def copy_exposure(self, filename): """ Create a copy of the original input to be renamed and used for multi-visit processing. New exposure filename needs to follow the MVM naming convention: hst_skycell-p<PPPP>x<XX>y<YY>_<instr>_<detector>_<filter>-<layer>_<ipppssoo>_fl[ct].fits Parameters ---------- filename : str Original pipeline filename for input exposure Returns ------- sce_filename : str New MVM-compatible HAP filename for input exposure """ suffix = filename.split("_")[1] sce_filename = '_'.join([self.product_basename, suffix]) log.info("Copying {} to MVM input: \n {}".format(filename, sce_filename)) try: shutil.copy(filename, sce_filename) except PermissionError: pass # Add HAPLEVEL keyword as required by pipeline processing fits.setval(sce_filename, 'HAPLEVEL', value=0, comment='Classificaion level of this product') return sce_filename
def chkeywd(fits_file, keyword, value, ext_number): if ext_number is None: extension_number = 0 else: extension_number = int(ext_number) # convert the keyword value input to the right type keyword = keyword.upper() if extension_number == 0: sample_kyewd_dict = shkvd.keywd_dict new_value = keywd_in_dict_or_new_keywd(sample_kyewd_dict, extension_number, keyword, value) elif extension_number == 1: sample_kyewd_dict = shkvd.keywd_dict["wcsinfo"] new_value = keywd_in_dict_or_new_keywd(sample_kyewd_dict, extension_number, keyword, value) else: new_value = new_keywd(extension_number, value) # now change the the value fits.setval(fits_file, keyword, extension_number, value=new_value) print('\n * Script change_keywd.py finished * \n')
def setwelldepth(date, filerange, welldepth): """ Manually set the well depth in a NIRI FITS header. date: date of the FITS file, e.g. 20201122 filerange: range of file numbers, e.g. 1-3,5,7-9 welldepth: the desired well depth, either 'shallow' or 'deep' """ biasvoltage = {'deep': -0.87, 'shallow': -0.60} # Detector bias voltage = VDDUC - VDET for i in expand(filerange): filename = 'N%sS%04d.fits' % (date,i) try: vdduc1 = fits.getval(filename, 'VDDUC') vdduc2 = fits.getval(filename, 'A_VDDUC') vdet1 = fits.getval(filename, 'VDET') vdet2 = fits.getval(filename, 'A_VDET') except: print('%s Not found' % filename) continue bias1 = vdduc1 - vdet1 bias2 = vdduc2 - vdet2 if abs(bias1 - biasvoltage[welldepth]) < 0.05 and \ abs(bias2 - biasvoltage[welldepth]) < 0.05: #print('%s %.3f - %.3f = %.3f %s' % (filename, vdduc1, vdet1, bias1, welldepth.upper())) print('%s is already set to %s well' % (filename, welldepth.upper())) else: newvdet1 = vdduc1 - biasvoltage[welldepth] newvdet2 = vdduc2 - biasvoltage[welldepth] #print('%s %.3f - %.3f = %.3f --> setting VDET = %.2f' % (filename, vdduc1, vdet1, bias1, newvdet1)) print('%s is now set to %s well' % (filename, welldepth.upper())) fits.setval(filename, 'VDET', value=newvdet1) fits.setval(filename, 'A_VDET', value=newvdet2) return
def calibrate_samples(samples, tile_key="TILE", xycorr=True): comment = "Magnitude zero point" zps = get_zps() zpcorr = get_zp_correction() for sample in samples: wdir = os.path.join(context.data_dir, sample, "cutouts") if not os.path.exists(wdir): continue galaxies = sorted(os.listdir(wdir)) desc = "Calibrating galaxies of sample {}".format(sample) for galaxy in tqdm(galaxies, desc=desc): galdir = os.path.join(wdir, galaxy) stamps = sorted( [_ for _ in os.listdir(galdir) if _.endswith(".fits")]) for stamp in stamps: filename = os.path.join(galdir, stamp) h = fits.getheader(filename, ext=1) tile = h[tile_key] filtername = h["FILTER"] idx = np.where((zps["FIELD"] == tile))[0] if len(idx) == 0: print("Calibration not found for tile: {}".format(tile)) continue zp = float(zps[idx][filtername].data[0]) if xycorr: x0 = h["X0TILE"] y0 = h["Y0TILE"] zp += float(zpcorr[filtername](x0, y0)[0][0]) fits.setval(filename, "MAGZP", value=round(zp, 7), comment=comment, ext=1)
def multiple_data_products_post_save(dps): logger.info(f'Running post save hook for multiple DataProducts: {dps}') for dp in dps: if dp.data.path.endswith('-e91.fits.fz'): logger.info(f'Starting spikepipe on {dp}') spikey_thread = threading.Thread(target=run_spikepipe, args=[dp]) spikey_thread.start() elif dp.data.path.endswith('.tar.gz'): logger.info(f'Saving extracted spectrum from {dp}') with tarfile.open(dp.data.path) as f: for member in f.getmembers(): if member.name.endswith('_2df_ex.fits'): extracted_spectrum = DataProduct( target=dp.target, observation_record=dp.observation_record, data_product_type='spectroscopy', data=File(f.extractfile(member), name=member.name)) extracted_spectrum.save() fits.setval(extracted_spectrum.data.path, 'ORIGIN', value='LCOGT') # for SpectroscopyProcessor run_custom_data_processor(extracted_spectrum, {}) else: logger.info(f'{dp} has no post save hook')
def append_bc_to_reduced_files(date, root='/Volumes/BERGRAID/data/veloce/'): print('Appending barycentric corrections to the reduced spectra of ' + str(date) + '...') acq_list, bias_list, dark_list, flat_list, skyflat_list, domeflat_list, arc_list, thxe_list, laser_list, laser_and_thxe_list, stellar_list, unknown_list = get_obstype_lists( root + 'raw_goodonly/' + date + '/') stellar_list.sort() obsnames = short_filenames(stellar_list) print('Calculating barycentric correction for stellar observation:') for i, (file, obsname) in enumerate(zip(stellar_list, obsnames)): print(str(i + 1) + '/' + str(len(stellar_list))) bc = get_barycentric_correction(file) bc = np.round(bc, 2) if np.isnan(bc): bc = '' # write the barycentric correction into the FITS header of both the quick-extracted and the optimal-extracted reduced spectrum files sublist = glob.glob(root + 'reduced/' + date + '/*' + obsname + '*extracted*') for outfn in sublist: pyfits.setval(outfn, 'BARYCORR', value=bc, comment='barycentric velocity correction [m/s]') print('DONE!') return
def change_keyword2ips_value(ips_keywd_dict, st_pipe_ready_dict, ips_keywd, st_pipe_ready_keywd, st_pipe_ready_file, verbose=False): """ Function changes the keyword value to match IPS value. :param ips_keywd_dict: dictionary, IPS header :param st_pipe_ready_dict: dictionary, STScI pipeline-ready file header :param st_pipe_ready_keywd: string, keyword with STScI spelling :param ips_keywd: string, keyword with IPS spelling :param st_pipe_ready_file: string, path and name of the fits file that is STScI pipeline-ready :param verbose: boolean :return: nothing """ for key, val in st_pipe_ready_dict.items(): if key == st_pipe_ready_keywd: if ips_keywd in ips_keywd_dict: fits.setval(st_pipe_ready_file, st_pipe_ready_keywd, value=ips_keywd_dict[ips_keywd]) if verbose: print('Modified keyword: ', key, ' old_value=', val, ' new_value=', ips_keywd_dict[ips_keywd]) else: if verbose: print( 'IPS keyword ', ips_keywd, ', corresponding to ', st_pipe_ready_keywd, 'in STScI pipeline, not found in header of IPS file.') break
def test_superdark3_pass(self): fits.setval(self.superdark, 'PCTE_VER', value='0.1_gamma') assert_equals( superdark_hash(superdark=self.superdark), superdark_hash( pctetab=self.pctetab, files=['abc_cte.fits', 'def_cte.fits', 'hij_cte.fits']))
def make_refbias(input_list, refbias_name='refbias.fits'): """Create a refbias FITS file Parameters ---------- input_list : list list of input bias files refbias_name : str name of the output bias reference file """ print('#-------------------------------#') print('# Running refbias #') print('#-------------------------------#') print('Making refbias %s' % (refbias_name)) joined_out = refbias_name.replace('.fits', '_joined.fits') print('Joining images to %s' % joined_out) functions.msjoin(input_list, joined_out) print('Checking for cosmic ray rejection') crj_filename = functions.crreject(joined_out) shutil.copy(crj_filename, refbias_name) flag_hot_pixels(refbias_name) functions.update_header_from_input(refbias_name, input_list) fits.setval(refbias_name, 'TASKNAME', ext=0, value='refbias') print('Cleaning up...') functions.RemoveIfThere(crj_filename) functions.RemoveIfThere(joined_out) print('refbias done for {}'.format(refbias_name))
def Extract_BeamCutout(self): beams = self.grp.get_beams(self.galaxy_id) pa = -1 for i in beams: if i.grism.filter == 'G102': if pa != i.get_dispersion_PA(): pa = i.get_dispersion_PA() i.write_fits(root='../beams/o{0}'.format(pa), clobber=True) fits.setval('../beams/o{0}_{1}.{2}.A.fits'.format( pa, self.galaxy_id, i.grism.filter), 'EXPTIME', ext=0, value=fits.open( '../beams/o{0}_{1}.{2}.A.fits'.format( pa, self.galaxy_id, i.grism.filter))[1].header['EXPTIME']) pa = -1 for i in beams: if i.grism.filter == 'G141': if pa != i.get_dispersion_PA(): pa = i.get_dispersion_PA() i.write_fits(root='../beams/o{0}'.format(pa), clobber=True) fits.setval('../beams/o{0}_{1}.{2}.A.fits'.format( pa, self.galaxy_id, i.grism.filter), 'EXPTIME', ext=0, value=fits.open( '../beams/o{0}_{1}.{2}.A.fits'.format( pa, self.galaxy_id, i.grism.filter))[1].header['EXPTIME'])
def write_template(filename, flux, wave, header=None, hdrref=None, clobber=False): if not header and hdrref: header = pyfits.getheader(hdrref) hdu = pyfits.PrimaryHDU(header=header) warnings.resetwarnings( ) # supress nasty overwrite warning http://pythonhosted.org/pyfits/users_guide/users_misc.html warnings.filterwarnings('ignore', category=UserWarning, append=True) hdu.writeto(filename, clobber=clobber, output_verify='fix') warnings.resetwarnings() warnings.filterwarnings('always', category=UserWarning, append=True) if isinstance(flux, np.ndarray): pyfits.append(filename, flux) pyfits.append(filename, wave) else: # pad arrays with zero to common size maxpix = max(arr.size for arr in flux if isinstance(arr, np.ndarray)) flux_new = np.zeros((len(flux), maxpix)) wave_new = np.zeros((len(flux), maxpix)) for o, arr in enumerate(flux): if isinstance(arr, np.ndarray): flux_new[o, :len(arr)] = arr for o, arr in enumerate(wave): if isinstance(arr, np.ndarray): wave_new[o, :len(arr)] = arr pyfits.append(filename, flux_new) pyfits.append(filename, wave_new) pyfits.setval(filename, 'EXTNAME', value='SPEC', ext=1) pyfits.setval(filename, 'EXTNAME', value='WAVE', ext=2)
def get_iris(num, direc, band): bd = str(band) iras_number = str(int(num)) if num < 100: iras_number = '0' + iras_number if num < 10: iras_number = '0' + iras_number hcon = 0 hnum = str(hcon) result = glob.glob(direc + '/?' + iras_number + '?' + bd + '?' + hnum + '.*') count = len(result) if count > 0: fits.setval(result[0], 'CDELT3', value=1) #TEST: modify header ifile = fits.open(result[0]) imap = ifile[0].data[0] header = fits.open(result[0])[0].header #sxaddpar sets LONPOLE to 180, but already there. bad = np.where((imap < -5) + (imap == 0))[0] nbbad = len(bad) if nbbad > 0: map[bad] = -32768 else: print("error: could not find data file for ISSA number", iras_number, "and band", bd) return imap, header
def main(): parser = OptionParser("usage: %prog key value image1.fits [image2 ...]") parser.add_option("-v", "--verbose", dest="verbose", action="count", help="Enable 'DEBUG' output in python log") parser.add_option("-e", "--ext", dest="hdu", default=0, metavar="HDU", help="HDU where key will be setted.") (options, args) = parser.parse_args() if options.verbose is None: logger.setLevel('WARN') elif options.verbose == 1: logger.setLevel('INFO') else: logger.setLevel('DEBUG') key = args[0] value = args[1] files = args[2:] for i in files: logger.debug("setting key:{} with value:{} on {}".format( key, value, i)) fits.setval(i, key, value=value, ext=options.hdu)
def copy_exposure(self, filename): """ Create a copy of the original input to be renamed and used for single-visit processing. New exposure filename needs to follow the convention: hst_<propid>_<obsetid>_<instr>_<detector>_<filter>_<ipppssoo>_fl[ct].fits Parameters ---------- filename : str Original pipeline filename for input exposure Returns ------- edp_filename : str New SVM-compatible HAP filename for input exposure """ suffix = filename.split("_")[1] edp_filename = self.basename + \ "_".join(map(str, [self.filters, filename[:8], suffix])) log.info("Copying {} to SVM input: \n {}".format(filename, edp_filename)) shutil.copy(filename, edp_filename) # Add HAPLEVEL keyword as required by pipeline processing fits.setval(edp_filename, 'HAPLEVEL', value=0, comment='Classificaion level of this product') return edp_filename
def test_superdark3_reject(self): fits.setval(self.pctetab, 'nsemodel', value=6) assert_not_equals( superdark_hash(superdark=self.superdark), superdark_hash( pctetab=self.pctetab, files=['abc_cte.fits', 'def_cte.fits', 'hij_cte.fits']))
def test_superdark4_reject(self): fits.setval(self.pctetab, 'PCTE_VER', value='0.2_alpha') assert_not_equals( superdark_hash(superdark=self.superdark), superdark_hash( pctetab=self.pctetab, files=['abc_cte.fits', 'def_cte.fits', 'hij_cte.fits']))
def append_relints_to_FITS(relints, fn, nfib=19): #prepare information on fibres fibinfo = [ 'inner ring', 'outer ring (2)', 'outer ring (1)', 'inner ring', 'outer ring (2)', 'outer ring (1)', 'inner ring', 'outer ring (2)', 'outer ring (1)', 'central', 'outer ring (2)', 'outer ring (1)', 'inner ring', 'outer ring (2)', 'outer ring (1)', 'inner ring', 'outer ring (2)', 'outer ring (1)', 'inner ring' ] #numbering of fibres as per Jon Lawrence's diagram (email from 22/02/2018 #ie correspoding to the following layout: # L S1 S3 S4 X I O2 O1 I O2 O1 I O2 O1 C O2 O1 I O2 O1 I O2 O1 I X S2 S5 ThXe # L S1 S3 S4 X 2 19 8 3 9 10 4 11 12 1 13 14 5 15 16 6 17 18 7 X S2 S5 ThXe #here O1 is the outer ring that is slightly further away from the centre!!! fibnums = [ 2, 19, 8, 3, 9, 10, 4, 11, 12, 1, 13, 14, 5, 15, 16, 6, 17, 18, 7 ] #the pseudoslit is reversed w.r.t. my simulations - we therefore turn the fibnums array around fibnums = fibnums[::-1] #loop over all fibres for i in np.arange(nfib): pyfits.setval(fn, 'RELINT' + str(i + 1).zfill(2), value=relints[i], comment='fibre #' + str(fibnums[i]) + ' - ' + fibinfo[i] + ' fibre') return
def test_superdark2_reject(self): fits.setval(self.superdark, 'PCTENSMD', value=5) assert_not_equals( superdark_hash(superdark=self.superdark), superdark_hash( pctetab=self.pctetab, files=['abc_cte.fits', 'def_cte.fits', 'hij_cte.fits']))
def putMJD(inim, case): hdr = fits.getheader(inim) if case == 'C1': mjdval = Time(hdr['JD'], format='jd', scale='utc').mjd fits.setval(inim, 'MJD', value=mjdval, comment='MJD appended') print 'header updated', fits.getheader(inim)['MJD'] elif case == 'C2': mjdval = Time(hdr['J_DATE'], format='jd', scale='utc').mjd fits.setval(inim, 'MJD', value=mjdval, comment='MJD appended') print 'header updated', fits.getheader(inim)['MJD'] elif case == 'C3': mjdval = Time(hdr['DATE-OBS'], format='isot', scale='utc').mjd fits.setval(inim, 'MJD', value=mjdval, comment='MJD appended') print 'header updated', fits.getheader(inim)['MJD'] elif case == 'C4': datetimestr = hdr['DATE-OBS'] + 'T' + hdr['TIME-OBS'] mjdval = Time(datetimestr, format='isot', scale='utc').mjd fits.setval(inim, 'MJD', value=mjdval, comment='MJD appended') elif case == 'C5': datetimestr = hdr['DATE-OBS'] + 'T' + hdr['UT'] mjdval = Time(datetimestr, format='isot', scale='utc').mjd fits.setval(inim, 'MJD', value=mjdval, comment='MJD appended') else: print 'Not in known cases.'
def make_refbias(input_list, refbias_name='refbias.fits'): """Create a refbias FITS file Parameters ---------- input_list : list list of input bias files refbias_name : str name of the output bias reference file """ print('#-------------------------------#') print('# Running refbias #') print('#-------------------------------#') print('Making refbias %s' % (refbias_name)) joined_out = refbias_name.replace('.fits', '_joined.fits') print('Joining images to %s' % joined_out) functions.msjoin(input_list, joined_out) print('Checking for cosmic ray rejection') crj_filename = functions.crreject(joined_out) shutil.copy(crj_filename, refbias_name) flag_hot_pixels(refbias_name) functions.update_header_from_input(refbias_name, input_list) fits.setval(refbias_name, 'TASKNAME', ext=0, value='refbias') print('Cleaning up...') functions.RemoveIfThere(crj_filename) functions.RemoveIfThere(joined_out) print('refbias done for {}'.format(refbias_name))
def main(): global deep_check pool = multiprocessing.Pool(processes=4) conf = json.load(open('/data7/DEEP/python/config.json')) deep_check = tf.keras.models.load_model(conf["ML_model"]) img_list = open('img.list').readlines() img_list = [i.strip() for i in img_list] list(pool.map(gen_diff, img_list)) trim_files = glob.glob('*trim*fits') for i in trim_files: os.remove(i) diff_img_list = glob.glob('*.diff.fits') check_result = check_img(diff_img_list) diff_img_list = np.array(diff_img_list) check_result = np.array(check_result) for n, j in enumerate(diff_img_list): print('{}: {}'.format(j, check_result[n])) if check_result[n] >= 0: fits.setval(j, 'ml_score', value=check_result[n]) else: gen_diff(j.replace('.diff.fits', '.fits'), num=1) ml_score = check_img([j])[0] print('{}: {}'.format(j, ml_score)) if ml_score > -5: fits.setval(j, 'ml_score', value=check_result[n]) else: os.remove(j) trim_files = glob.glob('*trim*fits') for i in trim_files: os.remove(i)
def make_basedark(input_list, refdark_name='basedark.fits', bias_file=None): """Make a monthly baseline dark from the input list. Parameters ---------- input_list: list list of input dark files refdark_name: str name of the output reference file bias_file: str bias file to be used in calibration """ print('#-------------------------------#') print('# Running basedark #') print('#-------------------------------#') print('output to: %s' % refdark_name) print('with biasfile %s' % bias_file) #-- bias subtract data if not already done flt_list = [functions.bias_subtract_data(item, bias_file) for item in input_list] for filename in flt_list: texpstrt = fits.getval(filename, 'texpstrt', 0) if texpstrt > 52091.0: functions.apply_dark_correction(filename, texpstrt) joined_filename = refdark_name.replace('.fits', '_joined.fits') crj_filename = joined_filename.replace('.fits', '_crj.fits') #if not bias_file: # raise IOError('No biasfile specified, this task needs one to run') print('Joining images') functions.msjoin(flt_list, joined_filename) print('Performing CRREJECT') crdone = functions.bd_crreject(joined_filename) if not crdone: functions.bd_calstis(joined_filename, bias_file) functions.normalize_crj(crj_filename) shutil.copy(crj_filename, refdark_name) update_sci(refdark_name) find_hotpix(refdark_name) functions.update_header_from_input(refdark_name, input_list) fits.setval(refdark_name, 'TASKNAME', ext=0, value='BASEDARK') print('Cleaning...') functions.RemoveIfThere(crj_filename) functions.RemoveIfThere(joined_filename) #map(functions.RemoveIfThere, flt_list) print('basedark done for {}'.format(refdark_name))
def test_restore_simple(self): # test restore on simple fits format altwcs.archiveWCS(self.simplefits, ext=0, wcskey='R') pyfits.setval(self.simplefits, ext=0, keyword='CRVAL1R', value=1) altwcs.restoreWCS(self.simplefits, ext=0, wcskey='R') wo = wcsutil.HSTWCS(self.simplefits, ext=0, wcskey='R') ws = wcsutil.HSTWCS(self.simplefits, ext=0) compare_wcs(ws, wo)
def test_restore_simple(self): # test restore on simple fits format altwcs.archive_wcs(self.simplefits, ext=0, wcskey='R') pyfits.setval(self.simplefits, ext=0, keyword='CRVAL1R', value=1) altwcs.restoreWCS(self.simplefits, ext=0, wcskey='R') wo = wcsutil.HSTWCS(self.simplefits, ext=0, wcskey='R') ws = wcsutil.HSTWCS(self.simplefits, ext=0) compare_wcs(ws, wo)
def fitsfix_6pt5(fitsfile): '''fixes the wcs header of a lenstool file generated using version 6.5''' fits.setval(fitsfile, 'CRPIX1', value=fits.getval(fitsfile, 'CRPIX1') + 0.5) fits.setval(fitsfile, 'CRPIX2', value=fits.getval(fitsfile, 'CRPIX2') + 0.5)
def destripe_plus(sy,scimask1='None',scimask2='None',cte_correct=True): # verify that the RAW image exists in cwd cwddir = os.getcwd() if not os.path.exists(cwddir+'/'+sy): sys.exit(sy + " RAW file does not exist. Quitting now!") #check if 2K subarray or full frame is_sub2K = False header = fits.getheader(sy) ctecorr = header['PCTECORR'] aperture = header['APERTURE'] subarray_list=['WFC1-2K', 'WFC1-POL0UV', 'WFC1-POL0V', 'WFC1-POL60V', 'WFC1-POL60UV', 'WFC1-POL120V', 'WFC1-POL120UV', 'WFC1-SMFL', 'WFC1-IRAMPQ', 'WFC1-MRAMPQ', 'WFC2-2K', 'WFC2-ORAMPQ', 'WFC2-SMFL', 'WFC2-POL0UV', 'WFC2-POL0V', 'WFC2-MRAMPQ'] if header['SUBARRAY'] and cte_correct: if aperture in subarray_list: is_sub2K = True else: print 'Using non-2K subarray, turning CTE correction off' cte_correct = False # run ACSCCD on RAW subarray acsccd.acsccd(sy) # execute destriping of the subarray (post-SM4 data only) acs_destripe.clean(sy.replace('raw','blv_tmp'), 'strp', clobber=False, maxiter=15, sigrej=2.0, mask1=scimask1, mask2=scimask2) os.rename(sy.replace('raw','blv_tmp_strp'),sy.replace('raw','blv_tmp')) #update subarray header if is_sub2K and cte_correct: fits.setval(sy.replace('raw','blv_tmp'),'PCTECORR',value='PERFORM') # perform CTE correction on destriped image if cte_correct: if ctecorr == 'PERFORM': acscte.acscte(sy.replace('raw','blv_tmp')) else: print "PCTECORR not set to 'PERFORM', cannot run CTE correction" cte_correct = False # run ACS2D to get FLT and FLC images acs2d.acs2d(sy.replace('raw','blv_tmp')) if cte_correct: acs2d.acs2d(sy.replace('raw','blc_tmp')) # delete intermediate files os.system("rm "+sy.replace('raw','blv_tmp')) if cte_correct: os.system("rm "+sy.replace('raw','blc_tmp')) print '__________________________________________________________' print " " print "FLT : ", sy.replace('raw','flt') if cte_correct: print "FLC : ", sy.replace('raw','flc') print " "
def save_fits_after_align(image_path, res_data): hdu = fits.open(image_path) hdu[0].data = res_data hdu.writeto(image_path[:-4]+'_aligned'+image_path[-4:], overwrite =True) if os.path.isfile(image_path[:-4]+'_aligned'+image_path[-4:]) : fits.setval(image_path[:-4]+'_aligned'+image_path[-4:], 'NOTES', value='aligned by [email protected]') return print('aligned fits file is created') else : return print('failure creating aligned fits file...')
def putmjd(i): try: hdr = fits.getheader(i) mjdval = Time(hdr['DATE-OBS'], format='isot', scale='utc').mjd fits.setval(i, 'MJD', value=mjdval, comment='MJD appended') print('header updated', fits.getheader(i)['MJD']) except: print(i, 'DATE-OBS keyword is missing')
def Write(self): if os.path.isfile(self.name): os.remove(self.name) self.hdu.writeto(self.name) self.hdu.header['i'] = '1' # Include data of the image in the Header of the .fits file for j in self.hdrData.keys(): fits.setval(self.name, j, value=self.hdrData[j])
def track_versions(self, files, apply_to="_raw"): """Add version keywords to raw_files(files).""" import caldp csys_ver = os.environ.get("CSYS_VER", "UNDEFINED") for filename in self.raw_files(files): if apply_to in filename: fits.setval(filename, "CSYS_VER", value=csys_ver) fits.setval(filename, "CALDPVER", value=caldp.__version__)
def scamp_astrometry_net0(im, projection='TAN', DETECT_THRESH='3'): contnum = scamp_net0(im, projection=projection, DETECT_THRESH='3') headmerge(im) fits.setval('sa' + im, 'FLXSCALE', value=1) fits.setval('sa' + im, 'SCAMPCON', value=contnum, hdrcomment='SCAMP cont. num') delhdrkey('sa' + im, kwds=kwds) return 'Done'
def scamp_non_astrometry_net(im, projection='TAN'): contnum = scamp_net(im, astref=False, projection=projection) swarpcom = 'swarp -c ' + astswarpconfig + ' ' + im + ' -IMAGEOUT_NAME sa' + im os.system(swarpcom) fits.setval('sa' + im, 'FLXSCALE', value=1) fits.setval('sa' + im, 'SCAMPCON', value=contnum, hdrcomment='SCAMP cont. num') delhdrkey('sa' + im, kwds=kwds)
def headerRenameKey2(self, key, newkey): for filename in self._matchingFiles: print('rename %s: %s= %s' % (filename, key, newkey)) try: value = fits.getval(filename, key) fits.setval(filename, newkey, value) fits.delval(filename, key) except Exception as e: print(str(e)) pass
def edit_cal_files(): for subdir in subdirlist: mydir = os.path.join(rootdir, subdir) rawfiles = glob.glob(os.path.join(mydir, '*_rawtag.fits')) for ref in reffiles: outputfolder = os.path.join(mydir, ref.split('_')[1].split('.')[0]) for myfile in rawfiles: fits.setval(myfile, 'XTRACTAB', value = '/user/esnyder/nuvxtractabproj/new1dxfiles/' + str(ref), ext = 0) asnfiles = glob.glob(os.path.join(mydir, '*_asn.fits')) parallel_cal(asnfiles, outputfolder)
def header_info(fitsfiles, switch_on): ''' setting values to "PERFORM" from "OMIT" ''' for f in fitsfiles: for kwd in switch_on: fits.setval(f, kwd, value='PERFORM') command_line_input = F'crds bestrefs --files {f} --sync-references=1 --update-bestrefs' os.system(command_line_input) return
def test_restore_wcs_mem(self): # test restore on an HDUList object altwcs.archiveWCS(self.acs_file, ext=[('SCI', 1), ('SCI', 2)], wcskey='T') pyfits.setval(self.acs_file, ext=('SCI', 1), keyword='CRVAL1', value=1) pyfits.setval(self.acs_file, ext=('SCI', 2), keyword='CRVAL1', value=1) f = pyfits.open(self.acs_file, mode='update') altwcs.restoreWCS(f, ext=1, wcskey='T') f.close() w1o = wcsutil.HSTWCS(self.acs_file, ext=1, wcskey='T') w1 = wcsutil.HSTWCS(self.acs_file, ext=1) compare_wcs(w1, w1o)
def wcs_photom(image,cat_file='nocat',conf_file='noconf',appsize=2.0,verbose=False): if not wcs_succeeded(image): return 'failed' outname = image + '.phot' casutools.imcore_list(image, cat_file, outname, confidence_map=conf_file,rcore=appsize, noell=True, verbose=verbose) # do some quality checks factor = 5 size = 11 stars = 1000 side = 3 #how many subdevisions of the chip along each axis. must be odd. fwhm_a, fwhm_b, t = call_find_fwhm(image,cat_file,factor,size,stars,tag=image,side=side) frame_ston = compute_frame_signal_to_noise(image) pf.setval(outname,'FRAME_SN',1,value=round(frame_ston,2),comment='A measure of bulk structure in the image (S/N)') positions = ['Top left.','Top middle.','Top right.','Middle left.','Center.','Middle right.','Bottom left.','Bottom middle.','Bottom right.'] for val in range(1,10): pf.setval(outname,'PSF_a_'+str(val),1,value=fwhm_a['f_'+str(val)][0],comment='[pixels] psf long axis FWHM. '+positions[val-1]) pf.setval(outname,'PSF_b_'+str(val),1,value=fwhm_b['f_'+str(val)][0],comment='[pixels] psf short axis FWHM. '+positions[val-1]) pf.setval(outname,'PSF_t_'+str(val),1,value=t['f_'+str(val)][0],comment='[degrees] psf rotation angle. '+positions[val-1]) #Â Compute the HJD values append_hjd_correction_column(outname) return 'ok'
def write_pixelscale(fits_file, value, ext=0): """ Write pixel scale information to a FITS file header The input pixel scale value is given in arcseconds but is stored in degrees since the chosen header KEYS are the linear transformation matrix parameters CDi_ja Parameters ---------- fits_file: str Path to a FITS image file value: float Pixel scale value in arcseconds ext: int, optional Extension number in the FITS file """ pixscl = value / 3600 comment = 'Linear transformation matrix' pyfits.setval(fits_file, 'CD1_1', value=pixscl, ext=ext, comment=comment) pyfits.setval(fits_file, 'CD1_2', value=0.0, ext=ext, comment=comment) pyfits.setval(fits_file, 'CD2_1', value=0.0, ext=ext, comment=comment) pyfits.setval(fits_file, 'CD2_2', value=pixscl, ext=ext, comment=comment)
def test_remove_d2im_distortion(): acs_orig_file = get_filepath('j94f05bgq_flt.fits') current_dir = os.path.abspath(os.path.curdir) acs_file = get_filepath('j94f05bgq_flt.fits', current_dir) idctab = get_filepath('postsm4_idc.fits') npol_file = get_filepath('qbu16424j_npl.fits') d2imfile = get_filepath('new_wfc_d2i.fits ') try: os.remove(acs_file) except OSError: pass shutil.copyfile(acs_orig_file, acs_file) fits.setval(acs_file, ext=0, keyword="IDCTAB", value=idctab) fits.setval(acs_file, ext=0, keyword="NPOLFILE", value=npol_file) fits.setval(acs_file, ext=0, keyword="D2IMFILE", value=d2imfile) updatewcs.updatewcs(acs_file) fits.setval(acs_file, keyword="D2IMFILE", value="N/A") updatewcs.updatewcs(acs_file) w1 = HSTWCS(acs_file, ext=("SCI", 1)) w4 = HSTWCS(acs_file, ext=("SCI", 2)) assert w1.det2im1 is None assert w4.det2im2 is None
def test_apply_d2im(): from stwcs.updatewcs import apply_corrections as appc acs_orig_file = get_filepath('j94f05bgq_flt.fits') current_dir = os.path.abspath(os.path.curdir) fname = get_filepath('j94f05bgq_flt.fits', current_dir) d2imfile = get_filepath('new_wfc_d2i.fits') try: os.remove(fname) except OSError: pass shutil.copyfile(acs_orig_file, fname) fits.setval(fname, ext=0, keyword="D2IMFILE", value=d2imfile) fits.setval(fname, ext=0, keyword="IDCTAB", value='N/A') fits.setval(fname, ext=0, keyword="NPOLFILE", value='N/A') # If D2IMEXT does not exist, the correction should be applied assert appc.apply_d2im_correction(fname, d2imcorr=True) updatewcs.updatewcs(fname) # Test the case when D2IMFILE == D2IMEXT assert not appc.apply_d2im_correction(fname, d2imcorr=True) assert not appc.apply_d2im_correction(fname, d2imcorr=False) fits.setval(fname, ext=0, keyword='D2IMFILE', value="N/A") assert not appc.apply_d2im_correction(fname, d2imcorr=True) # No D2IMFILE keyword in primary header fits.delval(fname, ext=0, keyword='D2IMFILE') assert not appc.apply_d2im_correction(fname, d2imcorr=True)
def test_update_d2im_distortion(): acs_orig_file = get_filepath('j94f05bgq_flt.fits') current_dir = os.path.abspath(os.path.curdir) acs_file = get_filepath('j94f05bgq_flt.fits', current_dir) idctab = get_filepath('postsm4_idc.fits') npol_file = get_filepath('qbu16424j_npl.fits') d2imfile = get_filepath('new_wfc_d2i.fits') newd2im = get_filepath('new_wfc_d2i.fits', current_dir) try: os.remove(acs_file) except OSError: pass shutil.copyfile(acs_orig_file, acs_file) fits.setval(acs_file, ext=0, keyword="IDCTAB", value=idctab) fits.setval(acs_file, ext=0, keyword="NPOLFILE", value=npol_file) fits.setval(acs_file, ext=0, keyword="D2IMFILE", value=d2imfile) updatewcs.updatewcs(acs_file) d2imerr1 = fits.getval(acs_file, ext=1, keyword='D2IMERR1') d2imerr4 = fits.getval(acs_file, ext=4, keyword='D2IMERR1') shutil.copyfile(d2imfile, newd2im) with fits.open(newd2im, mode='update') as newf: for ext in newf[1:]: ext.data = ext.data * 100 fits.setval(acs_file, keyword="D2IMFILE", value=newd2im) updatewcs.updatewcs(acs_file) nd2imerr1 = fits.getval(acs_file, ext=1, keyword='D2IMERR1') nd2imerr4 = fits.getval(acs_file, ext=4, keyword='D2IMERR1') assert np.isclose(d2imerr1 * 100, nd2imerr1) assert np.isclose(d2imerr4 * 100, nd2imerr4)
def make_basebias(input_list, refbias_name='basebias.fits'): """ Make the basebias for an anneal month 1- Calbrate each bias in the list 2- Average together the biases 3- Replace pixels and colums with median values 4- Set header keywords Parameters ---------- input_list : list list of input bias files. refbias_name : str name of the output reference file. """ print('#-------------------------------#') print('# Running basejoint #') print('#-------------------------------#') print('Output to %s' % refbias_name) print('Processing individual files') crj_list = [calibrate(item) for item in input_list] crj_list = [item for item in crj_list if item != None] mean_bias, totalweight = average_biases(crj_list) print('Replacing hot columns and pixels by median-smoothed values') residual_image, median_image = functions.make_residual(mean_bias) replace_hot_cols(mean_bias, median_image, residual_image) #-- then again, but only using the lower 20% of rows replace_hot_cols(mean_bias, median_image, residual_image, yfrac=.2) replace_hot_pix(mean_bias, median_image) shutil.copy(mean_bias, refbias_name) functions.update_header_from_input(refbias_name, input_list) fits.setval(refbias_name, 'NCOMBINE', value=totalweight, ext=1) fits.setval(refbias_name, 'TASKNAME', ext=0, value='BASEJOIN') print('Cleaning up...') functions.RemoveIfThere(mean_bias) for item in crj_list: functions.RemoveIfThere(item) print('basejoint done for {}'.format(refbias_name))
def test_missing_idctab(): """ Tests that an IOError is raised if an idctab file is not found on disk.""" acs_orig_file = get_filepath('j94f05bgq_flt.fits') current_dir = os.path.abspath(os.path.curdir) acs_file = get_filepath('j94f05bgq_flt.fits', current_dir) try: os.remove(acs_file) except OSError: pass shutil.copyfile(acs_orig_file, acs_file) fits.setval(acs_file, keyword="IDCTAB", value="my_missing_idctab.fits") with pytest.raises(IOError): updatewcs.updatewcs(acs_file)
def add_comments(fits_file, values): """ Add comments to the FITS header Parameters ---------- fits_file: str Path to a FITS image file values: str or str list Comment(s) to add """ if isinstance(values, str): pyfits.setval(fits_file, 'COMMENT', value=values) else: for value in values: pyfits.setval(fits_file, 'COMMENT', value=value)
def stisExt2PrimKw(stisfiles): """ Several kw which are usuall yin the primary header are in the extension header for STIS. They are copied to the primary header for convenience. List if kw: 'DATE-OBS', 'EXPEND', 'EXPSTART', 'EXPTIME' """ kw_list = ['DATE-OBS', 'EXPEND', 'EXPSTART', 'EXPTIME'] for sfile in stisfiles: d = {} for k in kw_list: d[k] = fits.getval(sfile, k, ext=1) for item in d.items(): fits.setval(sfile, item[0], value=item[1], comment='Copied from extension header')
def bd_crreject(joinedfile): """ Check if cosmic-ray rejection has been performed on input file if cosmic-ray rejection has already been done on the input bias image, skip all calstis-related calibration steps """ print(joinedfile) fd = pyfits.open(joinedfile) nimset = fd[0].header['nextend'] / 3 nrptexp = fd[0].header['nrptexp'] crcorr = fd[0].header['crcorr'] crdone = 0 if (crcorr == "COMPLETE") : crdone = 1 print('OK, CR rejection already done') os.rename(joinedfile, joinedfile.replace('_joined', '_crj') ) else: print(('crcorr found = ' + crcorr)) if (nimset <= 1 and not crdone): print("Sorry, your input image seems to have only 1 imset, but it isn't cr-rejected.") print("This task can only handle 'raw' or 'flt images with the NEXTEND keyword equal to 3*N (N > 1).") print("Bye now... better luck next time!") raise ValueError( 'Something bad happened' ) if not crdone: print('FYI: CR rejection not already done') print(('Keyword NRPTEXP = ' + str(nrptexp) + ' while nr. of imsets = ' + str(nimset))) if (nrptexp != nimset): pyfits.setval( joinedfile,'NRPTEXP',value=nimset) pyfits.setval( joinedfile,'CRSPLIT',value=1) print(('>>>> Updated keyword NRPTEXP to '+str(nimset) )) print(' (and set keyword CRSPLIT to 1)' ) print((' in ' + joinedfile )) return crdone
def test_missing_d2imfile(): """ Tests that an IOError is raised if a D2IMFILE file is not found on disk.""" acs_orig_file = get_filepath('j94f05bgq_flt.fits') current_dir = os.path.abspath(os.path.curdir) acs_file = get_filepath('j94f05bgq_flt.fits', current_dir) try: os.remove(acs_file) except OSError: pass shutil.copyfile(acs_orig_file, acs_file) fits.setval(acs_file, keyword="D2IMFILE", value="missing_d2i.fits") with pytest.raises(IOError): updatewcs.updatewcs(acs_file) fobj = fits.open(acs_file) with pytest.raises(IOError): updatewcs.updatewcs(fobj)
def setup_class(self): acs_orig_file = get_filepath('j94f05bgq_flt.fits') simple_orig_file = get_filepath('simple.fits') current_dir = os.path.abspath(os.path.curdir) simple_file = get_filepath('simple.fits', current_dir) acs_file = get_filepath('j94f05bgq_flt.fits', current_dir) comp_file = get_filepath('comp.fits', current_dir) self.headerlet_name = get_filepath('acs_hlet.fits', current_dir) try: os.remove(acs_file) os.remove('comp.fits') os.remove(simple_file) except OSError: pass idctab = get_filepath('postsm4_idc.fits') npol_file = get_filepath('qbu16424j_npl.fits') d2imfile = get_filepath('new_wfc_d2i.fits ') shutil.copyfile(acs_orig_file, acs_file) shutil.copyfile(simple_orig_file, simple_file) fits.setval(acs_file, ext=0, keyword="IDCTAB", value=idctab) fits.setval(acs_file, ext=0, keyword="NPOLFILE", value=npol_file) fits.setval(acs_file, ext=0, keyword="D2IMFILE", value=d2imfile) updatewcs.updatewcs(acs_file) shutil.copyfile(acs_file, comp_file) self.comp_file = comp_file
def setup_class(self): self.obsname = 'j94f05bgq_flt.fits' refname = self.obsname.replace('_flt', '_flt_rdb') acs_orig_file = get_filepath(self.obsname) current_dir = os.path.abspath(os.path.curdir) self.ref_file = get_filepath(refname, current_dir) self.acs_file = get_filepath(self.obsname, current_dir) try: os.remove(self.acs_file) os.remove(self.ref_file) except OSError: pass idctab = get_filepath('postsm4_idc.fits') npol_file = get_filepath('qbu16424j_npl.fits') d2imfile = get_filepath('new_wfc_d2i.fits ') shutil.copyfile(acs_orig_file, self.acs_file) fits.setval(self.acs_file, ext=0, keyword="IDCTAB", value=idctab) fits.setval(self.acs_file, ext=0, keyword="NPOLFILE", value=npol_file) fits.setval(self.acs_file, ext=0, keyword="D2IMFILE", value=d2imfile) shutil.copyfile(self.acs_file, self.ref_file) updatewcs.updatewcs(self.acs_file, use_db=False)
def setup_class(self): acs_orig_file = get_filepath('j94f05bgq_flt.fits') current_dir = os.path.abspath(os.path.curdir) self.ref_file = get_filepath('j94f05bgq_flt_r.fits', current_dir) self.acs_file = get_filepath('j94f05bgq_flt.fits', current_dir) try: os.remove(self.acs_file) os.remove(self.ref_file) except OSError: pass idctab = get_filepath('postsm4_idc.fits') npol_file = get_filepath('qbu16424j_npl.fits') d2imfile = get_filepath('new_wfc_d2i.fits ') shutil.copyfile(acs_orig_file, self.acs_file) fits.setval(self.acs_file, ext=0, keyword="IDCTAB", value=idctab) fits.setval(self.acs_file, ext=0, keyword="NPOLFILE", value=npol_file) fits.setval(self.acs_file, ext=0, keyword="D2IMFILE", value=d2imfile) updatewcs.updatewcs(self.acs_file) #self.ref_file = ref_file shutil.copyfile(self.acs_file, self.ref_file) self.w1 = HSTWCS(self.acs_file, ext=1) self.w4 = HSTWCS(self.acs_file, ext=4) self.w = wcs.WCS()
def test_found_idctab(): """ Tests the return value of apply_corrections.foundIDCTAB().""" acs_orig_file = get_filepath('j94f05bgq_flt.fits') current_dir = os.path.abspath(os.path.curdir) acs_file = get_filepath('j94f05bgq_flt.fits', current_dir) npol_file = get_filepath('qbu16424j_npl.fits') d2imfile = get_filepath('new_wfc_d2i.fits ') try: os.remove(acs_file) except OSError: pass shutil.copyfile(acs_orig_file, acs_file) fits.setval(acs_file, ext=0, keyword="NPOLFILE", value=npol_file) fits.setval(acs_file, ext=0, keyword="D2IMFILE", value=d2imfile) fits.setval(acs_file, keyword="IDCTAB", value="N/A") corrections = apply_corrections.setCorrections(acs_file) assert('MakeWCS' not in corrections) assert('TDDCor' not in corrections) assert('CompSIP' not in corrections) fobj = fits.open(acs_file) corrections = apply_corrections.setCorrections(fobj) assert('MakeWCS' not in corrections) assert('TDDCor' not in corrections) assert('CompSIP' not in corrections)
def test_restore_wcs_from_to(self): # test restore from ... to ... pyfits.setval(self.acs_file, ext=('SCI', 1), keyword='CRVAL1', value=1) pyfits.setval(self.acs_file, ext=('SCI', 2), keyword='CRVAL1', value=1) f = pyfits.open(self.acs_file, mode='update') altwcs.restore_from_to(f, fromext='SCI', toext=['SCI', 'ERR', 'DQ'], wcskey='T') f.close() w1o = wcsutil.HSTWCS(self.acs_file, ext=('SCI', 1), wcskey='T') w1 = wcsutil.HSTWCS(self.acs_file, ext=('SCI', 1)) compare_wcs(w1, w1o) w2 = wcsutil.HSTWCS(self.acs_file, ext=('ERR', 1)) compare_wcs(w2, w1o, exclude_keywords=['ctype']) w3 = wcsutil.HSTWCS(self.acs_file, ext=('DQ', 1)) compare_wcs(w3, w1o, exclude_keywords=['ctype']) w4o = wcsutil.HSTWCS(self.acs_file, ext=4, wcskey='T') w4 = wcsutil.HSTWCS(self.acs_file, ext=('SCI', 2)) compare_wcs(w4, w4o) w5 = wcsutil.HSTWCS(self.acs_file, ext=('ERR', 2)) compare_wcs(w5, w4o, exclude_keywords=['ctype']) w6 = wcsutil.HSTWCS(self.acs_file, ext=('DQ', 2)) compare_wcs(w3, w1o, exclude_keywords=['ctype'])
def setval(filepath, key, value): """Set metadata `key` in file `filepath` to `value`.""" ftype = config.filetype(filepath) if ftype == "fits": if key.upper().startswith(("META.","META_")): key = key.replace("META_", "META.") return _dm_setval(filepath, key, value) else: return pyfits.setval(filepath, key, value=value) elif ftype == "asdf": return _dm_setval(filepath, key, value) else: raise NotImplementedError("setval not supported for type " + repr(ftype))
def m_frame_shift(imagelist, index): try: image1 = imagelist[index - 1] image2 = imagelist[index] RA_shift, DEC_shift, tot_shift, RA, DEC = frame_shift(image1, image2) pf.setval(image2 + '.phot', 'RA_MOVE', 1, value=RA_shift, comment='RA shift from previous image [arcseconds]') pf.setval(image2 + '.phot', 'DEC_MOVE', 1, value=DEC_shift, comment='Dec shift from previous image [arcseconds]') pf.setval(image2 + '.phot', 'SKY_MOVE', 1, value=tot_shift, comment='Total movement on sky [arcseconds]') pf.setval(image2 + '.phot', 'WCSF_RA', 1, value=RA_shift, comment='RA center pix') pf.setval(image2 + '.phot', 'WCSF_DEC', 1, value=DEC_shift, comment='Dec center pix') except Exception as err: print "Exception handled in m_frame_shift: {}".format(str(err))
def checkPA_V3(fnames): removed_files = [] for f in fnames: try: pav3 = fits.getval(f, 'PA_V3') except KeyError: rootname = fits.getval(f, 'ROOTNAME') sptfile = rootname+'_spt.fits' if fileutil.findFile(sptfile): try: pav3 = fits.getval(sptfile, 'PA_V3') except KeyError: print("Warning: Files without keyword PA_V3 detected") removed_files.append(f) fits.setval(f, 'PA_V3', value=pav3) else: print("Warning: Files without keyword PA_V3 detected") removed_files.append(f) if removed_files != []: print("Warning: Removing the following files from input list") for f in removed_files: print('\t',f) return removed_files
def insert_dateobs(output, dateobs): """ Put the DATE-OBS keyword back into the AstroDrizzle outputs. AstroDrizzle removes this keyword, and it is needed for the database and ephemeris later. Parameters: output: string The renamed AstroDrizzle output the DATE-OBS keyword needs to be put back into. dateobs: string The value of the dateobs keyword from the original _flt or _c0m file. Returns: nothing Outputs: The AstroDrizzle output file, edited to include DATE-OBS. """ # Since we are changing only a single keyword, using the convenience # function is permissible. fits.setval(filename = output, keyword = 'date-obs', value = dateobs)
def create_superdarks( file_list ): print 'Creating superdarks' all_mjd = [pyfits.getval(item, 'EXPSTART', ext=1 ) for item in file_list ] file_list = np.array( file_list ) all_mjd = np.array( all_mjd ) step = 30 first_mjd = int(all_mjd.min()) end_mjd = int(all_mjd.max()) print 'Running from ', first_mjd, end_mjd for start in range( first_mjd, end_mjd, step)[:-1]: print start, '-->', start+step file_index = np.where( (all_mjd > start) & (all_mjd < start+step) )[0] if not len( file_index ): print 'WARNING, no files found for interval' dark_reffile = SuperDark( file_list[ file_index ] ) output = '{}_{}_drk.fits'.format( start, start+step ) dark_reffile.write( outname=output ) pyfits.setval( output, 'DATASTRT', ext=0, value=start ) pyfits.setval( output, 'DATAEND', ext=0, value=start+step )
def test_add_radesys(): """ test that RADESYS was successfully added to headers.""" acs_orig_file = get_filepath('j94f05bgq_flt.fits') current_dir = os.path.abspath(os.path.curdir) acs_file = get_filepath('j94f05bgq_flt.fits', current_dir) idctab = get_filepath('postsm4_idc.fits') npol_file = get_filepath('qbu16424j_npl.fits') d2imfile = get_filepath('new_wfc_d2i.fits ') try: os.remove(acs_file) except OSError: pass shutil.copyfile(acs_orig_file, acs_file) fits.setval(acs_file, ext=0, keyword="IDCTAB", value=idctab) fits.setval(acs_file, ext=0, keyword="NPOLFILE", value=npol_file) fits.setval(acs_file, ext=0, keyword="D2IMFILE", value=d2imfile) updatewcs.updatewcs(acs_file) for ext in [('SCI', 1), ('SCI', 2)]: hdr = fits.getheader(acs_file, ext) assert hdr['RADESYS'] == 'FK5'
def conv(filter): ''' Takes data (in the form of a FITS file) and convolves with a PSF. Keywords filter: the filter that the data considered is imaged in Options - SPIRE: psw (250 micron) pmw (350 micron) plw (500 micron) Options - PACS: 70 (70 micron) 100 (100 micron) 160 (160 micron) psf: the filename of the point spread function of the filter considered Example: SPIRE 250 micron PSF has filename 'theoretical_spire_beam_model_psw_V0_2' This file *must* be present in folder 'psf' ''' ################################# Read data #################################### # Determine the current working directory direc = os.getcwd() # Read in the FITS file containing the simulation results sim_result = fits.open(str(direc)+str('/')+str(filter)+str('.fits')) # Split into image data and header data data = sim_result[0].data hdu = sim_result[0].header # Pull out the total image width image_width = hdu['IMGWIDTH'] # In cm # Pull out the pixel width data_theta = hdu['PIXSIZE'] # Pixel size in "/pixel # Determine the size of one pixel data_size = (250*data_theta)/206256 # Extent of one pixel ############################# Read in FITS data ################################ # Read in the PSF # Given that the PSF has different file names depending on the filter under consideration, use this if statement to determine # which is the correct one if filter == 'psw': psf_raw = fits.open('/Users/tomasjames/Documents/University/Project/ZiggyStarDust/Code/datafiles/psf/ken/psf_0250.fits') elif filter == 'pmw': psf_raw = fits.open('/Users/tomasjames/Documents/University/Project/ZiggyStarDust/Code/datafiles/psf/theoretical_spire_beam_model_pmw_V0_2.fits') elif filter == 'plw': psf_raw = fits.open('/Users/tomasjames/Documents/University/Project/ZiggyStarDust/Code/datafiles/psf/theoretical_spire_beam_model_plw_V0_2.fits') # Extract the data psf = psf_raw[0].data psf_header = psf_raw[0].header # Assign cards to variables psf_theta_deg = psf_header['CDELT2'] # Pixel width in deg psf_theta = psf_theta_deg*3600. #image_width = hdu['IMGWIDTH'] # Image width in cm # Plot the data for comparison purposes subplot2grid((10,8), (0,0), colspan=8,rowspan=8) title(r'Raw SPIRE 250$\mu m$ PSF') matshow(psf,origin='lower') colorbar() xlabel('Pixel') ylabel('Pixel') ''' #tight_layout #grid(color='g',linestyle='-',linewidth=1) subplot2grid((10,8), (8,0), colspan=8,rowspan=2) plot(np.linspace(0,len(psf),len(psf)),psf[len(psf)/2]) xlim(min(np.linspace(0,len(psf),len(psf))), max(np.linspace(0,len(psf),len(psf)))) ylabel('Pixel Value') xlabel('Pixel') #tight_layout ''' savefig('psf.pdf',dpi=300) close() matshow(data,origin='lower') title(str('RADMC-3D Intensity Data for SPIRE ')+str(hdu['EFF'])+str('$ \mu m$')) #colorbar(label=r'$I_{\nu}$ [erg/s/cm/cm/Hz/ster]') colorbar(label=r'$I$ [MJy/ster]') savefig('data.pdf',dpi=300) close() ############################### Rebin the PSF ################################# # Take the data pixel size and determine how much larger/smaller it is than the PSF size_factor = data_theta/psf_theta # Convolve requires that the array be odd in dimension # Check to see if the size_factor is an odd number # This ensures the PSF is centered in the frame if (np.round(size_factor) % 2 == 0): print 'The dimensions of the PSF are even; altering to make the dimensions odd...\n' else: print 'The dimensions of the PSF are odd; proceeding as normal...\n' # Determine whether the pixel widths of the PSF and data differ if size_factor == 1: print 'The pixel sizes match!\n' psf_rebin = psf elif size_factor < 1: print 'The pixel sizes do not match, and the PSF has larger pixel size. Necessary to increase the size of the RADMC-3D image.\n' # This will resize the original data to be 1/2 the original size using the value closest to the original (method='neighbour') data = congrid(data, (len(data[0])*(1./2),len(data[:,0])*(1./2)),centre=True) imshow(data,origin='lower') title(r'Rebinned Data') #colorbar(label=r'$I_{\nu}$ [erg/s/cm/cm/Hz/ster]') colorbar(label=r'$I$ [MJy/ster]') savefig('data_rebin.png') close() # Determine the new angular size of each pixel data_theta = data_theta/(1./2) # Adjust the size factor accordingly size_factor = data_theta/psf_theta # Use the above rebin function to change the dimensions of the PSF to psf_rebin_unnorm = congrid(psf, ((psf_header['NAXIS1']/size_factor)+1,(psf_header['NAXIS2']/size_factor)+1),centre=True) # Renormalise the PSF back to unity (or close to it) psf_rebin = psf_rebin_unnorm*(np.sum(psf)/np.sum(psf_rebin_unnorm)) elif size_factor > 1: # Use the above rebin function to change the dimensions of the PSF to psf_rebin_unnorm = congrid(psf, ((psf_header['NAXIS1']/size_factor),(psf_header['NAXIS2']/size_factor)),centre=True) # Renormalise the PSF back to unity (or close to it) psf_rebin = psf_rebin_unnorm*(np.sum(psf)/np.sum(psf_rebin_unnorm)) # Determine the new pixel angular size new_psf_theta = psf_theta*size_factor # Save rebinned PSF to fits file fname = str('psf_rebin.fits') head = fits.PrimaryHDU(psf_rebin) head.writeto(fname) # Assign info to header fits.setval(fname, 'DISTANCE', value=hdu['DISTANCE']) fits.setval(fname, 'PIXSIZE', value=new_psf_theta) fits.setval(fname, 'EFF', value=hdu['EFF']) # Plot the resulting data to assess accuracy of rebin subplot2grid((10,8), (0,0), colspan=6,rowspan=6) title(r'Rebinned SPIRE 250$\mu m$ PSF') matshow(psf_rebin,origin='lower') colorbar() xlabel('Pixel') ylabel('Pixel') ''' # major ticks every 20, minor ticks every 5 major_ticks = np.arange(0, len(psf_rebin[0]), 10) minor_ticks = np.arange(0, len(psf_rebin[0]), 1) xticks(major_ticks) xticks(minor_ticks) yticks(major_ticks) yticks(minor_ticks) grid(which='minor',linestyle='-',alpha=0.2) grid(which='major',linestyle='-',alpha=0.2) subplot2grid((10,8), (8,0), colspan=8,rowspan=2) plot(np.linspace(0,len(psf_rebin[len(psf_rebin)/2]),len(psf_rebin[len(psf_rebin)/2])),psf_rebin[len(psf_rebin)/2]) xlim(min(np.linspace(0,len(psf_rebin),len(psf_rebin))), max(np.linspace(0,len(psf_rebin),len(psf_rebin)))) ylabel('Pixel Value') xlabel('Pixel') #tight_layout ''' savefig('psf_rebin.pdf',dpi=300) close() # Determine dimensions of the new image psf_rebin_x = len(psf_rebin) psf_rebin_y = len(psf_rebin[0]) # Print statements for debug print 'The raw PSF "/pixel:', psf_theta, '\n' print 'The raw data "/pixel:', data_theta, '\n' print 'The rebinned PSF "/pixel:', new_psf_theta, '\n' print 'The PSF image has now been rebinned to have dimensions', psf_rebin_x, 'x', psf_rebin_y, '. The new image has also been saved to the working directory.\n' ############################### Convolve the data ############################## print 'Currently convolving...' # Use the convolution to convolve the rebinned data with the PSF #conv = convolve(data, psf_rebin, boundary='extend') conv = convolve_fft(data, psf_rebin) print 'Convolution complete!\nSaving the image...\n' # Plot the resulting convolution #imshow(conv,origin='lower',vmin=0,vmax=1) matshow(conv,origin='lower') #colorbar(label=r'$I_{\nu}$ [erg/s/cm/cm/Hz/ster]') colorbar(label=r'$I$ [MJy/ster]') title(str('Convolved Data for SPIRE ')+str(hdu['EFF'])+str(r'$ \mu m$')) savefig('convolved.pdf',dpi=300) close() # Save to a FITS file # Check to see whether file has already been written # If so, delete the file (Python cannot overwrite a binary file) if os.path.isfile(str(filter)+str('_convolved.fits')) == True: os.remove(str(filter)+str('_convolved.fits')) # Do the write fname = str(filter)+str('_convolved.fits') head = fits.PrimaryHDU(conv) head.writeto(fname) # Write some header information # Write relevant information to the FITS header fits.setval(fname, 'DISTANCE', value=hdu['DISTANCE']) fits.setval(fname, 'IMGWIDTH', value=hdu['IMGWIDTH']) fits.setval(fname, 'PIXWIDTH', value=hdu['PIXWIDTH']) fits.setval(fname, 'PIXSIZE', value=data_theta) fits.setval(fname, 'EFF', value=hdu['EFF']) print 'The convolution has been performed and the convolved image saved to the working directory.\n' ############################### Check image power ############################## # Begin with default, non altered image raw_power = np.sum(np.sum(data)) # Repeat for convolved image convolved_power = np.sum(np.sum(conv)) # Print a statement to the terminal to show overall power print 'The initial power in the image is ', raw_power print 'The power in the convolved image is ', convolved_power
def regress(folder): """ Run *drk and *bia files in folder through CalSTIS to check for errors in processing """ start_dir = os.getcwd() print('#------------------#') print('Running regression for') print(folder) print('#------------------#') monitor_dir = '/grp/hst/stis/darks_biases' test_suite = os.path.join(monitor_dir, 'test_suite') test_dark = os.path.join(monitor_dir, 'test_dark') print((glob.glob(os.path.join(folder, '*bia.fits')))) reference_files = glob.glob(os.path.join(folder, '*bia.fits')) + \ glob.glob(os.path.join(folder, '*drk.fits')) print(reference_files) assert len(reference_files) >= 1, 'No reference files in folder' print('Copying files and removing old files') for testing_dir in [test_suite, test_dark]: for oldfile in glob.glob(os.path.join(testing_dir, '*_drk.fits')) + \ glob.glob(os.path.join(testing_dir, '*_bia.fits')): print(('removing', oldfile)) os.remove(os.path.join(testing_dir, oldfile)) for newfile in reference_files: print(('moving', newfile, '-->', testing_dir)) shutil.copy(newfile, testing_dir) ####################################### # Run checks in the test_suite folder # ####################################### os.chdir(test_suite) print((os.getcwd())) bias_biwk_refs = glob.glob('*bias*_bi*.fits') bias_biwk_refs.sort() biasrefs = glob.glob('*bias*_wk*.fits') biasrefs.sort() darkrefs = glob.glob('*dark*.fits') darkrefs.sort() raws = glob.glob('*raw.fits') print('Setting IMPHTTAB in datasets') for dark, bias in zip(darkrefs, biasrefs): remove_products() print('#-------------------------------------------#') print(('Running CalSTIS with %s %s ' % (dark, bias))) print('#-------------------------------------------#') for rawfile in raws: if os.path.exists( rawfile.replace('raw.fits', 'wav.fits') ): wavefile = rawfile.replace('raw.fits', 'wav.fits') else: wavefile = '' pyfits.setval(rawfile, 'DARKFILE', value=dark, ext=0) pyfits.setval(rawfile, 'BIASFILE', value=bias, ext=0) pyfits.setval(rawfile, 'IMPHTTAB', value='oref$x9r1607mo_imp.fits', ext=0) if wavefile: pyfits.setval(wavefile, 'DARKFILE', value=dark, ext=0) pyfits.setval(wavefile, 'BIASFILE', value=bias, ext=0) pyfits.setval(wavefile, 'IMPHTTAB', value='oref$x9r1607mo_imp.fits', ext=0) status = calstis(rawfile, wavecal=wavefile) if status: sys.exit('Calstis Error detected for %s' % (dark[5:9])) ###################################### # Run checks in the test_dark folder # ###################################### os.chdir(test_dark) print((os.getcwd())) raws = glob.glob('*raw.fits') print('Setting IMPHTTAB in datasets') for item in raws: pyfits.setval(item, 'IMPHTTAB', value='oref$x9r1607mo_imp.fits', ext=0) for bias in bias_biwk_refs: remove_products() print('#------------------------------------------#') print(('Running CalSTIS with %s' % (bias))) print('#------------------------------------------#') for rawfile in raws: pyfits.setval(rawfile, 'BIASFILE', value=bias, ext=0) pyfits.setval(rawfile, 'DARKFILE', value=darkrefs[0], ext=0) status = calstis(input=rawfile) if status: sys.exit('Calstis Error detected for %s' % (dark[5:9])) os.chdir(start_dir)