def main(args):
# List only?
hdu = fits.open(args.file)
head0 = hdu[0].header
if args.list:
hdu.info()
return
# Setup for PYPIT imports
msgs.reset(verbosity=2)
# Init
sdet = get_dnum(args.det, prefix=False)
# One detector, sky sub for now
names = [hdu[i].name for i in range(len(hdu))]
try:
exten = names.index('DET{:s}-PROCESSED'.format(sdet))
except: # Backwards compatability
msgs.error(
'Requested detector {:s} was not processed.\n'
'Maybe you chose the wrong one to view?\n'
'Set with --det= or check file contents with --list'.format(sdet))
sciimg = hdu[exten].data
try:
exten = names.index('DET{:s}-SKY'.format(sdet))
except: # Backwards compatability
msgs.error(
'Requested detector {:s} has no sky model.\n'
'Maybe you chose the wrong one to view?\n'
'Set with --det= or check file contents with --list'.format(sdet))
skymodel = hdu[exten].data
try:
exten = names.index('DET{:s}-MASK'.format(sdet))
except ValueError: # Backwards compatability
msgs.error(
'Requested detector {:s} has no bit mask.\n'
'Maybe you chose the wrong one to view?\n'
'Set with --det= or check file contents with --list'.format(sdet))
mask = hdu[exten].data
try:
exten = names.index('DET{:s}-IVARMODEL'.format(sdet))
except ValueError: # Backwards compatability
msgs.error(
'Requested detector {:s} has no IVARMODEL.\n'
'Maybe you chose the wrong one to view?\n' +
'Set with --det= or check file contents with --list'.format(sdet))
ivarmodel = hdu[exten].data
# Read in the object model for residual map
try:
exten = names.index('DET{:s}-OBJ'.format(sdet))
except ValueError: # Backwards compatability
msgs.error(
'Requested detector {:s} has no object model.\n'
'Maybe you chose the wrong one to view?\n' +
'Set with --det= or check file contents with --list'.format(sdet))
objmodel = hdu[exten].data
# Get waveimg
mdir = head0['PYPMFDIR'] + '/'
if not os.path.exists(mdir):
mdir_base = os.path.basename(os.path.dirname(mdir)) + '/'
msgs.warn('Master file dir: {0} does not exist. Using ./{1}'.format(
mdir, mdir_base))
mdir = mdir_base
trace_key = '{0}_{1:02d}'.format(head0['TRACMKEY'], args.det)
trc_file = os.path.join(
mdir, MasterFrame.construct_file_name('Trace', trace_key))
wave_key = '{0}_{1:02d}'.format(head0['ARCMKEY'], args.det)
waveimg = os.path.join(mdir,
MasterFrame.construct_file_name('Wave', wave_key))
tslits_dict = TraceSlits.load_from_file(trc_file)[0]
slitmask = pixels.tslits2mask(tslits_dict)
shape = (tslits_dict['nspec'], tslits_dict['nspat'])
slit_ids = [
trace_slits.get_slitid(shape, tslits_dict['slit_left'],
tslits_dict['slit_righ'], ii)[0]
for ii in range(tslits_dict['slit_left'].shape[1])
]
# Show the bitmask?
mask_in = mask if args.showmask else None
# Object traces
spec1d_file = args.file.replace('spec2d', 'spec1d')
det_nm = 'DET{:s}'.format(sdet)
if os.path.isfile(spec1d_file):
hdulist_1d = fits.open(spec1d_file)
else:
hdulist_1d = []
msgs.warn('Could not find spec1d file: {:s}'.format(spec1d_file) +
msgs.newline() +
' No objects were extracted.')
# Unpack the bitmask
bitMask = bitmask()
bpm, crmask, satmask, minmask, offslitmask, nanmask, ivar0mask, ivarnanmask, extractmask \
= bitMask.unpack(mask)
# Now show each image to a separate channel
# SCIIMG
image = sciimg # Raw science image
(mean, med, sigma) = sigma_clipped_stats(image[mask == 0],
sigma_lower=5.0,
sigma_upper=5.0)
cut_min = mean - 1.0 * sigma
cut_max = mean + 4.0 * sigma
chname_skysub = 'sciimg-det{:s}'.format(sdet)
# Clear all channels at the beginning
viewer, ch = ginga.show_image(image,
chname=chname_skysub,
waveimg=waveimg,
bitmask=mask_in,
clear=True)
#, cuts=(cut_min, cut_max), wcs_match=True)
ginga.show_slits(viewer, ch, tslits_dict['slit_left'],
tslits_dict['slit_righ'], slit_ids)
#, args.det)
# SKYSUB
image = (sciimg - skymodel) * (mask == 0) # sky subtracted image
(mean, med, sigma) = sigma_clipped_stats(image[mask == 0],
sigma_lower=5.0,
sigma_upper=5.0)
cut_min = mean - 1.0 * sigma
cut_max = mean + 4.0 * sigma
chname_skysub = 'skysub-det{:s}'.format(sdet)
# Clear all channels at the beginning
# TODO: JFH For some reason Ginga crashes when I try to put cuts in here.
viewer, ch = ginga.show_image(
image, chname=chname_skysub, waveimg=waveimg,
bitmask=mask_in) #, cuts=(cut_min, cut_max),wcs_match=True)
show_trace(hdulist_1d, det_nm, viewer, ch)
ginga.show_slits(viewer, ch, tslits_dict['slit_left'],
tslits_dict['slit_righ'], slit_ids)
#, args.det)
# SKRESIDS
chname_skyresids = 'sky_resid-det{:s}'.format(sdet)
image = (sciimg - skymodel) * np.sqrt(ivarmodel) * (mask == 0
) # sky residual map
viewer, ch = ginga.show_image(image,
chname_skyresids,
waveimg=waveimg,
cuts=(-5.0, 5.0),
bitmask=mask_in) #,wcs_match=True)
show_trace(hdulist_1d, det_nm, viewer, ch)
ginga.show_slits(viewer, ch, tslits_dict['slit_left'],
tslits_dict['slit_righ'], slit_ids)
#, args.det)
# RESIDS
chname_resids = 'resid-det{:s}'.format(sdet)
# full model residual map
image = (sciimg - skymodel - objmodel) * np.sqrt(ivarmodel) * (mask == 0)
viewer, ch = ginga.show_image(image,
chname=chname_resids,
waveimg=waveimg,
cuts=(-5.0, 5.0),
bitmask=mask_in) #,wcs_match=True)
show_trace(hdulist_1d, det_nm, viewer, ch)
ginga.show_slits(viewer, ch, tslits_dict['slit_left'],
tslits_dict['slit_righ'], slit_ids)
#, args.det)
# After displaying all the images sync up the images with WCS_MATCH
shell = viewer.shell()
out = shell.start_global_plugin('WCSMatch')
out = shell.call_global_plugin_method('WCSMatch', 'set_reference_channel',
[chname_resids], {})
if args.embed:
IPython.embed()
def extract_coadd2d(stack_dict, master_dir, samp_fact = 1.0,ir_redux=False, par=None, std=False, show=False, show_peaks=False):
"""
Main routine to run the extraction for 2d coadds.
Algorithm steps are as follows:
- Fill this in.
This performs 2d coadd specific tasks, and then also performs some
of the tasks analogous to the pypeit.extract_one method. Docs coming
soon....
Args:
stack_dict:
master_dir:
samp_fact: float
sampling factor to make the wavelength grid finer or coarser. samp_fact > 1.0 oversamples (finer),
samp_fact < 1.0 undersamples (coarser)
ir_redux:
par:
show:
show_peaks:
Returns:
"""
# Find the objid of the brighest object, and the average snr across all orders
nslits = stack_dict['tslits_dict']['slit_left'].shape[1]
objid, snr_bar = get_brightest_obj(stack_dict['specobjs_list'], echelle=True)
# TODO Print out a report here on the image stack, i.e. S/N of each image
spectrograph = util.load_spectrograph(stack_dict['spectrograph'])
par = spectrograph.default_pypeit_par() if par is None else par
binning = np.array([stack_dict['tslits_dict']['binspectral'],stack_dict['tslits_dict']['binspatial']])
# Grab the wavelength grid that we will rectify onto
wave_grid = spectrograph.wavegrid(binning=binning,samp_fact=samp_fact)
wave_grid_mid = spectrograph.wavegrid(midpoint=True,binning=binning,samp_fact=samp_fact)
coadd_list = []
nspec_vec = np.zeros(nslits,dtype=int)
nspat_vec = np.zeros(nslits,dtype=int)
# TODO: Generalize this to be a loop over detectors, such tha the
# coadd_list is an ordered dict (perhaps) with all the slits on all
# detectors
for islit in range(nslits):
msgs.info('Performing 2d coadd for slit: {:d}/{:d}'.format(islit,nslits-1))
# Determine the wavelength dependent optimal weights and grab the reference trace
rms_sn, weights, trace_stack, wave_stack = optimal_weights(stack_dict['specobjs_list'],
islit, objid)
thismask_stack = stack_dict['slitmask_stack'] == islit
# Perform the 2d coadd
coadd_dict = coadd2d(trace_stack, stack_dict['sciimg_stack'], stack_dict['sciivar_stack'],
stack_dict['skymodel_stack'], stack_dict['mask_stack'] == 0,
stack_dict['tilts_stack'], stack_dict['waveimg_stack'],
thismask_stack, weights=weights, wave_grid=wave_grid)
coadd_list.append(coadd_dict)
nspec_vec[islit]=coadd_dict['nspec']
nspat_vec[islit]=coadd_dict['nspat']
# Determine the size of the psuedo image
nspat_pad = 10
nspec_psuedo = nspec_vec.max()
nspat_psuedo = np.sum(nspat_vec) + (nslits + 1)*nspat_pad
spec_vec_psuedo = np.arange(nspec_psuedo)
shape_psuedo = (nspec_psuedo, nspat_psuedo)
imgminsky_psuedo = np.zeros(shape_psuedo)
sciivar_psuedo = np.zeros(shape_psuedo)
waveimg_psuedo = np.zeros(shape_psuedo)
tilts_psuedo = np.zeros(shape_psuedo)
spat_psuedo = np.zeros(shape_psuedo)
nused_psuedo = np.zeros(shape_psuedo, dtype=int)
inmask_psuedo = np.zeros(shape_psuedo, dtype=bool)
wave_mid = np.zeros((nspec_psuedo, nslits))
wave_mask = np.zeros((nspec_psuedo, nslits),dtype=bool)
wave_min = np.zeros((nspec_psuedo, nslits))
wave_max = np.zeros((nspec_psuedo, nslits))
dspat_mid = np.zeros((nspat_psuedo, nslits))
spat_left = nspat_pad
slit_left = np.zeros((nspec_psuedo, nslits))
slit_righ = np.zeros((nspec_psuedo, nslits))
spec_min1 = np.zeros(nslits)
spec_max1 = np.zeros(nslits)
for islit, coadd_dict in enumerate(coadd_list):
spat_righ = spat_left + nspat_vec[islit]
ispec = slice(0,nspec_vec[islit])
ispat = slice(spat_left,spat_righ)
imgminsky_psuedo[ispec, ispat] = coadd_dict['imgminsky']
sciivar_psuedo[ispec, ispat] = coadd_dict['sciivar']
waveimg_psuedo[ispec, ispat] = coadd_dict['waveimg']
tilts_psuedo[ispec, ispat] = coadd_dict['tilts']
# spat_psuedo is the sub-pixel image position on the rebinned psuedo image
inmask_psuedo[ispec, ispat] = coadd_dict['outmask']
image_temp = (coadd_dict['dspat'] - coadd_dict['dspat_mid'][0] + spat_left)*coadd_dict['outmask']
spat_psuedo[ispec, ispat] = image_temp
nused_psuedo[ispec, ispat] = coadd_dict['nused']
wave_min[ispec, islit] = coadd_dict['wave_min']
wave_max[ispec, islit] = coadd_dict['wave_max']
wave_mid[ispec, islit] = coadd_dict['wave_mid']
wave_mask[ispec, islit] = True
# Fill in the rest of the wave_mid with the corresponding points in the wave_grid
wave_this = wave_mid[wave_mask[:,islit], islit]
ind_upper = np.argmin(np.abs(wave_grid_mid - np.max(wave_this.max()))) + 1
if nspec_vec[islit] != nspec_psuedo:
wave_mid[nspec_vec[islit]:, islit] = wave_grid_mid[ind_upper:ind_upper + (nspec_psuedo-nspec_vec[islit])]
dspat_mid[ispat, islit] = coadd_dict['dspat_mid']
slit_left[:,islit] = np.full(nspec_psuedo, spat_left)
slit_righ[:,islit] = np.full(nspec_psuedo, spat_righ)
spec_max1[islit] = nspec_vec[islit]-1
spat_left = spat_righ + nspat_pad
slitcen = (slit_left + slit_righ)/2.0
tslits_dict_psuedo = dict(slit_left=slit_left, slit_righ=slit_righ, slitcen=slitcen,
nspec=nspec_psuedo, nspat=nspat_psuedo, pad=0,
nslits = nslits, binspectral=1, binspatial=1, spectrograph=spectrograph.spectrograph,
spec_min=spec_min1, spec_max=spec_max1)
slitmask_psuedo = pixels.tslits2mask(tslits_dict_psuedo)
# This is a kludge to deal with cases where bad wavelengths result in large regions where the slit is poorly sampled,
# which wreaks havoc on the local sky-subtraction
min_slit_frac = 0.70
spec_min = np.zeros(nslits)
spec_max = np.zeros(nslits)
for islit in range(nslits):
slit_width = np.sum(inmask_psuedo*(slitmask_psuedo == islit),axis=1)
slit_width_img = np.outer(slit_width, np.ones(nspat_psuedo))
med_slit_width = np.median(slit_width_img[slitmask_psuedo==islit])
nspec_eff = np.sum(slit_width > min_slit_frac*med_slit_width)
nsmooth = int(np.fmax(np.ceil(nspec_eff*0.02),10))
slit_width_sm = scipy.ndimage.filters.median_filter(slit_width, size=nsmooth, mode='reflect')
igood = (slit_width_sm > min_slit_frac*med_slit_width)
spec_min[islit] = spec_vec_psuedo[igood].min()
spec_max[islit] = spec_vec_psuedo[igood].max()
bad_pix = (slit_width_img < min_slit_frac*med_slit_width) & (slitmask_psuedo == islit)
inmask_psuedo[bad_pix] = False
# Update with tslits_dict_psuedo
tslits_dict_psuedo['spec_min'] = spec_min
tslits_dict_psuedo['spec_max'] = spec_max
slitmask_psuedo = pixels.tslits2mask(tslits_dict_psuedo)
# Make a fake bitmask from the outmask. We are kludging the crmask to be the outmask_psuedo here, and setting the bpm to
# be good everywhere
mask = processimages.ProcessImages.build_mask(imgminsky_psuedo, sciivar_psuedo, np.invert(inmask_psuedo),
np.zeros_like(inmask_psuedo), slitmask=slitmask_psuedo)
redux = reduce.instantiate_me(spectrograph, tslits_dict_psuedo, mask, ir_redux=ir_redux, par=par,
objtype = 'science', binning=binning)
if show:
redux.show('image', image=imgminsky_psuedo*(mask == 0), chname = 'imgminsky', slits=True, clear=True)
# Object finding
sobjs_obj, nobj, skymask_init = redux.find_objects(imgminsky_psuedo, sciivar_psuedo, ir_redux=ir_redux, std=std,
show_peaks=show_peaks, show=show)
# Local sky-subtraction
global_sky_psuedo = np.zeros_like(imgminsky_psuedo) # No global sky for co-adds since we go straight to local
rn2img_psuedo = global_sky_psuedo # No rn2img for co-adds since we go do not model noise
skymodel_psuedo, objmodel_psuedo, ivarmodel_psuedo, outmask_psuedo, sobjs = \
redux.local_skysub_extract(imgminsky_psuedo, sciivar_psuedo, tilts_psuedo, waveimg_psuedo, global_sky_psuedo,
rn2img_psuedo, sobjs_obj, spat_pix=spat_psuedo, std=std,
model_noise=False, show_profile=show, show=show)
if ir_redux:
sobjs.purge_neg()
# Add the information about the fixed wavelength grid to the sobjs
for spec in sobjs:
spec.boxcar['WAVE_GRID_MASK'] = wave_mask[:,spec.slitid]
spec.boxcar['WAVE_GRID'] = wave_mid[:,spec.slitid]
spec.boxcar['WAVE_GRID_MIN'] = wave_min[:,spec.slitid]
spec.boxcar['WAVE_GRID_MAX'] = wave_max[:,spec.slitid]
spec.optimal['WAVE_GRID_MASK'] = wave_mask[:,spec.slitid]
spec.optimal['WAVE_GRID'] = wave_mid[:,spec.slitid]
spec.optimal['WAVE_GRID_MIN'] = wave_min[:,spec.slitid]
spec.optimal['WAVE_GRID_MAX'] = wave_max[:,spec.slitid]
# TODO Implement flexure and heliocentric corrections on the single exposure 1d reductions and apply them to the
# waveimage. Change the data model to accomodate a wavelength model for each image.
# Using the same implementation as in core/pypeit
# Write out the psuedo master files to disk
master_key_dict = stack_dict['master_key_dict']
# TODO: These saving operations are a temporary kludge
waveImage = WaveImage(None, None, None, None, None, master_key=master_key_dict['arc'],
master_dir=master_dir)
waveImage.save(mswave=waveimg_psuedo)
traceSlits = TraceSlits(None, None, master_key=master_key_dict['trace'], master_dir=master_dir)
traceSlits.save(tslits_dict=tslits_dict_psuedo)
return imgminsky_psuedo, sciivar_psuedo, skymodel_psuedo, objmodel_psuedo, ivarmodel_psuedo, outmask_psuedo, sobjs
newcoords_tr = newcoords.transpose(newcoords_dims)
# makes a view that affects newcoords
newcoords_tr += ofs
deltas = (np.asarray(old) - m1) / (newdims - m1)
newcoords_tr *= deltas
newcoords_tr -= ofs
newa = ndimage.map_coordinates(a, newcoords)
return newa
else:
print("Congrid error: Unrecognized interpolation type. Currently only \'neighbour\', \'nearest\',\'linear\',", \
"and \'spline\' are supported.")
return None
TSlits = TraceSlits(None, None)
masterfile = '/Users/joe/python/PypeIt-development-suite/REDUX_OUT_old/Keck_NIRES/NIRES/MF_keck_nires/MasterTrace_A_15_01'
tset_slits = TSlits.load_master(masterfile)
spectrograph = load_spectrograph('keck_nires')
slitmask_orig = spectrograph.slitmask(tset_slits)
slitmask_orig = slitmask_orig[1:,1:]
#slitmask_new = (np.round(congrid(slitmask_orig.astype(np.float64), (2048,2048), method='neighbour'))).astype(slitmask_orig.dtype)
newshape = (2047*2,1023)
slitmask_new = rebin(slitmask_orig, newshape)
slitmask_old = rebin(slitmask_new,slitmask_orig.shape)
slitmask_new1 = ((np.round(resize(slitmask_orig.astype(np.integer), newshape, preserve_range=True, order=0))).astype(np.integer)).astype(slitmask_orig.dtype)
slitmask_old1 = ((np.round(resize(slitmask_new1.astype(np.integer), slitmask_orig.shape, preserve_range=True, order=0))).astype(np.integer)).astype(slitmask_orig.dtype)
def load_coadd2d_stacks(spec2d_files, det):
"""
Args:
spec2d_files: list
List of spec2d filenames
det: int
detector in question
Returns:
stack_dict: dict
Dictionary containing all the images and keys required for perfomring 2d coadds.
"""
# Get the detector string
sdet = parse.get_dnum(det, prefix=False)
# Get the master dir
head0 = fits.getheader(spec2d_files[0])
master_dir = os.path.basename(head0['PYPMFDIR'])
redux_path = os.getcwd()
master_path = os.path.join(redux_path, master_dir)
# Grab the files
head2d_list=[]
tracefiles = []
waveimgfiles = []
tiltfiles = []
spec1d_files = []
for f in spec2d_files:
head = fits.getheader(f)
trace_key = '{0}_{1:02d}'.format(head['TRACMKEY'], det)
wave_key = '{0}_{1:02d}'.format(head['ARCMKEY'], det)
head2d_list.append(head)
spec1d_files.append(f.replace('spec2d', 'spec1d'))
tracefiles.append(os.path.join(master_path,
MasterFrame.construct_file_name('Trace', trace_key)))
waveimgfiles.append(os.path.join(master_path,
MasterFrame.construct_file_name('Wave', wave_key)))
tiltfiles.append(os.path.join(master_path,
MasterFrame.construct_file_name('Tilts', wave_key)))
nfiles = len(spec2d_files)
specobjs_list = []
head1d_list=[]
# TODO Sort this out with the correct detector extensions etc.
# Read in the image stacks
for ifile in range(nfiles):
waveimg = WaveImage.load_from_file(waveimgfiles[ifile])
tilts = WaveTilts.load_from_file(tiltfiles[ifile])
hdu = fits.open(spec2d_files[ifile])
# One detector, sky sub for now
names = [hdu[i].name for i in range(len(hdu))]
# science image
try:
exten = names.index('DET{:s}-PROCESSED'.format(sdet))
except: # Backwards compatability
det_error_msg(exten, sdet)
sciimg = hdu[exten].data
# skymodel
try:
exten = names.index('DET{:s}-SKY'.format(sdet))
except: # Backwards compatability
det_error_msg(exten, sdet)
skymodel = hdu[exten].data
# Inverse variance model
try:
exten = names.index('DET{:s}-IVARMODEL'.format(sdet))
except ValueError: # Backwards compatability
det_error_msg(exten, sdet)
sciivar = hdu[exten].data
# Mask
try:
exten = names.index('DET{:s}-MASK'.format(sdet))
except ValueError: # Backwards compatability
det_error_msg(exten, sdet)
mask = hdu[exten].data
if ifile == 0:
# the two shapes accomodate the possibility that waveimg and tilts are binned differently
shape_wave = (nfiles,waveimg.shape[0],waveimg.shape[1])
shape_sci = (nfiles,sciimg.shape[0],sciimg.shape[1])
waveimg_stack = np.zeros(shape_wave,dtype=float)
tilts_stack = np.zeros(shape_wave,dtype=float)
sciimg_stack = np.zeros(shape_sci,dtype=float)
skymodel_stack = np.zeros(shape_sci,dtype=float)
sciivar_stack = np.zeros(shape_sci,dtype=float)
mask_stack = np.zeros(shape_sci,dtype=float)
waveimg_stack[ifile,:,:] = waveimg
tilts_stack[ifile,:,:] = tilts['tilts']
sciimg_stack[ifile,:,:] = sciimg
sciivar_stack[ifile,:,:] = sciivar
mask_stack[ifile,:,:] = mask
skymodel_stack[ifile,:,:] = skymodel
sobjs, head = load.load_specobjs(spec1d_files[ifile])
head1d_list.append(head)
specobjs_list.append(sobjs)
# Right now we assume there is a single tslits_dict for all images and read in the first one
# TODO this needs to become a tslits_dict for each file to accomodate slits defined by flats taken on different
# nights
tslits_dict, _ = TraceSlits.load_from_file(tracefiles[0])
spectrograph = util.load_spectrograph(tslits_dict['spectrograph'])
slitmask = pixels.tslits2mask(tslits_dict)
slitmask_stack = np.einsum('i,jk->ijk', np.ones(nfiles), slitmask)
# Fill the master key dict
head2d = head2d_list[0]
master_key_dict = {}
master_key_dict['frame'] = head2d['FRAMMKEY'] + '_{:02d}'.format(det)
master_key_dict['bpm'] = head2d['BPMMKEY'] + '_{:02d}'.format(det)
master_key_dict['bias'] = head2d['BIASMKEY'] + '_{:02d}'.format(det)
master_key_dict['arc'] = head2d['ARCMKEY'] + '_{:02d}'.format(det)
master_key_dict['trace'] = head2d['TRACMKEY'] + '_{:02d}'.format(det)
master_key_dict['flat'] = head2d['FLATMKEY'] + '_{:02d}'.format(det)
stack_dict = dict(specobjs_list=specobjs_list, tslits_dict=tslits_dict,
slitmask_stack=slitmask_stack,
sciimg_stack=sciimg_stack, sciivar_stack=sciivar_stack,
skymodel_stack=skymodel_stack, mask_stack=mask_stack,
tilts_stack=tilts_stack, waveimg_stack=waveimg_stack,
head1d_list = head1d_list, head2d_list=head2d_list,
redux_path=redux_path, master_path=master_path, master_dir=master_dir,
master_key_dict=master_key_dict,
spectrograph = tslits_dict['spectrograph'])
return stack_dict
def main(args):
# List only?
hdu = fits.open(args.file)
head0 = hdu[0].header
if args.list:
hdu.info()
return
# Init
sdet = get_dnum(args.det, prefix=False)
# One detector, sky sub for now
names = [hdu[i].name for i in range(len(hdu))]
try:
exten = names.index('DET{:s}-PROCESSED'.format(sdet))
except: # Backwards compatability
msgs.error('Requested detector {:s} was not processed.\n'
'Maybe you chose the wrong one to view?\n'
'Set with --det= or check file contents with --list'.format(sdet))
sciimg = hdu[exten].data
try:
exten = names.index('DET{:s}-SKY'.format(sdet))
except: # Backwards compatability
msgs.error('Requested detector {:s} has no sky model.\n'
'Maybe you chose the wrong one to view?\n'
'Set with --det= or check file contents with --list'.format(sdet))
skymodel = hdu[exten].data
try:
exten = names.index('DET{:s}-MASK'.format(sdet))
except ValueError: # Backwards compatability
msgs.error('Requested detector {:s} has no bit mask.\n'
'Maybe you chose the wrong one to view?\n'
'Set with --det= or check file contents with --list'.format(sdet))
mask = hdu[exten].data
frame = (sciimg - skymodel) * (mask == 0)
mdir = head0['PYPMFDIR']
if not os.path.exists(mdir):
mdir_base = os.path.join(os.getcwd(), os.path.basename(mdir))
msgs.warn('Master file dir: {0} does not exist. Using {1}'.format(mdir, mdir_base))
mdir = mdir_base
trace_key = '{0}_{1:02d}'.format(head0['TRACMKEY'], args.det)
trc_file = os.path.join(mdir, MasterFrame.construct_file_name('Trace', trace_key))
# TODO -- Remove this once the move to Edges is complete
if args.old:
tslits_dict = TraceSlits.load_from_file(trc_file)[0]
else:
trc_file = trc_file.replace('Trace', 'Edges')+'.gz'
tslits_dict = edgetrace.EdgeTraceSet.from_file(trc_file).convert_to_tslits_dict()
shape = (tslits_dict['nspec'], tslits_dict['nspat'])
slit_ids = [trace_slits.get_slitid(shape, tslits_dict['slit_left'], tslits_dict['slit_righ'], ii)[0]
for ii in range(tslits_dict['slit_left'].shape[1])]
# Object traces
spec1d_file = args.file.replace('spec2d', 'spec1d')
det_nm = 'DET{:s}'.format(sdet)
if os.path.isfile(spec1d_file):
hdulist_1d = fits.open(spec1d_file)
else:
hdulist_1d = []
msgs.warn('Could not find spec1d file: {:s}'.format(spec1d_file) + msgs.newline() +
' No objects were extracted.')
tslits_dict['objtrc'] = parse_traces(hdulist_1d, det_nm)
# TODO :: Need to include standard star trace in the spec2d files
std_trace = None
# Extract some trace models
fwhm = 2 # Start with some default value
# Brightest object on slit
trace_model_obj = None
trace_model_dict = dict()
if len(tslits_dict['objtrc']['pkflux']) > 0:
smash_peakflux = tslits_dict['objtrc']['pkflux']
ibri = smash_peakflux.argmax()
trace_model_obj = tslits_dict['objtrc']['traces'][ibri]
fwhm = tslits_dict['objtrc']['fwhm'][ibri]
trace_model_dict['object'] = dict(trace_model=trace_model_obj, fwhm=fwhm)
# Standard star trace
trace_model_dict['std'] = dict(trace_model=std_trace, fwhm=fwhm)
# Trace of the slit edge
trace_model_dict['slit'] = dict(trace_model=tslits_dict['slit_left'].copy(), fwhm=fwhm)
tslits_dict['trace_model'] = trace_model_dict
# Finally, initialise the GUI
gui_object_find.initialise(args.det, frame, tslits_dict, None, printout=True, slit_ids=slit_ids)