def extract_arcs(self, slitcen, slitmask, msarc, inmask):
"""
Extract the arcs down each slit/order
Wrapper to arc.get_censpec()
Args:
slitcen (ndarray): Image for tracing
slitmask (ndarray):
msarc (ndarray):
inmask (ndarray):
Returns:
ndarray, ndarray: Extracted arcs
"""
arccen, arc_maskslit = arc.get_censpec(
slitcen,
slitmask,
msarc,
inmask=inmask,
nonlinear_counts=self.nonlinear_counts)
# Step
self.steps.append(inspect.stack()[0][3])
return arccen, arc_maskslit
def extract_arcs(self, slitcen, slitmask, msarc, inmask):
"""
Extract the arcs down each slit/order
Wrapper to arc.get_censpec()
Returns
-------
(self.arccen, self.arc_maskslit_
self.arccen: ndarray, (nspec, nslit)
arc spectrum for all slits
self.arc_maskslit: ndarray, bool (nsit)
boolean array containing a mask indicating which slits are good
"""
# Full template kludge
if self.par['method'] == 'full_template':
nonlinear = 1e10
else:
nonlinear = self.nonlinear_counts
# Do it
# TODO: Consider *not* passing in nonlinear_counts; Probably
# should not mask saturated lines at this stage
arccen, arc_maskslit = arc.get_censpec(slitcen,
slitmask,
msarc,
inmask=inmask,
nonlinear_counts=nonlinear)
# Step
self.steps.append(inspect.stack()[0][3])
return arccen, arc_maskslit
def extract_arcs(self):
"""
Extract the arcs down each slit/order
Wrapper to arc.get_censpec()
Args:
Returns:
tuple: Returns the following:
- self.arccen: ndarray, (nspec, nslit): arc spectrum for
all slits
- self.arc_maskslit: ndarray, bool (nsit): boolean array
containing a mask indicating which slits are good
"""
# Do it
arccen, arccen_bpm, arc_maskslit = arc.get_censpec(self.slitcen,
self.slitmask,
self.msarc.image,
gpm=self.gpm)
#, nonlinear_counts=nonlinear) -- Non-linear counts are already part of the gpm
# Step
self.steps.append(inspect.stack()[0][3])
return arccen, arc_maskslit
def extract_arcs(self, slitIDs=None):
"""
Extract the arcs down each slit/order
Wrapper to arc.get_censpec()
Args:
slitIDs (:obj:`list`, optional):
A list of the slit IDs to extract (if None, all slits will be extracted)
Returns:
tuple: Returns the following:
- self.arccen: ndarray, (nspec, nslit): arc spectrum for
all slits
- self.arc_maskslit: ndarray, bool (nsit): boolean array
containing a mask indicating which slits are good
True = masked (bad)
"""
# Do it on the slits not masked in self.slitmask
arccen, arccen_bpm, arc_maskslit = arc.get_censpec(
self.slitcen,
self.slitmask,
self.msarc.image,
gpm=self.gpm,
slit_bpm=self.wvc_bpm,
slitIDs=slitIDs)
# Step
self.steps.append(inspect.stack()[0][3])
# Update the mask
self.wvc_bpm |= arc_maskslit
return arccen, self.wvc_bpm
def extract_arcs(self):
"""
Extract the arcs down each slit/order
Wrapper to arc.get_censpec()
Args:
Returns:
np.ndarray, np.ndarray: Extracted arcs
"""
arccen, arccen_bpm, arc_maskslit = arc.get_censpec(self.slitcen,
self.slitmask,
self.msarc.image,
gpm=self.gpm)
#, nonlinear_counts=self.nonlinear_counts)
# Step
self.steps.append(inspect.stack()[0][3])
return arccen, arccen_bpm, arc_maskslit
def extract_arcs(self):
"""
Extract the arcs down each slit/order
Wrapper to arc.get_censpec()
Returns:
:obj:`tuple`: Extracted arcs in two `numpy.ndarray`_ objects
"""
arccen, arccen_bpm, arc_maskslit = arc.get_censpec(self.slitcen, self.slitmask,
self.mstilt.image, gpm=self.gpm,
slit_bpm=self.tilt_bpm)
#, nonlinear_counts=self.nonlinear_counts)
# Step
self.steps.append(inspect.stack()[0][3])
# Update the mask
self.tilt_bpm |= arc_maskslit
return arccen, arccen_bpm
tslits_dict[tkey] = np.array(tslits_dict[tkey])
else:
tslits_dict = get_tslits_nires(args.flatfiles, user_settings=par, gingashow=gingashow)
# Get Tilts from scienceB image
aImage = arcimage.ArcImage(spectrograph,
file_list=args.sciBfiles,
par=par['calibrations']['arcframe'])
msarc = aImage.process(bias_subtract='overscan',
trim=False)
pixlocn = pixels.gen_pixloc(aImage.stack.shape)
bpm = spectrograph.bpm(shape=msarc.shape, det=1)
# Extract spectrum at the center
arccen, mask, _ = arc.get_censpec(tslits_dict['lcen'],
tslits_dict['rcen'],
pixlocn,
msarc,
1)
waveTilts = wavetilts.WaveTilts(msarc, spectrograph=spectrograph,
par=par['calibrations']['tilts'], det=1,
tslits_dict=tslits_dict, pixlocn=pixlocn)
nslits = tslits_dict['lcen'].shape[1]
maskslits = np.zeros(nslits, dtype=bool)
# QA is not working here
mstilts, wt_maskslits = waveTilts.run(maskslits=maskslits,
wv_calib=None,
doqa=False)
# Wavelength calibration from scienceB image
arcparam = {}
spectrograph.setup_arcparam(arcparam)