def driz(exps): """Performs rudimentary drizzling This function does the rudimentary drizzling (intended for) visit-level products. It uses crude parameters, so the images output in this stage should only be used for alignment or simple data checks. The output of this function is a drizzled image. It checks the number of images to be drizzled and changes some of the drizzle parameters (CR rejection ones) to make the images more useful. Parameters ---------- exps : list List of exposures to be drizzled Returns ------- Nothing """ hdr = fits.getheader(exps[0]) if hdr['INSTRUME'] == 'WFC3': filt = hdr['FILTER'] elif hdr['INSTRUME'] == 'ACS': filt = hdr['FILTER1'] if filt == 'CLEAR1L' or filt == 'CLEAR1S': filt = hdr['FILTER2'] targ = hdr['TARGNAME'] prop = hdr['PROPOSID'] vis = exps[0][4:6] inst = hdr['INSTRUME'] det = hdr['DETECTOR'] pvis = exps[0][1:6] print targ, filt, len(exps) fname = '_'.join([filt,targ,inst,det,pvis]).lower() combine_nhigh = 1 med_alg = 'iminmed' if len(exps) > 9: med_alg = 'imedian' if len(exps) > 13: combine_nhigh = 3 if os.path.exists(fname+'_drz.fits') or os.path.exists(fname+'_drc.fits'): return if det == 'IR' or len(exps)<2: astrodrizzle.AstroDrizzle(exps,output=fname, mdriztab=False, num_cores=1, in_memory=True,median=False, clean=True,build=True, blot=False,driz_cr=False,runfile='adriz_{}'.format(fname)) else: astrodrizzle.AstroDrizzle(exps,output=fname,num_cores=1, in_memory=True, clean=True, build=True, combine_type=med_alg, runfile='adriz_{}'.format(fname), mdriztab=False, combine_nhigh=combine_nhigh)
def run_aDriz(targnames): names = np.loadtxt(targnames,dtype=str) for nn in range(len(names)): temp_dir_606 = names[nn] + '_f606w/' temp_dir_814 = names[nn] + '_f814w/' astrodrizzle.AstroDrizzle(temp_dir_606 + "*.fits",\ configobj=upperDir+'astrodrizzle_new.cfg') # astrodrizzle.AstroDrizzle(temp_dir_814 + "*.fits",\ configobj=upperDir+'astrodrizzle_new.cfg') return None
def mydrizzle(input_files, output_file, kernel='lanczos3', refimage=None, logfile=None, verbose=False, clean=True, **kwargs): if isinstance(input_files, str): input_files = [input_files] N_files = len(input_files) logger = RegularPrint() if verbose else PrintRedirect(logfile) d_kwgs = { 'clean': clean, 'build': True, 'skysub': False, 'final_units': 'counts', 'mdriztab': False, 'combine_type': ('median' if N_files >= 4 else 'minmed'), 'combine_nhigh': (1 if N_files == 4 else 0), 'final_kernel': kernel, # 'wcskey': wcsname, 'final_rot': 0., 'final_wcs': True, 'final_refimage': (refimage or ''), } d_kwgs.update(kwargs) print(f' Drizzling Images with {kernel} kernel to {output_file}') with logger: print(d_kwgs) astrodrizzle.AstroDrizzle( input_files, output=output_file, **d_kwgs)
def test_perf(self, output, in_memory, num_cores, use_static, skywidth): # Prepare input files. raw_inputs = ["ib6m02d9q_flt.fits", "ib6m02daq_flt.fits"] inputs = [os.path.basename(self.get_input_file('input', i)) for i in raw_inputs] # Merge common parameter settings with test-specific settings input_pars = {'build':True, 'preserve':False, 'clean':True, 'sky_bits':None} input_pars['output'] = output input_pars['in_memory'] = in_memory input_pars['num_cores'] = num_cores input_pars['use_static'] = use_static input_pars['skywidth'] = skywidth run_file = '{}.log'.format(output) input_pars['runfile'] = run_file # Update WCS for all inputs driz_inputs = updatewcs.updatewcs(inputs, use_db=False) # run astrodrizzle now... parObj = teal.load('astrodrizzle', defaults=True) # get all default values astrodrizzle.AstroDrizzle(driz_inputs, configobj=parObj, **input_pars) # Compare results outfile = '{}_drz.fits'.format(output) reffile = 'reference_{}.fits'.format(output) outputs = [(outfile, reffile)] self.compare_outputs(outputs)
def test_kernels(self, output, kernel): input_file = 'j8bt06nyq_flt.fits' print("Running the test for kernel={}".format(kernel)) # Prepare input files. input_file = self.get_input_file('input', input_file) # run astrodrizzle now... parObj = teal.load('astrodrizzle', defaults=True) # get all default values parObj['output'] = output parObj['build'] = True parObj['in_memory'] = True parObj['runfile'] = 'drizzlepac.run' parObj['STATE OF INPUT FILES']['preserve'] = False parObj['STATE OF INPUT FILES']['clean'] = True parObj['STEP 1: STATIC MASK']['static'] = False parObj['STEP 2: SKY SUBTRACTION']['skysub'] = False parObj['STEP 3: DRIZZLE SEPARATE IMAGES']['driz_separate'] = False parObj['STEP 4: CREATE MEDIAN IMAGE']['median'] = False parObj['STEP 5: BLOT BACK THE MEDIAN IMAGE']['blot'] = False parObj['STEP 6: REMOVE COSMIC RAYS WITH DERIV, DRIZ_CR'][ 'driz_cr'] = False parObj['STEP 7: DRIZZLE FINAL COMBINED IMAGE']['final_kernel'] = kernel parObj['STEP 7: DRIZZLE FINAL COMBINED IMAGE'][ 'final_units'] = 'counts' astrodrizzle.AstroDrizzle(input_file, configobj=parObj) # Compare results outfile = '{}_drz.fits'.format(output) reffile = 'reference_{}.fits'.format(kernel) outputs = [(outfile, reffile)] self.compare_outputs(outputs)
def doFinalDrizzle(self): """ Does the final drizzling. :return: None """ #we can now perform the final drizzle to drizzle all FLT images to POL frames kwargs = { 'final_pixfrac': 1.0, 'skysub': False, 'final_outnx': 2300, 'final_outny': 2300, 'final_ra': 128.8369, 'final_dec': -45.1791, 'updatewcs': False, 'final_wcs': True, 'preserve': False, 'build': True, 'final_fillval': 1.0, #'final_wht_type': 'ERR', 'final_refimage': 'jbj901akq_flt.fits[1]' } for f in self.input: astrodrizzle.AstroDrizzle(input=f, mdriztab=False, editpars=False, **kwargs)
def run_adriz(flc_files): """ Runs AstroDrizzle in order to create cosmic ray masks and to obtain an estimate of the global sky background in new keyword 'mdrizsky'. """ # Assumes first 6 letters of a visit's images are all the same. common = flc_files[0][:6] search = '{}*flc.fits'.format(common) print('search term for AstroDrizzle: {}'.format(search)) # Check that really did capture all files with the search term. # You'll need do some hacking if this error should occur. for flc in flc_files: if common not in flc: print( "Error!! File {} does not match rest of visit with {}.".format( flc, common)) return astrodrizzle.AstroDrizzle(search, runfile='', output='', preserve=False, updatewcs=False, skysub=True, driz_cr=True, driz_cr_corr=True, driz_combine=False) # Remove unneeded files. unneeded_files = glob.glob('*med.fits') + glob.glob('*crclean.fits') \ + glob.glob('*blt.fits') + glob.glob('*single_mask.fits') \ + glob.glob('*wht.fits') + glob.glob('*sci.fits') \ + glob.glob('*staticMask.fits') + glob.glob('*skymatch*') for unneeded_file in unneeded_files: os.remove(unneeded_file)
def test_uvis_single(self): rootname = 'iacr51ohq' input_name = '{}_flt.fits'.format(rootname) output = '{}_drz.fits'.format(rootname) ref_file = 'reference_wfc3_uvis_single.fits' runfile = ref_file.replace('.fits','.log') # Prepare input files. input_file = os.path.basename(self.get_input_file('input', input_name)) input_pars = {'output': output, 'runfile':runfile, 'build':True, 'in_memory':True, 'preserve': False, 'clean':True, 'static':True, 'skysub':True, 'skywidth':0.3, 'use_static':False, 'sky_bits':None, 'driz_separate':False, 'median':False, 'blot':False, 'driz_cr':False} # Update wcs in input file driz_input = updatewcs.updatewcs(input_file) # run astrodrizzle now... parObj = teal.load('astrodrizzle', defaults=True) # get all default values astrodrizzle.AstroDrizzle(driz_input, mdriztab=False, configobj=parObj, **input_pars) # Compare results outputs = [(output, ref_file)] self.compare_outputs(outputs)
def test_uvis_asn(self): rootname = 'iacr51010' asn_file = '{}_asn.fits'.format(rootname) output = '{}_drz.fits'.format(rootname) ref_file = 'reference_wfc3_uvis_asn.fits' runfile = ref_file.replace('.fits','.log') # Prepare input files. input_files = [] input_asn = self.get_data('input', asn_file) for raw_file in raw_from_asn(asn_file, suffix='_flt.fits'): input_files.append(os.path.basename(self.get_input_file('input', raw_file))) # define input parameters to be used input_pars = {'output': output, 'runfile':runfile, 'build':True, 'in_memory':False, 'preserve': False, 'clean':True, 'static':True, 'skysub':True, 'skywidth':0.3, 'use_static':False, 'sky_bits':None} # run astrodrizzle now... parObj = teal.load('astrodrizzle', defaults=True) # get all default values astrodrizzle.AstroDrizzle(asn_file, mdriztab=False, configobj=parObj, **input_pars) # Compare results outputs = [(output, ref_file)] self.compare_outputs(outputs)
def do_astrodrizzle(filters, imdrizzlepath): """ Runs astrodrizzle in order to stack all images. Writes output as <filter>_drz.fits Note that we haven't dithered; the stack is just a higher S/N image of our FoV INPUTS: -------- filters : dictionary {filter : filelist} imdrizzle path : string path where full frame images have ben stored for stacking """ teal.unlearn( 'astrodrizzle' ) #teal mimics IRAF functionality, unlearn sets all parameters to default for filter in filters: if filter[0].lower() == 'f': #Check that we only have images if not os.path.isfile( os.path.join(imdrizzlepath, filter + '_drz.fits')): old_dir = os.getcwd() os.chdir( imdrizzlepath) #do the stacking in the imdrizzle directory astrodrizzle.AstroDrizzle('@%s.lis' % (filter), output=filter, build='yes', skysub=False) os.chdir(old_dir) #switch back to original working directory
def test_wfc3_ir_saturated(self): # Prepare input files. raw_inputs = ['ib5w02n0q_flt.fits', 'ib5w02naq_flt.fits', 'ib5w02njq_flt.fits'] inputs = [os.path.basename(self.get_input_file('input', i)) for i in raw_inputs] outname = 'wfc3_ir_sat' output = '{}_drz.fits'.format(outname) ref_file = 'reference_{}.fits'.format(outname) runfile = ref_file.replace('.fits','.log') # define input parameters to be used input_pars = {'output': outname, 'runfile':runfile, 'build':True, 'in_memory':False, 'preserve': False, 'clean':True, 'static':True, 'skysub':True, 'skystat':'mode', 'skylower':-100.0, 'use_static':False, 'sky_bits':None, 'driz_sep_bits':832, 'driz_cr_snr':'5.0 4.0', 'final_bits': 832} # run astrodrizzle now... parObj = teal.load('astrodrizzle', defaults=True) # get all default values astrodrizzle.AstroDrizzle(inputs, mdriztab=False, configobj=parObj, **input_pars) # Compare results outputs = [(output, ref_file)] self.compare_outputs(outputs)
def run(self, meta): outmeta = {} for i in self.group: inputlist = [] for j in i: source = meta[j]['FILE'] destination = self.outpath + source.split('/')[-1] shutil.copyfile(source, destination) inputlist.append(destination) for j, jj in enumerate(i): x = fits.open(meta[jj]['FILE']) ext = meta[jj]['EXT'] xdata = meta[jj]['CLEAN'] x[ext].data = copy.deepcopy(xdata) x.writeto(inputlist[j], overwrite=True) x.close() self.params['final_refimage'] = inputlist[0] self.params['output'] = inputlist[0].split('flt')[0] astrodrizzle.AstroDrizzle(input=inputlist, **self.params) for j, jj in enumerate(i): source = inputlist[j] os.remove(source) outfile = self.params['output'] + '_drz.fits' outmeta[i[0]] = copy.deepcopy(meta[i[0]]) outmeta[i[0]]['FILE'] = copy.deepcopy(outfile) outmeta[i[0]]['CLEAN'] = copy.deepcopy( fits.open(outfile)[outmeta[i[0]]['EXT']].data) return outmeta
def test_acs_narrowband(self): rootname = 'j8dw01010' asn_file = rootname + '_asn.fits' # Prepare input files. # TODO: Why is input_file not referenced? input_file = self.get_data('input', asn_file) for raw_file in raw_from_asn(asn_file, suffix='_flt.fits'): self.get_input_file('input', raw_file) # run astrodrizzle now... parObj = teal.load('astrodrizzle', defaults=True) # get all default values parObj['build'] = True parObj['runfile'] = 'drizzlepac.run' parObj['STATE OF INPUT FILES']['preserve'] = False parObj['STATE OF INPUT FILES']['clean'] = True parObj['STEP 2: SKY SUBTRACTION']['use_static'] = False parObj['STEP 2: SKY SUBTRACTION']['sky_bits'] = None parObj['STEP 4: CREATE MEDIAN IMAGE']['combine_maskpt'] = 0.7 parObj['STEP 4: CREATE MEDIAN IMAGE']['combine_nsigma'] = '6 3' parObj['STEP 4: CREATE MEDIAN IMAGE']['combine_nhigh'] = 1 parObj['STEP 6: REMOVE COSMIC RAYS WITH DERIV, DRIZ_CR'][ 'driz_cr_snr'] = '3.0 2.5' parObj['STEP 7: DRIZZLE FINAL COMBINED IMAGE']['final_bits'] = 8578 parObj['STEP 7a: CUSTOM WCS FOR FINAL OUTPUT']['final_wcs'] = True parObj['STEP 7a: CUSTOM WCS FOR FINAL OUTPUT']['final_rot'] = 0.0 astrodrizzle.AstroDrizzle(asn_file, configobj=parObj) # Compare results outputs = [('j8dw01010_drz.fits', 'reference_narrowband.fits')] self.compare_outputs(outputs)
def simple_drizzle(images, coverage_map, wcs_file, filt): """ Naively drizzle the images onto the final wcs grid Uses astrodrizzle to combine input images into single stacked image. Uses the coverage map created in create_coverage_map to determine the "median depth" of the image (how many images per output image pixel)- useful for choosing best algorithm for median combine. Output image is on same pixel grid as the image specified by wcs_file parameter. The coverage map filename is the typical input. This image is not an optimized drizzled image, and is meant to give a basic stack. The drizzled image is stored as <FILT>_dr[cz].fits (drc or drz based on input images). Parameters ---------- images : list List of image filenames to drizzle. Must be fits files. coverage_map : numpy.ndarray File created via create_coverage_map, i.e. total number of input images per output pixel wcs_file : string File to read WCS from to get the output grid of the drizzled image. Use the filename of the coverage map for simplicity. filt : string The filter the images were taken with. Used for naming output image """ # This calculates how many of the input images cover each # pixel of the output image grid. Used to determine best # median algorithm for drizzle median_coverage = np.median(coverage_map[coverage_map > 0]) out_name = '{}_final'.format(filt) if median_coverage > 4: med_alg = 'median' combine_nhigh = 1 else: med_alg = 'minmed' combine_nhigh = 0 # Due to bug in astrodrizzle, this can't yet be optimized # to use the mdriztab astrodrizzle.AstroDrizzle(images, clean=True, build=True, context=False, preserve=False, combine_type=med_alg, combine_nhigh=combine_nhigh, in_memory=False, final_wcs=True, final_refimage=wcs_file, output=out_name)
def drizzle_singlefilt(df_driz, mean_ra, mean_dec, nx, ny, scale=0.0498, outfilebase='drizzle'): ''' do the thing ''' detector = df_driz.DETECTOR.unique()[0] filt = df_driz.FILTER.unique()[0] print('Drizzling images for {} {}'.format(detector,filt)) wht1 = 'IVM' if detector == 'WFC': native_scale = 0.049 wht2 = 'ERR' bits = '~128' final_kernel='lanczos3' elif detector == 'UVIS': native_scale = 0.04 wht2 = 'EXP' bits = None final_kernel='lanczos3' elif detector == 'IR': native_scale = 0.13 wht2 = 'EXP' bits = None final_kernel='square' else: print('Detector not recognized!') final_nx = np.ceil(nx * (native_scale / scale)).astype(int) final_ny = np.ceil(ny * (native_scale / scale)).astype(int) print('Final image size: {} x {} pix'.format(final_nx, final_ny)) flist = (df_driz.index+'.fits').values.tolist() print('Input images:', flist) outfile1 = '_'.join([outfilebase, filt]) print('Drizzle output base:', outfile1) for wht in [wht1, wht2]: teal.unlearn('astrodrizzle') if wht == 'IVM': driz_cr_snr = '2 1.5' else: driz_cr_snr = '4 3' astrodrizzle.AstroDrizzle(flist, output=outfile1 + '_{}'.format(wht), combine_type='median', driz_cr_snr=driz_cr_snr, final_pixfrac=1.0, final_scale=scale, final_bits=bits, final_wht_type=wht, final_kernel=final_kernel, final_outnx=final_nx, final_outny=final_ny, final_ra=mean_ra, final_dec=mean_dec, skysub=False, clean=True) return outfile1
def image_drizzle_product(self, ref_image, total_shape, configobj): """ Create the drizzle-combined exposure image using the reference image as the reference output """ astrodrizzle.AstroDrizzle(input=self.full_filename, output=self.drizzle_filename, final_refimage=ref_image, final_outnx=total_shape[1], final_outny=total_shape[0], runfile=self.trl_filename, configobj=configobj) # Rename Astrodrizzle log file as a trailer file shutil.move(self.trl_filename, self.trl_filename.replace('.log', '.txt'))
def test_fuv_mama(self): """ This test confirms that drizzlepac can correcly apply the distortion model for STIS FUV MAMA data and create a combined product. """ # Prepare input files. raw_inputs = [ 'o60q02f3q_flt.fits', 'o60q02f4q_flt.fits', 'o60q02f6q_flt.fits', 'o60q02f8q_flt.fits', 'o60q02fbq_flt.fits', 'o60q02fcq_flt.fits', 'o60q02feq_flt.fits', 'o60q02fgq_flt.fits', 'o60q02fiq_flt.fits' ] all_inputs = [self.get_input_file('input', i) for i in raw_inputs] inputs = [os.path.basename(i) for i in all_inputs] print("[STIS_01] Found inputs: \n{}".format(inputs)) output = 'final_stis_01' outfile = '{}_drz.fits'.format(output) reffile = 'reference_stis_01.fits' # Update WCS for all inputs updatewcs.updatewcs(inputs, use_db=False) # run astrodrizzle now... adriz_parobj = teal.load('astrodrizzle', defaults=True) adriz_parobj['output'] = output adriz_parobj['build'] = True adriz_parobj['in_memory'] = True adriz_parobj['runfile'] = 'stis_01' adriz_parobj['STATE OF INPUT FILES']['preserve'] = False adriz_parobj['STATE OF INPUT FILES']['clean'] = True adriz_parobj['STEP 1: STATIC MASK']['static_sig'] = 3.0 adriz_parobj['STEP 2: SKY SUBTRACTION']['skystat'] = 'mean' adriz_parobj['STEP 2: SKY SUBTRACTION']['skywidth'] = 0.1 adriz_parobj['STEP 2: SKY SUBTRACTION']['skylower'] = -50.0 adriz_parobj['STEP 2: SKY SUBTRACTION']['skyupper'] = 200.0 adriz_parobj['STEP 2: SKY SUBTRACTION']['use_static'] = False adriz_parobj['STEP 2: SKY SUBTRACTION']['sky_bits'] = None adriz_parobj['STEP 3: DRIZZLE SEPARATE IMAGES'][ 'driz_separate'] = False adriz_parobj['STEP 4: CREATE MEDIAN IMAGE']['median'] = False adriz_parobj['STEP 5: BLOT BACK THE MEDIAN IMAGE']['blot'] = False adriz_parobj['STEP 6: REMOVE COSMIC RAYS WITH DERIV, DRIZ_CR'][ 'driz_cr'] = False astrodrizzle.AstroDrizzle(inputs, configobj=adriz_parobj) # Compare results outputs = [(outfile, reffile)] self.compare_outputs(outputs)
def wcs_drizzle_product(self, meta_wcs, configobj): """ Create the drizzle-combined filter image using the meta_wcs as the reference output """ edp_filenames = [element.full_filename for element in self.edp_list] astrodrizzle.AstroDrizzle(input=edp_filenames, output=self.drizzle_filename, final_refimage=meta_wcs, final_outnx=meta_wcs.pixel_shape[1], final_outny=meta_wcs.pixel_shape[0], runfile=self.trl_filename, configobj=configobj) # Rename Astrodrizzle log file as a trailer file shutil.move(self.trl_filename, self.trl_filename.replace('.log', '.txt'))
def wcs_drizzle_product(self, meta_wcs, configobj): """ Create the drizzle-combined exposure image using the meta_wcs as the reference output """ # AstroDrizzle will soon take a meta_wcs object which contains outnx, outny astrodrizzle.AstroDrizzle(input=self.full_filename, output=self.drizzle_filename, final_refimage=meta_wcs, final_outnx=meta_wcs.pixel_shape[1], final_outny=meta_wcs.pixel_shape[0], runfile=self.trl_filename, configobj=configobj) # Rename Astrodrizzle log file as a trailer file shutil.move(self.trl_filename, self.trl_filename.replace('.log', '.txt'))
def driz_all(fltlist, ad_dict, drzext = 'drz'): ''' Function to create the individual drizzled images using one image as reference :fltlist: List of flt files to be processed. Processing will happen in the provided order. The first image of the list will be used as reference :dict: Dictionary of parameters to pass to astrodrizzle ''' ref = fltlist[0].replace('flt', drzext) for im in fltlist: if os.path.exists(ref): print('Ref:',ref) astrodrizzle.AstroDrizzle(im,driz_sep_refimage=ref, final_refimage=ref, **ad_dict) else: astrodrizzle.AstroDrizzle(im, **ad_dict)
def test_stis_ccd(self): """ This test confirms that drizzlepac can correcly apply the distortion model for STIS CCD data and create a combined product. """ # Prepare input files. raw_inputs = [ 'o6cl10arq_flt.fits', 'o6cl10asq_flt.fits', 'o6cl10atq_flt.fits', 'o6cl10auq_flt.fits', 'o6cl10axq_flt.fits', 'o6cl10ayq_flt.fits', 'o6cl10azq_flt.fits', 'o6cl10b0q_flt.fits' ] all_inputs = [self.get_input_file('input', i) for i in raw_inputs] inputs = [os.path.basename(i) for i in all_inputs] output = 'final_stis_04' outfile = '{}_drz.fits'.format(output) reffile = 'reference_stis_04.fits' # Update WCS for all inputs updatewcs.updatewcs(inputs, use_db=False) # run astrodrizzle now... adriz_parobj = teal.load('astrodrizzle', defaults=True) adriz_parobj['output'] = output adriz_parobj['build'] = True adriz_parobj['in_memory'] = True adriz_parobj['runfile'] = 'stis_04' adriz_parobj['STATE OF INPUT FILES']['preserve'] = False adriz_parobj['STATE OF INPUT FILES']['clean'] = True adriz_parobj['STEP 1: STATIC MASK']['static_sig'] = 3.0 adriz_parobj['STEP 2: SKY SUBTRACTION']['skywidth'] = 0.1 adriz_parobj['STEP 2: SKY SUBTRACTION']['skylower'] = -50.0 adriz_parobj['STEP 2: SKY SUBTRACTION']['skyupper'] = 200.0 adriz_parobj['STEP 2: SKY SUBTRACTION']['use_static'] = False adriz_parobj['STEP 2: SKY SUBTRACTION']['sky_bits'] = None adriz_parobj['STEP 4: CREATE MEDIAN IMAGE']['combine_maskpt'] = 0.7 adriz_parobj['STEP 4: CREATE MEDIAN IMAGE']['combine_type'] = 'median' adriz_parobj['STEP 4: CREATE MEDIAN IMAGE']['combine_nsigma'] = '6 3' adriz_parobj['STEP 4: CREATE MEDIAN IMAGE']['combine_nhigh'] = 1 adriz_parobj['STEP 7: DRIZZLE FINAL COMBINED IMAGE'][ 'final_bits'] = 528 astrodrizzle.AstroDrizzle(inputs, configobj=adriz_parobj) # Compare results outputs = [(outfile, reffile)] self.compare_outputs(outputs)
def funcdrz_psfsub(drz, obs, tar, source='qso', nx=64, ny=64, pixsize=0.13, final_pixfrac=1., fn_final_refimage='drz.fits'): """ astrodrizzle flt_bestfit_psf.fits to produce drz_psf.fits and subtract it from drz.fits to get drz_psfsub_source.fits. Crop drz.fits and drz_psfsub.fits to get drz_crop.fits and drz_psfsub_crop.fits Args: # fixed arguments: drz obs tar # user arguments: source='qso' nx=64 (int): cutout size in x ny=64 (int): cutout size in y pixsize=0.13 (float): in arcsec final_pixfrac=1. (float): drizzle drop size """ s = drz.sources[source] if not os.path.isdir(s.directory): os.mkdir(s.directory) drz.fp_psf = s.directory+'drz_psf.fits' drz.fp_psfsub = s.directory+'drz_psfsub.fits' fp_flt_psfs = [flt.sources[source].directory+'flt_bestfit_psf.fits' for flt in drz.flts] adz.AstroDrizzle(input=fp_flt_psfs, output=drz.fp_psf, static=False, build=True, skysub=True, driz_cr=False, preserve=False, runfile=drz.directory+'astrodrizzle_psfsub.log', final_pixfrac=final_pixfrac, final_refimage=drz.directory+fn_final_refimage) # PSF subtraction hdus = fits.open(drz.fp_local) hdus_psf = fits.open(drz.fp_psf) data_psfsub = hdus[1].data - hdus_psf[1].data hdus[1].data = data_psfsub hdus[1].header['HISTORY'] = 'IMAGE REPLACED BY PSF SUBTRACTED IMAGE' hdus[0].header['HISTORY'] = 'SCI IMAGE REPLACED BY PSF SUBTRACTED IMAGE' for i in range(2, len(hdus)): # removing extensions => 2. hdus.pop() hdus.writeto(drz.fp_psfsub, overwrite=True) # crop cutouts f = tinyfit.imgfitter.imgfitter(filename=drz.directory+'drz.fits', nx=nx, ny=ny, pixsize=pixsize) f._crop(xc=s.x, yc=s.y) f.img_crop.writeto(s.directory+'drz_crop.fits') f_psub = tinyfit.imgfitter.imgfitter(filename=drz.fp_psfsub, nx=nx, ny=ny, pixsize=pixsize) f_psub._crop(xc=s.x, yc=s.y) f_psub.img_crop.writeto(s.directory+'drz_psfsub_crop.fits') f_psf = tinyfit.imgfitter.imgfitter(filename=drz.fp_psf, nx=nx, ny=ny, pixsize=pixsize) f_psf._crop(xc=s.x, yc=s.y) f_psf.img_crop.writeto(s.directory+'drz_psf_crop.fits')
def drzImage(flt, pscale, rot): """drzImage: Drizzle out a image with no cr-cleaning to be used for alignment""" ad.AstroDrizzle(flt, static=False, skysub=True, driz_separate=False, median=False, blot=False, driz_cr=False, num_cores=4, preserve=False, context=False, final_wcs=True, final_scale=pscale, final_rot=rot) return
def run(self,meta): out = {} for i in self.group: inputlist = [] for j in i: source = meta[j]['FILE'] destination = self.outpath + source.split('/')[-1] shutil.copyfile(source,destination) inputlist.append(destination) astrodrizzle.AstroDrizzle(input=inputlist, **self.params) for j,jj in enumerate(i): source = inputlist[j] os.remove(source) new = source.split('flt')[0] + 'crclean.fits' out[jj] = new return out
def run_astrodrizzle(input_files, drizzle_options): input_dict = {'runfile': '', 'build': True, 'preserve': False, 'skystat': 'mode', 'skylower': 0., 'driz_sep_fillval': -100000., 'driz_sep_wcs': True, 'combine_maskpt': 0.2, 'combine_lthresh': -10000., 'combine_type': 'mean' if len(input_files) == 1 else 'minmed', 'final_fillval': -50000., 'final_units': 'counts', 'final_wcs': True} # These parameters were either set by default or passed in by the user for key in ['output', 'final_pixfrac', 'clean', 'num_cores', 'skysub']: if key in drizzle_options: input_dict[key] = drizzle_options[key] if 'refimage' in drizzle_options: driz_opts_to_include = ['bits', 'refimage'] else: driz_opts_to_include = ['bits', 'rot', 'scale', 'outnx', 'outny', 'ra', 'dec'] for key in driz_opts_to_include: if key in drizzle_options: input_dict['driz_sep_' + key] = drizzle_options[key] input_dict['final_' + key] = drizzle_options[key] astrodrizzle.AstroDrizzle(input_files, **input_dict) # add the sky value back in # only add the sky to non flagged pixels (-50k) if '_flc.fits' in input_files[0]: output_filename = drizzle_options['output'] + '_drc.fits' else: output_filename = drizzle_options['output'] + '_drz.fits' sci_hdu = fits.open(output_filename) sci_data = sci_hdu['SCI'].data mask = sci_data <= input_dict['final_fillval'] if drizzle_options.get('skysub') in [True, None]: sci_data[~mask] -= np.min(sci_data[~mask]) sci_data[mask] = 0.0 sci_hdu.writeto(output_filename, overwrite=True) # remove temporary files missed by astrodrizzle's clean = True for filename in glob('*_skymatch_mask*.fits') + glob('*_staticMask.fits'): os.remove(filename)
def test_waiver_single(self): """ This test confirms that drizzlepac can correcly process . """ # Prepare input files. raw_inputs = ["u40x010hm_c0f.fits", "u40x010hm_c1f.fits"] inputs = [ os.path.basename(self.get_input_file('input', i)) for i in raw_inputs ] output = 'wfpc2_single_waiver' outfile = '{}_drz.fits'.format(output) reffile = 'reference_single_waiver.fits' # Update WCS for all inputs driz_inputs = updatewcs.updatewcs(inputs[0], use_db=False) # run astrodrizzle now... adriz_parobj = teal.load('astrodrizzle', defaults=True) adriz_parobj['output'] = output adriz_parobj['build'] = True adriz_parobj['in_memory'] = False adriz_parobj['runfile'] = 'wfpc2_single_waiver.log' adriz_parobj['STATE OF INPUT FILES']['preserve'] = False adriz_parobj['STATE OF INPUT FILES']['clean'] = True adriz_parobj['STEP 1: STATIC MASK']['static'] = False adriz_parobj['STEP 2: SKY SUBTRACTION']['skysub'] = True adriz_parobj['STEP 2: SKY SUBTRACTION']['skystat'] = 'mode' adriz_parobj['STEP 2: SKY SUBTRACTION']['skywidth'] = 0.3 adriz_parobj['STEP 2: SKY SUBTRACTION']['skylower'] = -100.0 adriz_parobj['STEP 2: SKY SUBTRACTION']['use_static'] = False adriz_parobj['STEP 2: SKY SUBTRACTION']['sky_bits'] = None adriz_parobj['STEP 3: DRIZZLE SEPARATE IMAGES'][ 'driz_separate'] = False adriz_parobj['STEP 4: CREATE MEDIAN IMAGE']['median'] = False adriz_parobj['STEP 5: BLOT BACK THE MEDIAN IMAGE']['blot'] = False adriz_parobj['STEP 6: REMOVE COSMIC RAYS WITH DERIV, DRIZ_CR'][ 'driz_cr'] = False astrodrizzle.AstroDrizzle(driz_inputs, configobj=adriz_parobj) # Compare results outputs = [(outfile, reffile)] self.compare_outputs(outputs)
def dumb_drizzle(drz, false_images): drz_hdr0 = fits.getheader(drz) out = '_'.join(drz.split('_')[:-1]) + '_star' astrodrizzle.AstroDrizzle(false_images, build=True, clean=True, in_memory=True, final_refimage=drz, final_wcs=True, skysub=False, median=False, blot=False, driz_cr=False, driz_separate=False, static=False, final_pixfrac=drz_hdr0['D001PIXF'], preserve=False, context=False, output=out)
def initialProcessing(self): """ Does the initial processing as follows: 1. use astrodrizzle to combine images of the same POL filter using the shifts file generated by the tweakreg at point one. """ #run astrodrizzle separately for each POL kwargs = dict(final_pixfrac=1.0, final_fillval=1.0, preserve=False, updatewcs=True, final_wcs=False, build=True, skysub=False) for f in self.input: astrodrizzle.AstroDrizzle(input=f, mdriztab=False, editpars=False, **kwargs)
def test_waiver_asn(self): """ This test confirms that drizzlepac can correcly process input WFPC2 data stored in WAIVER fits format. """ # Prepare input files. raw_inputs = [ 'u40x010hm_c0f.fits', 'u40x010im_c0f.fits', 'u40x010jm_c0f.fits', 'u40x010km_c0f.fits', 'u40x010hm_c1f.fits', 'u40x010im_c1f.fits', 'u40x010jm_c1f.fits', 'u40x010km_c1f.fits' ] inputs = [ os.path.basename(self.get_input_file('input', i)) for i in raw_inputs ] output = 'wfpc2_waiver' outfile = '{}_drz.fits'.format(output) reffile = 'reference_wfpc2_asn_waiver.fits' # Update WCS for all inputs driz_inputs = updatewcs.updatewcs(inputs[:4], use_db=False) # run astrodrizzle now... adriz_parobj = teal.load('astrodrizzle', defaults=True) adriz_parobj['output'] = output adriz_parobj['build'] = True adriz_parobj['in_memory'] = True adriz_parobj['runfile'] = 'wfpc2_asn_waiver.log' adriz_parobj['STATE OF INPUT FILES']['preserve'] = False adriz_parobj['STATE OF INPUT FILES']['clean'] = True adriz_parobj['STEP 1: STATIC MASK']['static_sig'] = 3.0 adriz_parobj['STEP 2: SKY SUBTRACTION']['skysub'] = False astrodrizzle.AstroDrizzle(driz_inputs, configobj=adriz_parobj) # Compare results outputs = [(outfile, reffile)] self.compare_outputs(outputs)
def test_mef_asn(self): """ This test confirms that drizzlepac can correcly process input WFPC2 data stored in Multi-extensions FITS(MEF) format. """ # Prepare input files. raw_inputs = [ 'u9yq0703m_c0m.fits', 'u9yq0704m_c0m.fits', 'u9yq0707m_c0m.fits', 'u9yq0708m_c0m.fits', 'u9yq0703m_c1m.fits', 'u9yq0704m_c1m.fits', 'u9yq0707m_c1m.fits', 'u9yq0708m_c1m.fits' ] inputs = [ os.path.basename(self.get_input_file('input', i)) for i in raw_inputs ] output = 'wfpc2_mef' outfile = '{}_drz.fits'.format(output) reffile = 'reference_wfpc2_asn_mef.fits' # Update WCS for all inputs driz_inputs = updatewcs.updatewcs(inputs[:4], use_db=False) # run astrodrizzle now... adriz_parobj = teal.load('astrodrizzle', defaults=True) adriz_parobj['output'] = output adriz_parobj['build'] = True adriz_parobj['in_memory'] = True adriz_parobj['runfile'] = 'wfpc2_asn_mef.log' adriz_parobj['STATE OF INPUT FILES']['preserve'] = False adriz_parobj['STATE OF INPUT FILES']['clean'] = True adriz_parobj['STEP 2: SKY SUBTRACTION']['skysub'] = False astrodrizzle.AstroDrizzle(driz_inputs, configobj=adriz_parobj) # Compare results outputs = [(outfile, reffile)] self.compare_outputs(outputs)