def build_wv_calib(self, arccen, method, skip_QA=False):
"""
Main routine to generate the wavelength solutions in a loop over slits
Wrapper to arc.simple_calib or arc.calib_with_arclines
self.maskslits is updated for slits that fail
Args:
method : str
'simple' -- arc.simple_calib
'arclines' -- arc.calib_with_arclines
'holy-grail' -- wavecal.autoid.HolyGrail
'reidentify' -- wavecal.auotid.ArchiveReid
'identify' -- wavecal.identify.Identify
'full_template' -- wavecal.auotid.full_template
skip_QA (bool, optional)
Returns:
dict: self.wv_calib
"""
# Obtain a list of good slits
ok_mask_idx = np.where(np.invert(self.wvc_bpm))[0]
# Obtain calibration for all slits
if method == 'simple':
lines = self.par['lamps']
line_lists = waveio.load_line_lists(lines)
final_fit = arc.simple_calib_driver(
line_lists,
arccen,
ok_mask_idx,
n_final=self.par['n_final'],
sigdetect=self.par['sigdetect'],
IDpixels=self.par['IDpixels'],
IDwaves=self.par['IDwaves'])
elif method == 'holy-grail':
# Sometimes works, sometimes fails
arcfitter = autoid.HolyGrail(
arccen,
par=self.par,
ok_mask=ok_mask_idx,
nonlinear_counts=self.nonlinear_counts)
patt_dict, final_fit = arcfitter.get_results()
elif method == 'identify':
final_fit = {}
# Manually identify lines
msgs.info("Initializing the wavelength calibration tool")
embed(header='line 222 wavecalib.py')
for slit_idx in ok_mask_idx:
arcfitter = Identify.initialise(arccen,
self.slits,
slit=slit_idx,
par=self.par)
final_fit[str(slit_idx)] = arcfitter.get_results()
arcfitter.store_solution(final_fit[str(slit_idx)],
"",
self.binspectral,
specname=self.spectrograph.name,
gratname="UNKNOWN",
dispangl="UNKNOWN")
elif method == 'reidentify':
# Now preferred
# Slit positions
arcfitter = autoid.ArchiveReid(
arccen,
self.spectrograph,
self.par,
ok_mask=ok_mask_idx,
#slit_spat_pos=self.spat_coo,
orders=self.orders,
nonlinear_counts=self.nonlinear_counts)
patt_dict, final_fit = arcfitter.get_results()
elif method == 'full_template':
# Now preferred
if self.binspectral is None:
msgs.error(
"You must specify binspectral for the full_template method!"
)
final_fit = autoid.full_template(
arccen,
self.par,
ok_mask_idx,
self.det,
self.binspectral,
nonlinear_counts=self.nonlinear_counts,
nsnippet=self.par['nsnippet'])
else:
msgs.error(
'Unrecognized wavelength calibration method: {:}'.format(
method))
# Build the DataContainer
# Loop on WaveFit items
tmp = []
for idx in range(self.slits.nslits):
item = final_fit.pop(str(idx))
if item is None: # Add an empty WaveFit
tmp.append(wv_fitting.WaveFit(self.slits.spat_id[idx]))
else:
# This is for I/O naming
item.spat_id = self.slits.spat_id[idx]
tmp.append(item)
self.wv_calib = WaveCalib(
wv_fits=np.asarray(tmp),
arc_spectra=arccen,
nslits=self.slits.nslits,
spat_ids=self.slits.spat_id,
PYP_SPEC=self.spectrograph.name,
)
# Update mask
self.update_wvmask()
#TODO For generalized echelle (not hard wired) assign order number here before, i.e. slits.ech_order
# QA
if not skip_QA:
ok_mask_idx = np.where(np.invert(self.wvc_bpm))[0]
for slit_idx in ok_mask_idx:
outfile = qa.set_qa_filename(
self.master_key,
'arc_fit_qa',
slit=self.slits.slitord_id[slit_idx],
out_dir=self.qa_path)
#
#autoid.arc_fit_qa(self.wv_calib[str(self.slits.slitord_id[slit_idx])],
# outfile=outfile)
autoid.arc_fit_qa(
self.wv_calib.wv_fits[slit_idx],
#str(self.slits.slitord_id[slit_idx]),
outfile=outfile)
# Return
self.steps.append(inspect.stack()[0][3])
return self.wv_calib
def main(args):
import os
import sys
from pypeit import masterframe
from pypeit.spectrographs.util import load_spectrograph
from pypeit.core.gui.identify import Identify
from pypeit.core.wavecal import waveio
from pypeit.wavecalib import WaveCalib
from pypeit import slittrace
from pypeit.images.buildimage import ArcImage
# Load the MasterArc file
if os.path.exists(args.arc_file):
arcfil = args.arc_file
else:
try:
arcfil = "Masters/{0:s}".format(args.arc_file)
except FileNotFoundError:
print("Could not find MasterArc file.")
sys.exit()
msarc = ArcImage.from_file(arcfil)
mdir = msarc.head0['MSTRDIR']
mkey = msarc.head0['MSTRKEY']
# Load the spectrograph
specname = msarc.head0['PYP_SPEC']
spec = load_spectrograph(specname)
par = spec.default_pypeit_par()['calibrations']['wavelengths']
# Get the lamp list
if args.lamps is None:
lamplist = par['lamps']
if lamplist is None:
print("ERROR :: Cannot determine the lamps")
sys.exit()
else:
lamplist = args.lamps.split(",")
par['lamps'] = lamplist
# Load the slits
slits = slittrace.SlitTraceSet.from_file(args.slits_file)
# Reset the mask
slits.mask = slits.mask_init
# Check if a solution exists
solnname = os.path.join(mdir,
masterframe.construct_file_name(WaveCalib, mkey))
wv_calib = waveio.load_wavelength_calibration(
solnname) if os.path.exists(solnname) and args.solution else None
# Load the MasterFrame (if it exists and is desired)?
wavecal = WaveCalib(msarc,
slits,
spec,
par,
binspectral=slits.binspec,
det=args.det,
master_key=mkey,
msbpm=msarc.fullmask)
arccen, arc_maskslit = wavecal.extract_arcs(slitIDs=[args.slit])
# Launch the identify window
arcfitter = Identify.initialise(arccen,
slits,
slit=int(args.slit),
par=par,
wv_calib_all=wv_calib,
wavelim=[args.wmin, args.wmax],
nonlinear_counts=spec.nonlinear_counts(
msarc.detector))
final_fit = arcfitter.get_results()
# Ask the user if they wish to store the result in PypeIt calibrations
arcfitter.store_solution(final_fit,
mdir,
slits.binspec,
rmstol=args.rmstol,
specname=specname)
def main(args):
import os
import sys
import numpy as np
from pypeit import msgs
from pypeit import masterframe
from pypeit.spectrographs.util import load_spectrograph
from pypeit.core.gui.identify import Identify
from pypeit.core.wavecal import waveio
from pypeit.wavecalib import BuildWaveCalib, WaveCalib
from pypeit import slittrace
from pypeit.images.buildimage import ArcImage
# Load the MasterArc file
msarc = ArcImage.from_file(args.arc_file)
# Load the spectrograph
spec = load_spectrograph(msarc.PYP_SPEC)
par = spec.default_pypeit_par()['calibrations']['wavelengths']
# Get the lamp list
if args.lamps is None:
lamps = par['lamps']
if lamps is None or lamps == ['use_header']:
msgs.error('Cannot determine the lamps; use --lamps argument')
else:
lamps = args.lamps.split(",")
par['lamps'] = lamps
# Load the slits
slits = slittrace.SlitTraceSet.from_file(args.slits_file)
# Reset the mask
slits.mask = slits.mask_init
# Check if a solution exists
solnname = masterframe.construct_file_name(WaveCalib,
msarc.master_key,
master_dir=msarc.master_dir)
wv_calib = waveio.load_wavelength_calibration(solnname) \
if os.path.exists(solnname) and args.solution else None
# Load the MasterFrame (if it exists and is desired). Bad-pixel mask
# set to any flagged pixel in MasterArc.
wavecal = BuildWaveCalib(msarc,
slits,
spec,
par,
lamps,
binspectral=slits.binspec,
det=args.det,
master_key=msarc.master_key,
msbpm=msarc.select_flag())
arccen, arc_maskslit = wavecal.extract_arcs(slitIDs=[args.slit])
# Launch the identify window
# TODO -- REMOVE THIS HACK
try:
nonlinear_counts = msarc.detector.nonlinear_counts()
except AttributeError:
nonlinear_counts = None
arcfitter = Identify.initialise(arccen,
lamps,
slits,
slit=int(args.slit),
par=par,
wv_calib_all=wv_calib,
wavelim=[args.wmin, args.wmax],
nonlinear_counts=nonlinear_counts,
pxtoler=args.pixtol,
test=args.test,
fwhm=args.fwhm,
sigdetect=args.sigdetect,
specname=spec.name,
y_log=not args.linear)
# Testing?
if args.test:
return arcfitter
final_fit = arcfitter.get_results()
# Build here to avoid circular import
# Note: This needs to be duplicated in test_scripts.py
# Wavecalib (wanted when dealing with multiple detectors, eg. GMOS)
if 'WaveFit' in arcfitter._fitdict.keys():
waveCalib = WaveCalib(
nslits=1,
wv_fits=np.atleast_1d(arcfitter._fitdict['WaveFit']),
arc_spectra=np.atleast_2d(arcfitter.specdata).T,
spat_ids=np.atleast_1d(int(arcfitter._spatid)),
PYP_SPEC=msarc.PYP_SPEC,
lamps=','.join(lamps))
else:
waveCalib = None
# Ask the user if they wish to store the result in PypeIt calibrations
arcfitter.store_solution(final_fit,
slits.binspec,
wvcalib=waveCalib,
rmstol=args.rmstol,
force_save=args.force_save)
def main(args):
import os
import sys
import numpy as np
from pypeit import masterframe
from pypeit.spectrographs.util import load_spectrograph
from pypeit.core.gui.identify import Identify
from pypeit.core.wavecal import waveio
from pypeit.wavecalib import BuildWaveCalib, WaveCalib
from pypeit import slittrace
from pypeit.images.buildimage import ArcImage
# Load the MasterArc file
if os.path.exists(args.arc_file):
arcfil = args.arc_file
else:
try:
arcfil = "Masters/{0:s}".format(args.arc_file)
except FileNotFoundError:
print("Could not find MasterArc file.")
sys.exit()
msarc = ArcImage.from_file(arcfil)
mdir = msarc.head0['MSTRDIR']
mkey = msarc.head0['MSTRKEY']
# Load the spectrograph
specname = msarc.head0['PYP_SPEC']
spec = load_spectrograph(specname)
par = spec.default_pypeit_par()['calibrations']['wavelengths']
# Get the lamp list
if args.lamps is None:
lamplist = par['lamps']
if lamplist is None:
print("ERROR :: Cannot determine the lamps")
sys.exit()
else:
lamplist = args.lamps.split(",")
par['lamps'] = lamplist
# Load the slits
slits = slittrace.SlitTraceSet.from_file(args.slits_file)
# Reset the mask
slits.mask = slits.mask_init
# Check if a solution exists
solnname = os.path.join(mdir,
masterframe.construct_file_name(WaveCalib, mkey))
wv_calib = waveio.load_wavelength_calibration(
solnname) if os.path.exists(solnname) and args.solution else None
# Load the MasterFrame (if it exists and is desired)?
wavecal = BuildWaveCalib(msarc,
slits,
spec,
par,
binspectral=slits.binspec,
det=args.det,
master_key=mkey,
msbpm=msarc.fullmask)
arccen, arc_maskslit = wavecal.extract_arcs(slitIDs=[args.slit])
# Launch the identify window
arcfitter = Identify.initialise(arccen,
slits,
slit=int(args.slit),
par=par,
wv_calib_all=wv_calib,
wavelim=[args.wmin, args.wmax],
nonlinear_counts=spec.nonlinear_counts(
msarc.detector),
pxtoler=args.pixtol,
test=args.test,
fwhm=args.fwhm)
# Testing?
if args.test:
return arcfitter
final_fit = arcfitter.get_results()
# Build here to avoid circular import
# Note: This needs to be duplicated in test_scripts.py
# Wavecalib (wanted when dealing with multiple detectors, eg. GMOS)
if 'WaveFit' in arcfitter._fitdict.keys():
waveCalib = WaveCalib(
nslits=1,
wv_fits=np.atleast_1d(arcfitter._fitdict['WaveFit']),
arc_spectra=np.atleast_2d(arcfitter.specdata).T,
spat_ids=np.atleast_1d(arcfitter._slit),
PYP_SPEC=specname,
)
else:
waveCalib = None
# Ask the user if they wish to store the result in PypeIt calibrations
arcfitter.store_solution(final_fit,
mdir,
slits.binspec,
wvcalib=waveCalib,
rmstol=args.rmstol,
force_save=args.force_save)
def build_wv_calib(self, arccen, method, skip_QA=False):
"""
Main routine to generate the wavelength solutions in a loop over slits
Wrapper to arc.simple_calib or arc.calib_with_arclines
self.maskslits is updated for slits that fail
Args:
method : str
'simple' -- arc.simple_calib
'arclines' -- arc.calib_with_arclines
'holy-grail' -- wavecal.autoid.HolyGrail
'reidentify' -- wavecal.auotid.ArchiveReid
'identify' -- wavecal.identify.Identify
'full_template' -- wavecal.auotid.full_template
skip_QA (bool, optional)
Returns:
dict: self.wv_calib
"""
# Obtain a list of good slits
ok_mask_idx = np.where(np.invert(self.wvc_bpm))[0]
# Obtain calibration for all slits
if method == 'simple':
lines = self.par['lamps']
line_lists = waveio.load_line_lists(lines)
final_fit = arc.simple_calib_driver(
line_lists,
arccen,
ok_mask_idx,
n_final=self.par['n_final'],
sigdetect=self.par['sigdetect'],
IDpixels=self.par['IDpixels'],
IDwaves=self.par['IDwaves'])
# elif method == 'basic':
# final_fit = {}
# for slit in ok_mask:
# status, ngd_match, match_idx, scores, ifinal_fit = \
# autoid.basic(arccen[:, slit], self.par['lamps'], self.par['wv_cen'],
# self.par['disp'], nonlinear_counts=self.nonlinear_counts)
# final_fit[str(slit)] = ifinal_fit.copy()
# if status != 1:
# self.maskslits[slit] = True
elif method == 'holy-grail':
# Sometimes works, sometimes fails
arcfitter = autoid.HolyGrail(
arccen,
par=self.par,
ok_mask=ok_mask_idx,
nonlinear_counts=self.nonlinear_counts)
patt_dict, final_fit = arcfitter.get_results()
elif method == 'identify':
final_fit = {}
# Manually identify lines
msgs.info("Initializing the wavelength calibration tool")
embed()
for slit_idx in ok_mask_idx:
arcfitter = Identify.initialise(arccen,
self.slits,
slit=slit_idx,
par=self.par)
final_fit[str(slit_idx)] = arcfitter.get_results()
arcfitter.store_solution(
final_fit[str(slit_idx)],
"",
self.binspectral,
specname=self.spectrograph.spectrograph,
gratname="UNKNOWN",
dispangl="UNKNOWN")
elif method == 'reidentify':
# Now preferred
# Slit positions
arcfitter = autoid.ArchiveReid(
arccen,
self.spectrograph,
self.par,
ok_mask=ok_mask_idx,
slit_spat_pos=self.spat_coo,
nonlinear_counts=self.nonlinear_counts)
patt_dict, final_fit = arcfitter.get_results()
elif method == 'full_template':
# Now preferred
if self.binspectral is None:
msgs.error(
"You must specify binspectral for the full_template method!"
)
final_fit = autoid.full_template(
arccen,
self.par,
ok_mask_idx,
self.det,
self.binspectral,
nonlinear_counts=self.nonlinear_counts,
nsnippet=self.par['nsnippet'])
else:
msgs.error(
'Unrecognized wavelength calibration method: {:}'.format(
method))
# Convert keys to spatial system
self.wv_calib = {}
tmp = copy.deepcopy(final_fit)
for idx in range(self.slits.nslits):
if str(idx) in final_fit.keys():
self.wv_calib[str(self.slits.slitord_id[idx])] = final_fit.pop(
str(idx))
# Update mask
self.update_wvmask()
#TODO For generalized echelle (not hard wired) assign order number here before, i.e. slits.ech_order
# QA
if not skip_QA:
ok_mask_idx = np.where(np.invert(self.wvc_bpm))[0]
for slit_idx in ok_mask_idx:
outfile = qa.set_qa_filename(
self.master_key,
'arc_fit_qa',
slit=self.slits.slitord_id[slit_idx],
out_dir=self.qa_path)
autoid.arc_fit_qa(self.wv_calib[str(
self.slits.slitord_id[slit_idx])],
outfile=outfile)
# Return
self.steps.append(inspect.stack()[0][3])
return self.wv_calib