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 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 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():
util.mkdir(flat_dir)
flat_num = np.arange(0, 10+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, [], flat_dir + 'flat.fits', darks=False)
return
def make_flat():
"""
Makes a flat and mask from flats.
Done for two different binnings
"""
util.mkdir(flat_dir)
flat_num_bin1 = np.arange(51, 54 + 1)
flat_num_bin2 = np.arange(55, 62 + 1)
flat_frames_bin1 = [
'{0:s}twi{1:03d}.fits'.format(twi_dir, ss) for ss in flat_num_bin1
]
flat_frames_bin2 = [
'{0:s}twi{1:03d}.fits'.format(twi_dir, ss) for ss in flat_num_bin2
]
reduce_STA.treat_overscan(flat_frames_bin1)
reduce_STA.treat_overscan(flat_frames_bin2)
scan_flat_frames_bin1 = [
'{0:s}twi{1:03d}_scan.fits'.format(twi_dir, ss) for ss in flat_num_bin1
]
scan_flat_frames_bin2 = [
'{0:s}twi{1:03d}_scan.fits'.format(twi_dir, ss) for ss in flat_num_bin2
]
calib.makeflat(scan_flat_frames_bin1,
None,
calib_dir + 'flat_bin1.fits',
darks=False)
calib.makeflat(scan_flat_frames_bin2,
None,
calib_dir + 'flat_bin2.fits',
darks=False)
# This mask tells us where not to search for stars.
calib.make_mask(calib_dir + 'flat_bin1.fits',
calib_dir + 'mask_bin1.fits',
mask_min=0.8,
mask_max=1.4,
left_slice=20,
right_slice=20,
top_slice=25,
bottom_slice=25)
calib.make_mask(calib_dir + 'flat_bin2.fits',
calib_dir + 'mask_bin2.fits',
mask_min=0.8,
mask_max=1.4,
left_slice=10,
right_slice=10,
top_slice=15,
bottom_slice=15)
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)
## Darks are the same all night
#filt_order = "IVBR"
#flat_num_60 = np.arange(13, 18+1)
#flat_num_20 = np.arange(19, 24+1)
filt_order = "BRIV"
flat_num_60 = np.arange(73, 78+1)
flat_num_20 = np.arange(79, 84+1)
print(filt_order)
## I quad flat (60)
dark_num = np.arange(29, 34+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_60]
scan_flat_frames = ['{0:s}dome_{1:03d}_scan.fits'.format(dome_dir, ss) for ss in flat_num_60]
reduce_STA.treat_overscan(dark_frames)
reduce_STA.treat_overscan(flat_frames)
calib.makeflat(scan_flat_frames, scan_dark_frames,
f'{calib_dir}domeflat_60_{filt_order}.fits', darks=True, fourfilter=True)
## BVR quad flat (20)
dark_num = np.arange(39, 44+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_20]
scan_flat_frames = ['{0:s}dome_{1:03d}_scan.fits'.format(dome_dir, ss) for ss in flat_num_20]
reduce_STA.treat_overscan(dark_frames)
reduce_STA.treat_overscan(flat_frames)
calib.makeflat(scan_flat_frames, scan_dark_frames,
f'{calib_dir}domeflat_20_{filt_order}.fits', darks=True, fourfilter=True)
# Combining two flats based on filter orientation
calib.combine_filter_flat(f'{calib_dir}domeflat_60_{filt_order}.fits',
f'{calib_dir}domeflat_20_{filt_order}.fits',
f'{calib_dir}flat_{filt_order}.fits', filt_order)
return
def make_flat_4F():
"""
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)
## Darks are the same all night
filt_order = "VBRI"
flat_num_60 = np.arange(63, 67+1)
flat_num_20 = np.array([73, 74, 75, 73, 74])
print(filt_order)
print("I quad flat (60)")
dark_num = np.arange(81, 85+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}sta{1:03d}_o.fits'.format(dome_dir, ss) for ss in flat_num_60]
scan_flat_frames = ['{0:s}sta{1:03d}_o_scan.fits'.format(dome_dir, ss) for ss in flat_num_60]
reduce_STA.treat_overscan(dark_frames)
reduce_STA.treat_overscan(flat_frames)
calib.makeflat(scan_flat_frames, scan_dark_frames,
f'{calib_dir}domeflat_60_{filt_order}.fits', darks=True, fourfilter=True)
print("BVR quad flat (20)")
dark_num = np.arange(76,80+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}sta{1:03d}_o.fits'.format(dome_dir, ss) for ss in flat_num_20]
scan_flat_frames = ['{0:s}sta{1:03d}_o_scan.fits'.format(dome_dir, ss) for ss in flat_num_20]
reduce_STA.treat_overscan(dark_frames)
reduce_STA.treat_overscan(flat_frames)
calib.makeflat(scan_flat_frames, scan_dark_frames,
f'{calib_dir}domeflat_20_{filt_order}.fits', darks=True, fourfilter=True)
# Combining two flats based on filter orientation
print("Combining: I quad flat (60) & BVR quad flat (20)")
calib.combine_filter_flat(f'{calib_dir}domeflat_60_{filt_order}.fits',
f'{calib_dir}domeflat_20_{filt_order}.fits',
f'{calib_dir}flat_{filt_order}.fits', filt_order, flip_180=True)
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 make_flat():
flat_raw_dir = root_dir + 'twilights/'
dark_raw_dir = root_dir + 'dark/'
flat_out_dir = root_dir + "reduce/calib/"
util.mkdir(flat_out_dir)
flat_num = np.arange(125, 152)
flat_frames = [
'{0:s}twi_{1:04d}.fits'.format(flat_raw_dir, ss) for ss in flat_num
]
dark_frames = [
'{0:s}dark_{1:04d}.fits'.format(dark_raw_dir, ss) for ss in flat_num
]
calib.makeflat(flat_frames, dark_frames, flat_out_dir + 'flat.fits')
return
def make_flat():
"""
Makes flat and data mask.
Just for single filter I band
CHANGES: took domeflats this night
"""
util.mkdir(calib_dir)
# Flats: at 200 seconds
flat_num = np.arange(1, 5 + 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)
# Darks: at 210 seconds
dark_num = np.arange(6, 10 + 1)
dark_frames = [
'{0:s}sta{1:03d}_o.fits'.format(dome_dir, ss) for ss in dark_num
]
scan_dark_frames = [
'{0:s}sta{1:03d}_o_scan.fits'.format(dome_dir, ss) for ss in dark_num
]
reduce_STA.treat_overscan(dark_frames)
# Make flat
calib.makeflat(scan_flat_frames,
scan_dark_frames,
calib_dir + 'domeflat.fits',
darks=True)
# Mask for masking find_stars areas
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)
def make_flat():
flat_raw_dir = root_dir + "twilights/"
dark_raw_dir = root_dir + "twilights/"
flat_out_dir = root_dir + "reduce/calib/"
util.mkdir(flat_out_dir)
flat_num = [0, 1, 2, 3, 4, 5, 6]
flat_frames = [
'{0:s}twi_{1:03d}.fits'.format(flat_raw_dir, ss) for ss in flat_num
]
dark_frames = [
'{0:s}dark_{1:03d}.fits'.format(flat_raw_dir, ss) for ss in flat_num
]
calib.makeflat(flat_frames, dark_frames, flat_out_dir + 'flat_1.fits')
flat_num = [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, \
26, 27, 28, 29]
flat_frames = [
'{0:s}twi_{1:03d}.fits'.format(flat_raw_dir, ss) for ss in flat_num
]
dark_frames = [
'{0:s}dark_{1:03d}.fits'.format(flat_raw_dir, ss) for ss in flat_num
]
calib.makeflat(flat_frames, dark_frames, flat_out_dir + 'flat_2.fits')
flat1 = fits.getdata(flat_out_dir + 'flat_1.fits')
flat2 = fits.getdata(flat_out_dir + 'flat_2.fits')
flat1_rebin3 = reduce_fli.rebin(
flat1, 3)[:, :-1] / 9 ## WHAT IS THIS REVERSING/DIVIDNG DOING?
mean, median, stdev = sigma_clipped_stats([flat1_rebin3, flat2],
sigma=3,
iters=2,
axis=0)
hdu = fits.PrimaryHDU(median.data)
hdu.writeto(flat_out_dir + 'flat.fits')
return
def make_flat():
util.mkdir(flat_dir)
# We don't have one for this run, so I just symbolically linked from an really
# really old run.
# In sta/reduce/calib/
# ln -s /g/lu/data/imaka/onaga/20181223/sta/reduce/calib/flat.fits
# 2021 update: will link to flats in 20200122 (the following night)
flat_num = np.arange(221, 230+1)
flat_frames = ['{0:s}twi_{1:03d}.fits'.format(twi_alt_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_alt_dir, ss) for ss in flat_num]
calib.makeflat(scan_flat_frames, [], calib_dir + 'flat.fits', darks=False)
# Mask for masking find_stars areas
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 taken the a previous night
# shutil.copyfile(root_dir + '../../20210828/sta/reduce/calib/flat_1p_VBRI.fits', calib_dir + 'flat_VBRI.fits')
## Creating flat from range, I band only
flat_num = np.arange(1, 5 + 1)
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)
calib.makeflat(scan_flat_frames,
None,
calib_dir + 'flat_I.fits',
darks=False)
## Make a mask to use when calling find_stars.
calib.make_mask(calib_dir + 'flat_I.fits',
calib_dir + 'mask_I.fits',
mask_min=0.5,
mask_max=1.8,
left_slice=20,
right_slice=20,
top_slice=25,
bottom_slice=25)
#calib.make_mask(calib_dir + 'flat_VBRI.fits', calib_dir + 'mask_VBRI.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():
"""
Make a flat... this will be with dome flats for now.
These are junk... replace with twilight flats.
"""
util.mkdir(calib_dir)
## Copy flight from previous night if twilight exposures
## are a little saturated.
#shutil.copyfile(root_dir + '../../20210430/sta/reduce/calib/flat_bin1.fits', calib_dir + 'flat.fits')
## assuming these aren't overexposed
flat_num = np.arange(59, 70 + 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.
## UPDATE: mask_min and mask_max were hand calculated 6/14/2021
calib.make_mask(calib_dir + 'flat.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 make_flat():
"""
Flats made with twilights
"""
util.mkdir(calib_dir)
flat_num = np.arange(56, 68+1) # Change per night
flat_frames = ['{0:s}twi_{1:03d}.fits'.format(twi_dir, ss) for ss in flat_num] # file list
## STA: needs to deal with overscan
reduce_STA.treat_overscan(flat_frames) # run once
scan_flat_frames = ['{0:s}twi_{1:03d}_scan.fits'.format(twi_dir, ss) for ss in flat_num] # new file list
## Main Function
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.7, mask_max=1.6,
left_slice=20, right_slice=20, top_slice=25, bottom_slice=25)
return
def make_twilight_flats():
twilights = [
'twi_1001.fits', 'twi_2002.fits', 'twi_3003.fits', 'twi_4004.fits',
'twi_5005.fits', 'twi_6006.fits', 'twi_7007.fits', 'twi_8008.fits',
'twi_9009.fits', 'twi_10010.fits', 'twi_11011.fits', 'twi_12012.fits',
'twi_13013.fits', 'twi_14014.fits', 'twi_15015.fits', 'twi_16016.fits',
'twi_17017.fits', 'twi_18018.fits', 'twi_19019.fits', 'twi_20020.fits',
'twi_21021.fits', 'twi_22022.fits', 'twi_23023.fits', 'twi_24024.fits',
'twi_25025.fits', 'twi_26026.fits', 'twi_27027.fits', 'twi_28028.fits',
'twi_29029.fits', 'twi_30030.fits', 'twi_31031.fits'
]
twi_darks = [
'dark_1001002.fits', 'dark_2002013.fits', 'dark_3003024.fits',
'dark_4004035.fits', 'dark_5005044.fits', 'dark_6006045.fits',
'dark_7007046.fits', 'dark_8008047.fits', 'dark_9009048.fits',
'dark_10010001.fits', 'dark_11011003.fits', 'dark_12012004.fits',
'dark_13013005.fits', 'dark_14014006.fits', 'dark_15015007.fits',
'dark_16016008.fits', 'dark_17017009.fits', 'dark_18018010.fits',
'dark_19019011.fits', 'dark_20020012.fits', 'dark_21021014.fits',
'dark_22022015.fits', 'dark_23023016.fits', 'dark_24024017.fits',
'dark_25025018.fits', 'dark_26026019.fits', 'dark_27027020.fits',
'dark_28028021.fits', 'dark_29029022.fits', 'dark_30030023.fits',
'dark_31031025.fits'
]
twilight_root = '/Users/jlu/data/imaka/2016_11_19/20161118/twilight/'
twi_dark_root = '/Users/jlu/data/imaka/2016_11_19/20161118/darks/darks_for_twis/'
for tt in range(len(twilights)):
twilights[tt] = twilight_root + twilights[tt]
twi_darks[tt] = twi_dark_root + twi_darks[tt]
calib.makeflat(twilights, twi_darks, twilight_root + 'flat_r.fits')
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
"""
util.mkdir(calib_dir)
util.mkdir(dark_dir)
## Two exposure length flats taken this night
## Not planning on combining them initially
## scaling old darks because we took none
filt_order = "VBRI"
print(filt_order)
print("Scanning Flat Frames... ")
flat_num_3p = np.arange(80, 84 + 1)
flat_num_1p = np.append(np.arange(87, 90 + 1), 85)
flat_frames_3p = [
'{0:s}sta{1:03d}_o.fits'.format(screen_dir, ss) for ss in flat_num_3p
]
flat_frames_1p = [
'{0:s}sta{1:03d}_o.fits'.format(screen_dir, ss) for ss in flat_num_1p
]
scan_flat_frames_3p = [
'{0:s}sta{1:03d}_o_scan.fits'.format(screen_dir, ss)
for ss in flat_num_3p
]
scan_flat_frames_1p = [
'{0:s}sta{1:03d}_o_scan.fits'.format(screen_dir, ss)
for ss in flat_num_1p
]
reduce_STA.treat_overscan(flat_frames_3p)
reduce_STA.treat_overscan(flat_frames_1p)
print("Scaling Dark Frames... ")
dark_num = np.arange(29, 33 + 1)
## didn't take darks for this date, scaling old ones
dark_frames = [
'{0:s}dark_{1:03d}.fits'.format(alt_dark_dir, ss) for ss in dark_num
]
dark_frames_save = [
'{0:s}dark_{1:03d}.fits'.format(dark_dir, ss) for ss in dark_num
]
# Rescaling Dark frames
for i in range(len(dark_frames)):
if not os.path.isfile(dark_frames_save[i]):
redu.rescale_dark(dark_frames[i], flat_frames_3p[0],
dark_frames_save[i])
print("Scanning Dark Frames... ")
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_save)
print("Making Flats... ")
## Darker flat, 3 piece3 of paper
calib.makeflat(scan_flat_frames_3p,
scan_dark_frames,
f'{calib_dir}flat_3p_{filt_order}.fits',
darks=True,
fourfilter=True)
## Lighter flat, 1 piece of paper
calib.makeflat(scan_flat_frames_1p,
scan_dark_frames,
f'{calib_dir}flat_1p_{filt_order}.fits',
darks=True,
fourfilter=True)
# Combining two flats based on filter orientation
#calib.combine_filter_flat(f'{calib_dir}domeflat_60_{filt_order}.fits',
# f'{calib_dir}domeflat_20_{filt_order}.fits',
# f'{calib_dir}flat_{filt_order}.fits', filt_order)
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
filt_order = "RIVB"
calib.combine_filter_flat(calib_dir + 'domeflat_60.fits',
calib_dir + 'domeflat_20.fits',
calib_dir + f'flat_{filt_order}.fits',
filt_order)
## 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
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 this run, we illuminated the filter with a lamp, dimming with paper sheets.
other nights used different numbers of paper, 8_30 we just used 1 extra sheet
Integration times were 12s, darks taken 08_29
"""
util.mkdir(calib_dir)
util.mkdir(dark_dir)
## Two exposure length flats taken this night
## Not planning on combining them initially
## scaling old darks because we took none
#filt_order = "IVBR" #position 2
#flat_num = np.arange(1, 5+1)
filt_order = "BRIV" #position 4
flat_num = np.arange(6, 10 + 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("Pulling Dark Frames... ")
## didn't take darks for this date, pulling from previous night
dark_num = np.arange(94, 102 + 1)
dark_frames = [
'{0:s}dark_{1:03d}.fits'.format(alt_dark_dir, ss) for ss in dark_num
]
dark_frames_save = [
'{0:s}dark_{1:03d}.fits'.format(dark_dir, ss) for ss in dark_num
]
#Copying dark frames
#for i in range(len(dark_frames)):
# shutil.copyfile(dark_frames[i], dark_frames_save[i])
print("Scanning Dark Frames... ")
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_save)
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)
# Combining two flats based on filter orientation
#calib.combine_filter_flat(f'{calib_dir}domeflat_60_{filt_order}.fits',
# f'{calib_dir}domeflat_20_{filt_order}.fits',
# f'{calib_dir}flat_{filt_order}.fits', filt_order)
return
