def test_build_me():
# Masters
spectrograph = load_spectrograph('shane_kast_blue')
edges, tilts_dict, wv_calib = load_kast_blue_masters(edges=True,
tilts=True,
wvcalib=True)
tslits_dict = edges.convert_to_tslits_dict()
# Instantiate
master_key = 'A_01_aa'
master_dir = os.path.join(os.getenv('PYPEIT_DEV'), 'Cooked',
'Shane_Kast_blue')
nslits = tslits_dict['nslits']
maskslits = np.zeros(nslits, dtype=bool)
det = 1
wvImg = waveimage.WaveImage(tslits_dict,
tilts_dict['tilts'],
wv_calib,
spectrograph,
det,
maskslits,
master_key=master_key,
master_dir=master_dir,
reuse_masters=True)
# Build
wave = wvImg.build_wave()
assert int(np.max(wave)) > 5510
def get_wave(self):
"""
Load or generate a wavelength image
Requirements:
tilts_dict, tslits_dict, wv_calib
det, par, master_key
Returns:
ndarray: :attr:`mswave` wavelength image
"""
# Check for existing data
if not self._chk_objs(['tilts_dict', 'tslits_dict', 'wv_calib']):
self.mswave = None
return self.mswave
# Check internals
self._chk_set(['det', 'par'])
# Return existing data
if self._cached('wave', self.master_key_dict['arc']):
self.mswave = self.calib_dict[self.master_key_dict['arc']]['wave']
return self.mswave
# No wavelength calibration requested
if self.par['wavelengths']['reference'] == 'pixel':
msgs.warn('No wavelength calibration performed!')
self.mswave = self.tilts_dict['tilts'] * (
self.tilts_dict['tilts'].shape[0] - 1.0)
self.calib_dict[self.master_key_dict['arc']]['wave'] = self.mswave
return self.mswave
# Instantiate
# TODO we are regenerating this mask a lot in this module. Could reduce that
self.waveImage = waveimage.WaveImage(
self.tslits_dict,
self.tilts_dict['tilts'],
self.wv_calib,
self.spectrograph,
self.det,
self.tslits_dict['maskslits'],
master_key=self.master_key_dict['arc'],
master_dir=self.master_dir,
reuse_masters=self.reuse_masters)
# Attempt to load master
self.mswave = self.waveImage.load()
if self.mswave is None:
self.mswave = self.waveImage.build_wave()
# Save to hard-drive
if self.save_masters:
self.waveImage.save()
# Save & return
self._update_cache('arc', 'wave', self.mswave)
return self.mswave
def test_build_me():
# Masters
spectrograph, tslits_dict, tilts_dict, wv_calib \
= load_kast_blue_masters(get_spectrograph=True, tslits=True, tilts=True, wvcalib=True)
# Instantiate
master_key = 'A_01_aa'
root_path = data_path('MF') if os.getenv('PYPEIT_DEV') is None \
else os.path.join(os.getenv('PYPEIT_DEV'), 'Cooked', 'MF')
master_dir = root_path+'_'+spectrograph.spectrograph
nslits = tslits_dict['slit_left'].shape[1]
maskslits = np.zeros(nslits, dtype=bool)
wvImg = waveimage.WaveImage(tslits_dict, tilts_dict['tilts'], wv_calib, spectrograph, maskslits,
master_key=master_key, master_dir=master_dir, reuse_masters=True)
# Build
wave = wvImg._build_wave()
assert int(np.max(wave)) > 5510
setup = 'NIRES'
waveCalib = wavecalib.WaveCalib(msarc,
spectrograph=spectrograph,
#par=par['calibrations']['wavelengths'],
det=1,
setup=setup,
arcparam=arcparam)
wv_calib, _ = waveCalib.run(tslits_dict['lcen'],
tslits_dict['rcen'],
pixlocn,
nonlinear=spectrograph.detector[0]['nonlinear'])
# Get 2-D wavelength solution
waveImage = waveimage.WaveImage(tslits_dict['slitpix'],
mstilts,
wv_calib,
setup=setup,
maskslits=maskslits)
waveimg = waveImage._build_wave()
# Process science images
datasec_img = np.zeros_like(msarc) + 1
# Hack, create the fitstbl from the header of one of the science frames
# ToDo -- this step should not be necessary
#from astropy.io import fits
#from astropy.table import Table
#hdul = fits.open(args.sciAfiles[0])
#fitstbl = Table(rows=[(hdul[0].header['ITIME'], '1x1')], names=('exptime', 'binning',))
# Processing A
def extract_coadd2d(stack_dict, master_dir, ir_redux=False, par=None, std=False, show=False, show_peaks=False):
"""
Main routine to run the extraction for 2d coadds. 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:
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
# Grab the wavelength grid that we will rectify onto
wave_grid = spectrograph.wavegrid()
wave_grid_mid = spectrograph.wavegrid(midpoint=True)
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')
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']
waveImage = waveimage.WaveImage(None, None, None, None, None,
master_key=master_key_dict['arc'], master_dir=master_dir)
waveImage.save_master(waveimg_psuedo)
traceSlits = traceslits.TraceSlits(None, None, None, master_key=master_key_dict['trace'], master_dir=master_dir)
traceSlits.save_master(tslits_dict_psuedo)
return imgminsky_psuedo, sciivar_psuedo, skymodel_psuedo, objmodel_psuedo, ivarmodel_psuedo, outmask_psuedo, sobjs