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)
