def make_dark():
util.mkdir(sky_dir)
## COPY A SKY => use a dark
# shutil.copyfile(root_dir + '../../20210724/sta/dark/dark_044_scan.fits', sky_dir + 'fld2_sky_tmp.fits')
## CREATING A SKY
print("I quad flat (60)")
dark_num = np.arange(51, 55 + 1)
dark_frames = [
'{0:s}dark_{1:03d}.fits'.format(dark_dir, ss) for ss in dark_num
]
scan_dark_frames = [
'{0:s}dark_{1:03d}_scan.fits'.format(dark_dir, ss) for ss in dark_num
]
reduce_STA.treat_overscan(dark_frames)
calib.makedark(scan_dark_frames, calib_dir + 'fld2_dark60_IVBR.fits')
print("BVR quad flat (20)")
dark_num = np.arange(46, 50 + 1)
dark_frames = [
'{0:s}dark_{1:03d}.fits'.format(dark_dir, ss) for ss in dark_num
]
scan_dark_frames = [
'{0:s}dark_{1:03d}_scan.fits'.format(dark_dir, ss) for ss in dark_num
]
reduce_STA.treat_overscan(dark_frames)
calib.makedark(scan_dark_frames, calib_dir + 'fld2_dark20_IVBR.fits')
return
def calc_star_stats():
util.mkdir(stats_dir)
## Loop through all the different data sets
#for key in ['set_name']: ## Single key setup
#for key in ['open_IVBR', 'LS_IVBR', 'docz_IVBR']:
#for key in []:
for key in dict_suffix.keys():
img = dict_images[key]
suf = dict_suffix[key]
print('Working on: {1:s} {0:s}'.format(key, suf))
print(' Catalog: ', img)
img_files = [
out_dir +
'sta{img:03d}{suf:s}_scan_clean.fits'.format(img=ii, suf=suf)
for ii in img
]
stats_file = stats_dir + 'stats_' + key + '.fits'
redu.calc_star_stats(img_files, output_stats=stats_file)
moffat.fit_moffat(img_files, stats_file, flux_percent=0.2)
## DEBUG - single threaded
#key_i = 'open_BRIV'
#fmt = '{dir}sta{img:03d}{suf:s}_scan_clean.fits'
#image_file = fmt.format(dir=out_dir, img=dict_images[key_i][0], suf=dict_suffix[key_i])
#stats_file = f'{stats_dir}stats_{key_i}.fits'
#redu.calc_star_stats([image_file], output_stats=stats_file)
#moffat.fit_moffat_single(image_file,image_file.replace('.fits', '_stars_stats.fits'), 0.2)
return
def stack_FLD2():
util.mkdir(stacks_dir)
# Open Loop
open_images = [
out_dir + 'obj{0:03d}_o_scan_clean.fits'.format(ii) for ii in fnum_o
]
open_starlists = [
out_dir + 'obj{0:03d}_o_scan_clean_stars.txt'.format(ii)
for ii in fnum_o
]
open_output_root = stacks_dir + 'FLD2_stack_open'
reduce_fli.shift_and_add(open_images,
open_starlists,
open_output_root,
method='mean')
# Closed Loop - threeWFS_LS
closed_images = [
out_dir + 'obj{0:03d}threeWFS_LS_c_scan_clean.fits'.format(ii)
for ii in fnum_c
]
closed_starlists = [
out_dir + 'obj{0:03d}threeWFS_LS_c_scan_clean_stars.txt'.format(ii)
for ii in fnum_c
]
closed_output_root = stacks_dir + 'FLD2_stack_threeWFS_LS_c'
reduce_fli.shift_and_add(closed_images,
closed_starlists,
closed_output_root,
method='mean')
return
def reduce_FLD2():
util.mkdir(out_dir)
# Open Loop
img_files = [data_dir + 'obj{0:03d}_o.fits'.format(ii) for ii in fnum_o]
reduce_STA.treat_overscan(img_files)
scan_img_files = [
data_dir + 'obj{0:03d}_o_scan.fits'.format(ii) for ii in fnum_o
]
reduce_fli.clean_images(scan_img_files,
out_dir,
rebin=1,
sky_frame=sky_dir + 'FLD2_sky.fits',
flat_frame=flat_dir + "flat.fits")
# Closed - threeWFS_LS
img_files = [
data_dir + 'obj{0:03d}threeWFS_LS_c.fits'.format(ii) for ii in fnum_c
]
reduce_STA.treat_overscan(img_files)
scan_img_files = [
data_dir + 'obj{0:03d}threeWFS_LS_c_scan.fits'.format(ii)
for ii in fnum_c
]
reduce_fli.clean_images(scan_img_files,
out_dir,
rebin=1,
sky_frame=sky_dir + 'FLD2_sky.fits',
flat_frame=flat_dir + "flat.fits")
return
def calc_star_stats():
util.mkdir(stats_dir)
# Open Loop
img_files = [
out_dir + 'obj{0:03d}_o_scan_clean.fits'.format(ii) for ii in fnum_o
]
stats_file = stats_dir + 'stats_open.fits'
reduce_STA.calc_star_stats(img_files, output_stats=stats_file)
moffat.fit_moffat(img_files, stats_file)
#Closed Loop - LS
img_files = [
out_dir + 'obj{0:03d}LS_c_scan_clean.fits'.format(ii)
for ii in fnum_c_LS
]
stats_file = stats_dir + 'stats_closed_LS.fits'
reduce_STA.calc_star_stats(img_files, output_stats=stats_file)
moffat.fit_moffat(img_files, stats_file)
#Closed Loop - B2
img_files = [
out_dir + 'obj{0:03d}LS_Bin2_c_scan_clean.fits'.format(ii)
for ii in fnum_c_B2
]
stats_file = stats_dir + 'stats_closed_B2.fits'
reduce_STA.calc_star_stats(img_files, output_stats=stats_file)
moffat.fit_moffat(img_files, stats_file)
return
def make_flat():
"""
Make a flat... this will be with dome flats for now.
These are junk... replace with twilight flats.
"""
util.mkdir(calib_dir)
flat_num = np.arange(115, 120 + 1)
flat_frames = [
'{0:s}twi_{1:03d}.fits'.format(twi_dir, ss) for ss in flat_num
]
# reduce_STA.treat_overscan(flat_frames)
scan_flat_frames = [
'{0:s}twi_{1:03d}_scan.fits'.format(twi_dir, ss) for ss in flat_num
]
# calib.makeflat(scan_flat_frames, None, calib_dir + 'flat.fits', darks=False)
# Lets also make a mask to use when we call find_stars.
# This mask tells us where not to search for stars.
calib.make_mask(calib_dir + 'flat.fits',
calib_dir + 'mask.fits',
mask_min=0.8,
mask_max=1.4,
left_slice=20,
right_slice=20,
top_slice=25,
bottom_slice=25)
return
def make_flat():
"""
Makes flat and data mask.
Just for single filter I band
"""
util.mkdir(calib_dir)
## Copy flat from a previous night
#shutil.copyfile(root_dir + '../../20210724/sta/reduce/calib/flat_BRIV.fits', calib_dir + 'flat_BRIV.fits')
## Creating flat from range, I band only
flat_num = np.arange(105, 109 + 1)
flat_frames = [
'{0:s}sta{1:03d}_o.fits'.format(dome_dir, ss) for ss in flat_num
]
scan_flat_frames = [
'{0:s}sta{1:03d}_o_scan.fits'.format(dome_dir, ss) for ss in flat_num
]
reduce_STA.treat_overscan(flat_frames)
#For darks = use master dark as many times as there are flat frames => reduces noise
scan_dark_frames = [calib_dir + 'fld2_dark120.fits' for ss in flat_num]
calib.makeflat(scan_flat_frames,
scan_dark_frames,
calib_dir + 'domeflat.fits',
darks=True)
calib.make_mask(calib_dir + 'domeflat.fits',
calib_dir + 'domemask.fits',
mask_min=0.8,
mask_max=1.4,
left_slice=20,
right_slice=20,
top_slice=25,
bottom_slice=25)
return
def rebin_data():
"""
Takes the reduced files, and rebins them
this changes the sape of the file and the header.
"""
util.mkdir(out_dir + "bin2/")
binfac = 2
for key in dict_suffix.keys():
#for key in ["LS_3wfs_s_1"]:
img = dict_images[key]
suf = dict_suffix[key]
print('Rebinning: {1:s} {0:s}'.format(key, suf))
print(' Images: ', img)
img_files = [
out_dir +
'sta{img:03d}{suf:s}_scan_clean.fits'.format(img=ii, suf=suf)
for ii in img
]
rebin_files = [
out_dir + 'bin2/sta{img:03d}{suf:s}_scan_clean_bin2.fits'.format(
img=ii, suf=suf) for ii in img
]
redu.write_rebin(img_files, rebin_files, binfac)
return
def make_sky():
util.mkdir(sky_dir)
## CREATING A SKY
## IVBR pos 2
sky_num = np.arange(43, 49 + 1)
sky_frames = [
'{0:s}sky_{1:03d}_o.fits'.format(data_dir, ss) for ss in sky_num
]
scan_sky_frames = [
'{0:s}sky_{1:03d}_o_scan.fits'.format(data_dir, ss) for ss in sky_num
]
reduce_STA.treat_overscan(sky_frames)
calib.makedark(scan_sky_frames, sky_dir + 'fld2_sky_IVBR.fits')
## BRIV pos 4
sky_num = np.arange(37, 42 + 1)
sky_frames = [
'{0:s}sky_{1:03d}_o.fits'.format(data_dir, ss) for ss in sky_num
]
scan_sky_frames = [
'{0:s}sky_{1:03d}_o_scan.fits'.format(data_dir, ss) for ss in sky_num
]
reduce_STA.treat_overscan(sky_frames)
calib.makedark(scan_sky_frames, sky_dir + 'fld2_sky_BRIV.fits')
return
def make_sky():
util.mkdir(sky_dir)
## COPY A SKY => use a dark
# shutil.copyfile(root_dir + '../../20210724/sta/dark/dark_044_scan.fits', sky_dir + 'fld2_sky_tmp.fits')
## CREATING A SKY
## IVBR pos 2
sky_num = np.arange(41, 47)
sky_frames = [
'{0:s}sky_{1:03d}_o.fits'.format(data_dir, ss) for ss in sky_num
]
scan_sky_frames = [
'{0:s}sky_{1:03d}_o_scan.fits'.format(data_dir, ss) for ss in sky_num
]
reduce_STA.treat_overscan(sky_frames)
calib.makedark(scan_sky_frames, sky_dir + 'fld2_sky_IVBR.fits')
## VBRI pos 3
sky_num = np.arange(69, 74 + 1)
sky_frames = [
'{0:s}sky_{1:03d}_o.fits'.format(data_dir, ss) for ss in sky_num
]
scan_sky_frames = [
'{0:s}sky_{1:03d}_o_scan.fits'.format(data_dir, ss) for ss in sky_num
]
reduce_STA.treat_overscan(sky_frames)
calib.makedark(scan_sky_frames, sky_dir + 'fld2_sky_VBRI.fits')
return
def make_flat():
"""
Makes flat and data mask.
Just for single filter I band
"""
util.mkdir(calib_dir)
## Creating flat from range, I band only, 60 seconds
flat_num = np.arange(37, 49 + 1)
flat_frames = [
'{0:s}dome_{1:03d}.fits'.format(dome_dir, ss) for ss in flat_num
]
scan_flat_frames = [
'{0:s}dome_{1:03d}_scan.fits'.format(dome_dir, ss) for ss in flat_num
]
reduce_STA.treat_overscan(flat_frames)
calib.makeflat(scan_flat_frames,
None,
calib_dir + 'domeflat_I.fits',
darks=False)
## Make a mask to use when calling find_stars.
calib.make_mask(calib_dir + 'domeflat_I.fits',
calib_dir + 'mask.fits',
mask_min=0.5,
mask_max=1.8,
left_slice=20,
right_slice=20,
top_slice=25,
bottom_slice=25)
return
def stack():
util.mkdir(stacks_dir)
## Loop through all datasets
for key in dict_suffix.keys():
img = dict_images[key]
suf = dict_suffix[key]
print('Working on: {1:s} {0:s}'.format(key, suf))
print(' Images: ', img)
img_files = [
out_dir +
'sta{img:03d}{suf:s}_scan_clean.fits'.format(img=ii, suf=suf)
for ii in img
]
starlists = [
out_dir +
'sta{img:03d}{suf:s}_scan_clean_stars.txt'.format(img=ii, suf=suf)
for ii in img
]
output_root = stacks_dir + 'fld2_stack_' + suf
redu.shift_and_add(img_files, starlists, output_root, method='mean')
return
def make_flat():
"""
Makes flat and data mask.
Just for single filter I band
"""
util.mkdir(calib_dir)
filt_order = 'IVBR'
## Copy flat from a previous night
shutil.copyfile(
root_dir + '../../20220514/sta/reduce/calib/flat_IVBR.fits',
calib_dir + 'flat_IVBR.fits')
## Creating flat from range, I band only
#flat_num = np.arange(37, 49+1)
#flat_frames = ['{0:s}dome_{1:03d}.fits'.format(dome_dir, ss) for ss in flat_num]
#scan_flat_frames = ['{0:s}dome_{1:03d}_scan.fits'.format(dome_dir, ss) for ss in flat_num]
#reduce_STA.treat_overscan(flat_frames)
#calib.makeflat(scan_flat_frames, None, calib_dir + 'domeflat_I.fits', darks=False)
calib.make_mask(f'{calib_dir}flat_{filt_order}.fits',
f'{calib_dir}mask_{filt_order}.fits',
mask_min=0.8,
mask_max=1.4,
left_slice=20,
right_slice=20,
top_slice=25,
bottom_slice=25)
return
def calc_star_stats():
util.mkdir(stats_dir)
## Loop through all datasets
for key in dict_suffix.keys():
img = dict_images[key]
suf = dict_suffix[key]
bin = 'bin1' if 'bin1' in key else 'bin2' # key should contain bin info
print('Working on: {1:s} {0:s}'.format(key, suf))
print(' Catalog: ', img)
img_files = [
out_dir +
'sta{img:03d}{suf:s}_scan_clean.fits'.format(img=ii, suf=suf)
for ii in img
]
stats_file = stats_dir + 'stats_' + key + '.fits'
redu.calc_star_stats(img_files, output_stats=stats_file)
moffat.fit_moffat(img_files, stats_file, flux_percent=0.2)
# DEBUG - single threaded
# fmt = '{dir}sta{img:03d}{suf:s}_scan_clean.fits'
# image_file = fmt.format(dir=out_dir, img=dict_images['LS_c'][0], suf=dict_suffix['LS_c'][0])
# stats_file = stats_dir + 'stats_LS_c.fits'
# redu.calc_star_stats(image_file, stats_file, flux_percent=0.2)
return
def reduce_fld2():
util.mkdir(out_dir)
## Loop through all the different data sets
for key in dict_suffix.keys():
#for key in ['doczskycl']:
img = dict_images[key]
suf = dict_suffix[key]
sky = dict_skies[key]
print('Working on: {1:s} {0:s}'.format(key, suf))
print(' Images: ', img)
print(' Sky: ', sky)
img_files = [
data_dir + 'sta{img:03d}{suf:s}.fits'.format(img=ii, suf=suf)
for ii in img
]
scn_files = [
data_dir + 'sta{img:03d}{suf:s}_scan.fits'.format(img=ii, suf=suf)
for ii in img
]
reduce_STA.treat_overscan(img_files)
redu.clean_images(scn_files,
out_dir,
rebin=1,
sky_frame=sky_dir + sky,
flat_frame=calib_dir + "flat.fits") #,
# fix_bad_pixels=True, worry_about_edges=True)
return
def stack():
## EDITED FOR 4F DATA
util.mkdir(stacks_dir)
## Loop through all the different data sets
#for key in ['tt_RIVB']: ## Single key setup
for key in dict_suffix.keys():
img = dict_images[key]
suf = dict_suffix[key]
filt = dict_filt[key]
print('Working on: {1:s} {0:s}'.format(key, suf))
print(' Images: ', img)
img_files = [
out_dir +
'sta{img:03d}{suf:s}_scan_clean.fits'.format(img=ii, suf=suf)
for ii in img
]
starlists = [
out_dir +
'sta{img:03d}{suf:s}_scan_clean_stars.txt'.format(img=ii, suf=suf)
for ii in img
]
output_root = stacks_dir + 'fld2_stack_' + suf + '_' + filt ## EDITED LINE
redu.shift_and_add(img_files, starlists, output_root, method='mean')
return
def reduce_fld2():
util.mkdir(out_dir)
## Loop through all the different data sets and reduce them.
#for key in ['tt_IVBR', 'LS_VBRI', 'open_VBRI', 'docz_VBRI', 'tt_VBRI']: ## Single key setup
for key in dict_suffix.keys():
img = dict_images[key]
suf = dict_suffix[key]
filt = dict_filt[key]
print('Working on: {1:s} {0:s}'.format(key, suf))
print(' Images: ', img)
print(' Filter: ', filt)
img_files = [
data_dir + 'sta{img:03d}{suf:s}.fits'.format(img=ii, suf=suf)
for ii in img
]
scn_files = [
data_dir + 'sta{img:03d}{suf:s}_scan.fits'.format(img=ii, suf=suf)
for ii in img
]
reduce_STA.treat_overscan(img_files)
redu.clean_images(scn_files,
out_dir,
rebin=1,
sky_frame=sky_dir + f"fld2_sky_{filt}.fits",
flat_frame=calib_dir + f"flat_{filt}.fits") #,
# fix_bad_pixels=True, worry_about_edges=True)
return
def calc_star_stats():
util.mkdir(stats_dir)
## Loop through all the different data sets
#for key in ['set_name']: ## Single key setup
for key in dict_suffix.keys():
img = dict_images[key]
suf = dict_suffix[key]
print('Working on: {1:s} {0:s}'.format(key, suf))
print(' Catalog: ', img)
img_files = [
out_dir +
'sta{img:03d}{suf:s}_scan_clean.fits'.format(img=ii, suf=suf)
for ii in img
]
stats_file = stats_dir + 'stats_' + key + '.fits'
redu.calc_star_stats(img_files, output_stats=stats_file)
moffat.fit_moffat(img_files, stats_file, flux_percent=0.2)
## DEBUG - single threaded
# fmt = '{dir}sta{img:03d}{suf:s}_scan_clean.fits'
# image_file = fmt.format(dir=out_dir, img=dict_images['LS_c'][0], suf=dict_suffix['LS_c'][0])
# stats_file = stats_dir + 'stats_LS_c.fits'
# redu.calc_star_stats(image_file, stats_file, flux_percent=0.2)
return
def reduce_FLD2():
sky_dir = root_dir + 'reduce/sky/'
data_dir = root_dir + 'FLD2_2/'
flat_dir = root_dir + 'reduce/calib/'
out_dir = root_dir + 'reduce/FLD2_2/'
util.mkdir(out_dir)
# Open Loop
fnum = [4, 5, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45]
fnum += [51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 85, 88, 89]
fnum += [92, 95, 99, 103, 107, 110, 113, 116, 119, 122, 125, 128]
fnum += [
131, 134, 137, 140, 143, 146, 149, 152, 155, 158, 161, 164, 167, 170
]
img_files = [data_dir + 'obj{0:04d}_o.fits'.format(ii) for ii in fnum]
reduce_fli.clean_images(img_files,
out_dir,
rebin=1,
sky_frame=sky_dir + 'FLD2_2_sky.fits',
flat_frame=flat_dir + 'flat.fits')
# Closed Loop
fnum = [96, 100, 104]
img_files = [data_dir + 'obj{0:04d}_c.fits'.format(ii) for ii in fnum]
reduce_fli.clean_images(img_files,
out_dir,
rebin=1,
sky_frame=sky_dir + 'FLD2_2_sky.fits',
flat_frame=flat_dir + 'flat.fits')
# Closed A
fnum = [6, 8, 11, 14, 17, 20, 23, 26, 29, 32, 35, 38, 41, 44, 47, 50, 53]
fnum += [56, 59, 62, 65, 68, 71, 74, 77, 80, 83, 87, 91, 94, 98, 102, 106]
fnum += [109, 112, 115, 118, 121, 124, 127, 130, 133, 136, 139, 142, 145]
fnum += [148, 151, 154, 157, 160, 163, 166, 169]
img_files = [data_dir + 'obj{0:04d}_cA.fits'.format(ii) for ii in fnum]
reduce_fli.clean_images(img_files,
out_dir,
rebin=1,
sky_frame=sky_dir + 'FLD2_2_sky.fits',
flat_frame=flat_dir + 'flat.fits')
# Closed B
fnum = [10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 52, 55, 58]
fnum += [
61, 64, 67, 70, 73, 76, 79, 82, 86, 90, 93, 97, 101, 105, 108, 111
]
fnum += [
114, 117, 120, 123, 126, 129, 132, 135, 138, 141, 144, 147, 150, 153
]
fnum += [156, 159, 162, 165, 168, 171]
img_files = [data_dir + 'obj{0:04d}_cB.fits'.format(ii) for ii in fnum]
reduce_fli.clean_images(img_files,
out_dir,
rebin=1,
sky_frame=sky_dir + 'FLD2_2_sky.fits',
flat_frame=flat_dir + 'flat.fits')
return
def stack_beehive():
util.mkdir(stacks_dir)
# Loop through all the different data sets and reduce them.
#for key in dict_suffix.keys():
for key in ['open_2', 'LS_3wfs_s_2', 'LS_3wfs_w_2', 'LS_5wfs_2']:
img = dict_images[key]
suf = dict_suffix[key]
print('Working on: {1:s} {0:s}'.format(key, suf))
print(' Images: ', img)
img_files = [
out_dir +
'sta{img:03d}{suf:s}_scan_clean.fits'.format(img=ii, suf=suf)
for ii in img
]
starlists = [
out_dir +
'sta{img:03d}{suf:s}_scan_clean_stars.txt'.format(img=ii, suf=suf)
for ii in img
]
output_root = stacks_dir + 'beehive_stack_' + suf
redu.shift_and_add(img_files, starlists, output_root, method='mean')
return
def reduce_beehive():
util.mkdir(out_dir)
## Loop through all the different data sets and reduce them.
for key in dict_suffix.keys():
#for key in ['open']:
img = dict_images[key]
suf = dict_suffix[key]
sky = dict_sky[key]
print('Working on: {1:s} {0:s}'.format(key, suf))
print(' Images: ', img)
print(' Sky: ', sky)
img_files = [
data_dir + 'sta{img:03d}{suf:s}.fits'.format(img=ii, suf=suf)
for ii in img
]
scn_files = [
data_dir + 'sta{img:03d}{suf:s}_scan.fits'.format(img=ii, suf=suf)
for ii in img
]
reduce_STA.treat_overscan(img_files)
#reduce_STA.treat_overscan_working(img_files) #BUG
redu.clean_images(scn_files,
out_dir,
rebin=1,
sky_frame=sky_dir + sky,
flat_frame=calib_dir + "domeflat.fits")
return
def make_flat():
"""
Makes flat and data mask.
Just for single filter I band
"""
util.mkdir(calib_dir)
## Copy flat from a previous night
shutil.copyfile(
root_dir + '../../20210723/sta/reduce/calib/domeflat_I.fits',
calib_dir + 'flat_I.fits')
## Creating flat from range, I band only
#flat_num = np.arange(37, 49+1)
#flat_frames = ['{0:s}dome_{1:03d}.fits'.format(dome_dir, ss) for ss in flat_num]
#scan_flat_frames = ['{0:s}dome_{1:03d}_scan.fits'.format(dome_dir, ss) for ss in flat_num]
#reduce_STA.treat_overscan(flat_frames)
#calib.makeflat(scan_flat_frames, None, calib_dir + 'domeflat_I.fits', darks=False)
## Make a mask to use when calling find_stars.
calib.make_mask(calib_dir + 'domeflat_I.fits',
calib_dir + 'mask.fits',
mask_min=0.5,
mask_max=1.8,
left_slice=20,
right_slice=20,
top_slice=25,
bottom_slice=25)
return
def stack_FLD2():
data_dir = root_dir + 'reduce/FLD2_2/'
stats_dir = root_dir + 'reduce/stats/'
stacks_dir = root_dir + 'reduce/stacks/'
util.mkdir(stacks_dir)
# Open Loop
fnum = [124, 129, 135, 141, 147, 153, 159, 165, 171, 177, 183, 189, 195]
fnum += [201, 207, 215, 221, 227, 233, 239, 245, 251, 257, 263, 269]
open_images = [data_dir + 'obj{0:04d}_o_clean.fits'.format(ii) for ii in fnum]
open_starlists = [data_dir + 'obj{0:04d}_o_clean_stars.txt'.format(ii) for ii in fnum]
open_output_root = stacks_dir + 'FLD2_stack_open'
reduce_fli.shift_and_add(open_images, open_starlists, open_output_root, method='mean')
# Closed
fnum = [126, 128, 134, 140, 146, 152, 158, 164, 170, 176, 182, 188, 194]
fnum += [200, 206, 212, 214, 220, 226, 232, 238, 244, 250, 256, 262, 268]
closed_images = [data_dir + 'obj{0:04d}_c_clean.fits'.format(ii) for ii in fnum]
closed_starlists = [data_dir + 'obj{0:04d}_c_clean_stars.txt'.format(ii) for ii in fnum]
closed_output_root = stacks_dir + 'FLD2_stack_closed'
reduce_fli.shift_and_add(closed_images, closed_starlists, closed_output_root, method='mean')
# Closed A
fnum = [125, 127, 130, 136, 142, 148, 154, 160, 166, 172, 178, 184, 190]
fnum += [196, 202, 208, 216, 222, 228, 234, 240, 246, 252, 258, 264, 270]
closed_images = [data_dir + 'obj{0:04d}_cA_clean.fits'.format(ii) for ii in fnum]
closed_starlists = [data_dir + 'obj{0:04d}_cA_clean_stars.txt'.format(ii) for ii in fnum]
closed_output_root = stacks_dir + 'FLD2_stack_closedA'
reduce_fli.shift_and_add(closed_images, closed_starlists, closed_output_root, method='mean')
# Closed B
fnum = [131, 137, 143, 149, 155, 161, 167, 173, 179, 185, 191, 197, 203]
fnum += [209, 217, 223, 229, 235, 241, 247, 253, 259, 265, 271]
closed_images = [data_dir + 'obj{0:04d}_cB_clean.fits'.format(ii) for ii in fnum]
closed_starlists = [data_dir + 'obj{0:04d}_cB_clean_stars.txt'.format(ii) for ii in fnum]
closed_output_root = stacks_dir + 'FLD2_stack_closedB'
reduce_fli.shift_and_add(closed_images, closed_starlists, closed_output_root, method='mean')
# Closed C
fnum = [132, 138, 144, 150, 156, 162, 168, 174, 180, 186, 192, 198, 204]
fnum += [210, 218, 224, 230, 236, 242, 248, 254, 260, 266, 272]
closed_images = [data_dir + 'obj{0:04d}_cC_clean.fits'.format(ii) for ii in fnum]
closed_starlists = [data_dir + 'obj{0:04d}_cC_clean_stars.txt'.format(ii) for ii in fnum]
closed_output_root = stacks_dir + 'FLD2_stack_closedC'
reduce_fli.shift_and_add(closed_images, closed_starlists, closed_output_root, method='mean')
# Closed D
fnum = [133, 139, 145, 151, 157, 163, 169, 175, 181, 187, 193, 199, 205]
fnum += [211, 219, 225, 231, 237, 243, 249, 255, 261, 267, 273]
closed_images = [data_dir + 'obj{0:04d}_cD_clean.fits'.format(ii) for ii in fnum]
closed_starlists = [data_dir + 'obj{0:04d}_cD_clean_stars.txt'.format(ii) for ii in fnum]
closed_output_root = stacks_dir + 'FLD2_stack_closedD'
reduce_fli.shift_and_add(closed_images, closed_starlists, closed_output_root, method='mean')
return
def make_flat_filter():
"""
Makes flat and data mask.
- makeflat(fourfilter=True) normalizes each quadrant independently
- combine_filter_flat(filt_order) takes two 4F flats
and gives I-band the logner int quadrant
For four filter, dome flat was made with two integration times,
20(2) for BVR
60(45) for I
*Note, no VBRI filter taken forr this date
"""
util.mkdir(calib_dir)
util.mkdir(dark_dir)
filt_order = "RIVB" # position 1
flat_num = np.arange(88, 92 + 1)
print("Filter: ", filt_order)
print("Scanning Flat Frames... ")
flat_frames = [
'{0:s}sta{1:03d}_o.fits'.format(screen_dir, ss) for ss in flat_num
]
scan_flat_frames = [
'{0:s}sta{1:03d}_o_scan.fits'.format(screen_dir, ss) for ss in flat_num
]
reduce_STA.treat_overscan(flat_frames)
print("Scanning Dark Frames... ")
dark_num = np.arange(94, 102 + 1)
dark_frames = [
'{0:s}dark_{1:03d}.fits'.format(dark_dir, ss) for ss in dark_num
]
scan_dark_frames = [
'{0:s}dark_{1:03d}_scan.fits'.format(dark_dir, ss) for ss in dark_num
]
reduce_STA.treat_overscan(dark_frames)
print("Making Flats... ")
calib.makeflat(scan_flat_frames,
scan_dark_frames[:len(scan_flat_frames)],
f'{calib_dir}flat_{filt_order}.fits',
darks=True,
fourfilter=True)
print("Making mask... ")
calib.make_mask(f'{calib_dir}flat_{filt_order}.fits',
f'{calib_dir}mask_{filt_order}.fits',
mask_min=0.5,
mask_max=1.8,
left_slice=20,
right_slice=20,
top_slice=25,
bottom_slice=25)
return
def make_flat():
# Didn't take flats, so just copy over the one from Friday night.
# Note this is an R-band flat; but we will use it for R and I.
old_flat = imaka_dir + '20170214/fli/reduce/calib/flat.fits'
new_flat = root_dir + 'reduce/calib/flat.fits'
util.mkdir(root_dir + 'reduce/calib/')
shutil.copyfile(old_flat, new_flat)
return
def make_sky():
util.mkdir(sky_dir)
sky_num = np.arange(73, 82 + 1)
sky_frames = [
'{0:s}sky_{1:04d}_o.fits'.format(data_dir, ss) for ss in sky_num
]
calib.makedark(sky_frames, sky_dir + 'FLD2_30_sky.fits')
return
def make_flat_filter():
"""
Makes flat and data mask.
For four filter, dome flat was made with two integration times, 20(2) for BVR 60(45) for I
"""
util.mkdir(calib_dir)
## I quad flat (60)
dark_num = np.arange(108, 113 + 1)
flat_num = np.arange(130, 135 + 1)
dark_frames = [
'{0:s}dark_{1:03d}.fits'.format(dark_dir, ss) for ss in dark_num
]
scan_dark_frames = [
'{0:s}dark_{1:03d}_scan.fits'.format(dark_dir, ss) for ss in dark_num
]
flat_frames = [
'{0:s}dome_{1:03d}.fits'.format(dome_dir, ss) for ss in flat_num
]
scan_flat_frames = [
'{0:s}dome_{1:03d}_scan.fits'.format(dome_dir, ss) for ss in flat_num
]
reduce_STA.treat_overscan(dark_frames)
reduce_STA.treat_overscan(flat_frames)
#calib.makeflat(scan_flat_frames, scan_dark_frames, calib_dir + 'domeflat_60.fits', darks=True, fourfilter=True)
## BVR quad flat (20)
dark_num = np.arange(118, 123 + 1)
flat_num = np.arange(124, 129 + 1)
dark_frames = [
'{0:s}dark_{1:03d}.fits'.format(dark_dir, ss) for ss in dark_num
]
scan_dark_frames = [
'{0:s}dark_{1:03d}_scan.fits'.format(dark_dir, ss) for ss in dark_num
]
flat_frames = [
'{0:s}dome_{1:03d}.fits'.format(dome_dir, ss) for ss in flat_num
]
scan_flat_frames = [
'{0:s}dome_{1:03d}_scan.fits'.format(dome_dir, ss) for ss in flat_num
]
reduce_STA.treat_overscan(dark_frames)
reduce_STA.treat_overscan(flat_frames)
#calib.makeflat(scan_flat_frames, scan_dark_frames, calib_dir + 'domeflat_20.fits', darks=True, fourfilter=True)
# Combining two flats based on filter orientation
## Make a mask to use when calling find_stars.
#calib.make_mask(calib_dir + 'domeflat_60.fits', calib_dir + 'mask_60.fits',
# mask_min=0.5, mask_max=1.8,
# left_slice=20, right_slice=20, top_slice=25, bottom_slice=25)
return
