def load(self, ifile=None):
"""
Load a full (all slit) wavelength calibration.
This is largely a wrapper for
:func:`pypeit.core.wavecal.waveio.load_wavelength_calibration`.
Args:
ifile (:obj:`str`, optional):
Name of the master frame file. Defaults to
:attr:`file_path`.
Returns:
dict or None: self.wv_calib
"""
if not self.reuse_masters:
# User does not want to load masters
msgs.warn('PypeIt will not reuse masters!')
return None
# Check the input path
_ifile = self.file_path if ifile is None else ifile
if not os.path.isfile(_ifile):
# Master file doesn't exist
msgs.warn('No Master {0} frame found: {1}'.format(
self.master_type, self.file_path))
return None
# Read, save it to self, return
# TODO: Need to save it to self?
msgs.info('Loading Master {0} frame: {1}'.format(
self.master_type, _ifile))
self.wv_calib = waveio.load_wavelength_calibration(_ifile)
return self.wv_calib
def load_from_file(filename):
"""
Load a full (all slit) wavelength calibration.
This simply executes
:func:`pypeit.core.wavecal.waveio.load_wavelength_calibration`.
Args:
filename (:obj:`str`):
Name of the master frame file.
Returns:
dict: The wavelength calibration data.
"""
return waveio.load_wavelength_calibration(filename)
def load(self, ifile):
"""
Load a full (all slit) wavelength calibration.
This is largely a wrapper for
:func:`pypeit.core.wavecal.waveio.load_wavelength_calibration`.
Args:
ifile (:obj:`str`, optional):
Name of the master frame file. Defaults to
:attr:`master_file_path`.
Returns:
dict or None: self.wv_calib
"""
# Check on whether to reuse and whether the file exists
self.wv_calib = waveio.load_wavelength_calibration(ifile)
return self.wv_calib
def load(self, ifile=None):
"""
Load a full (all slit) wavelength calibration.
This is largely a wrapper for
:func:`pypeit.core.wavecal.waveio.load_wavelength_calibration`.
Args:
ifile (:obj:`str`, optional):
Name of the master frame file. Defaults to
:attr:`master_file_path`.
Returns:
dict or None: self.wv_calib
"""
# Check on whether to reuse and whether the file exists
master_file = self.chk_load_master(ifile)
if master_file is None:
return
# Read, save it to self, return
msgs.info('Loading Master frame: {0}'.format(master_file))
self.wv_calib = waveio.load_wavelength_calibration(master_file)
return self.wv_calib
def test_user_redo():
# Check for files
spectrograph = util.load_spectrograph('shane_kast_blue')
# Instantiate
par = spectrograph.default_pypeit_par()['calibrations']['wavelengths']
master_dir = os.path.join(os.getenv('PYPEIT_DEV'), 'Cooked', 'WaveCalib')
master_key = 'ShaneKastBlue_A'
waveCalib = wavecalib.WaveCalib(None,
None,
spectrograph,
par,
master_dir=master_dir,
master_key=master_key,
reuse_masters=True)
assert os.path.isfile(
waveCalib.master_file_path), 'Did not find Cooked file.'
wv_calib = waveCalib.load()
# Setup
waveCalib.par['sigdetect'] = 5.
nslit = 1
waveCalib.make_maskslits(nslit)
npix = len(waveCalib.wv_calib['0']['spec'])
waveCalib.arccen = np.zeros((npix, nslit))
waveCalib.arccen[:, 0] = waveCalib.wv_calib['0']['spec']
# Do it
new_wv_calib = waveCalib.build_wv_calib(waveCalib.arccen,
'holy-grail',
skip_QA=True)
# Test
assert new_wv_calib['0']['rms'] < 0.2
# Now also test the utility script that reads in the wavecalib
#wv_calib_load = wavecalib.WaveCalib.load_from_file(waveCalib.master_file_path)
wv_calib_load = waveio.load_wavelength_calibration(
waveCalib.master_file_path)
assert np.all(wv_calib['0']['fitc'] == wv_calib_load['0']['fitc'])
def load_kast_blue_masters(aimg=False,
mstilt=False,
edges=False,
tilts=False,
wvcalib=False,
pixflat=False):
"""
Load up the set of shane_kast_blue master frames
Order is Arc, edges, tilts_dict, wv_calib, pixflat
Args:
get_spectrograph:
aimg:
edges (bool, optional):
Load the slit edges
tilts:
datasec:
wvcalib:
Returns:
list: List of calibration items
"""
spectrograph = load_spectrograph('shane_kast_blue')
spectrograph.naxis = (2112, 350) # Image shape with overscan
master_dir = os.path.join(os.getenv('PYPEIT_DEV'), 'Cooked',
'shane_kast_blue')
reuse_masters = True
# Load up the Masters
ret = []
master_key = 'A_1_01'
if aimg:
arc_file = masterframe.construct_file_name(buildimage.ArcImage,
master_key,
master_dir=master_dir)
AImg = buildimage.ArcImage.from_file(arc_file)
if mstilt:
# We use an arc
arc_file = masterframe.construct_file_name(buildimage.ArcImage,
master_key,
master_dir=master_dir)
AImg = buildimage.ArcImage.from_file(arc_file)
# Convert
mstilt = buildimage.TiltImage.from_pypeitimage(AImg)
ret.append(mstilt)
if edges:
#trace_file = '{0}.gz'.format(os.path.join(master_dir,
# MasterFrame.construct_file_name('Edges', master_key)))
trace_file = masterframe.construct_file_name(edgetrace.EdgeTraceSet,
master_key,
master_dir=master_dir)
ret.append(edgetrace.EdgeTraceSet.from_file(trace_file))
if tilts:
tilts_file = masterframe.construct_file_name(wavetilts.WaveTilts,
master_key,
master_dir=master_dir)
waveTilts = wavetilts.WaveTilts.from_file(tilts_file)
ret.append(waveTilts)
if wvcalib:
#calib_file = os.path.join(master_dir,
# MasterFrame.construct_file_name('WaveCalib', master_key,
# file_format='json'))
calib_file = masterframe.construct_file_name(wavecalib.WaveCalib,
master_key,
master_dir=master_dir)
wv_calib = waveio.load_wavelength_calibration(calib_file)
ret.append(wv_calib)
# Pixelflat
if pixflat:
#calib_file = os.path.join(master_dir,
# MasterFrame.construct_file_name('Flat', master_key))
flat_file = masterframe.construct_file_name(flatfield.FlatImages,
master_key,
master_dir=master_dir)
flatImages = flatfield.FlatImages.from_file(flat_file)
ret.append(flatImages.get_pixelflat())
# Return
return ret
def main(args):
import os
import sys
import astropy.io.fits as fits
from pypeit import masterframe
from pypeit.spectrographs.util import load_spectrograph
from pypeit.core import parse
from pypeit.core import gui
from pypeit.core.wavecal import waveio, templates
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 == '':
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) 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()
# Launch the identify window
arcfitter = gui.identify.initialise(arccen,
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
if final_fit['rms'] < args.rmstol:
ans = ''
while ans != 'y' and ans != 'n':
ans = input(
"Would you like to store this wavelength solution in the archive? (y/n): "
)
if ans == 'y':
gratname = fits.getheader(
msarc.head0['F1'])[spec.meta['dispname']['card']].replace(
"/", "_")
dispangl = "UNKNOWN"
templates.pypeit_identify_record(final_fit, slits.binspec,
specname, gratname, dispangl)
print("Your wavelength solution has been stored")
print("Please consider sending your solution to the PypeIt team!")
else:
print(
"Final fit RMS: {0:0.3f} is larger than the allowed tolerance: {1:0.3f}"
.format(final_fit['rms'], args.rmstol))
print(
"Set the variable --rmstol on the command line to allow a more flexible RMS tolerance"
)
ans = ''
while ans != 'y' and ans != 'n':
ans = input("Would you like to store the line IDs? (y/n): ")
if ans == 'y':
arcfitter.save_IDs()
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 load_kast_blue_masters(aimg=False,
edges=False,
tilts=False,
wvcalib=False,
pixflat=False):
"""
Load up the set of shane_kast_blue master frames
Order is Arc, edges, tilts_dict, wv_calib, pixflat
Args:
get_spectrograph:
aimg:
edges (bool, optional):
Load the slit edges
tilts:
datasec:
wvcalib:
Returns:
list: List of calibration items
"""
spectrograph = load_spectrograph('shane_kast_blue')
spectrograph.naxis = (2112, 350) # Image shape with overscan
master_dir = os.path.join(os.getenv('PYPEIT_DEV'), 'Cooked',
'Shane_Kast_blue')
reuse_masters = True
# Load up the Masters
ret = []
master_key = 'A_1_01'
if aimg:
AImg = arcimage.ArcImage(spectrograph,
master_key=master_key,
master_dir=master_dir,
reuse_masters=reuse_masters)
msarc = AImg.load()
ret.append(msarc)
if edges:
trace_file = '{0}.gz'.format(
os.path.join(master_dir,
MasterFrame.construct_file_name('Edges', master_key)))
ret.append(edgetrace.EdgeTraceSet.from_file(trace_file))
if tilts:
tilts_file = os.path.join(
master_dir, MasterFrame.construct_file_name('Tilts', master_key))
tilts_dict = wavetilts.WaveTilts.from_master_file(
tilts_file).tilts_dict
ret.append(tilts_dict)
if wvcalib:
calib_file = os.path.join(
master_dir,
MasterFrame.construct_file_name('WaveCalib',
master_key,
file_format='json'))
wv_calib = waveio.load_wavelength_calibration(calib_file)
ret.append(wv_calib)
# Pixelflat
if pixflat:
calib_file = os.path.join(
master_dir, MasterFrame.construct_file_name('Flat', master_key))
flatField = flatfield.FlatField.from_master_file(calib_file)
ret.append(flatField.mspixelflat)
# Return
return ret
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 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 load_kast_blue_masters(aimg=False,
tslits=False,
tilts=False,
wvcalib=False,
pixflat=False):
"""
Load up the set of shane_kast_blue master frames
Order is Arc, tslits_dict, tilts_dict, wv_calib, pixflat
Args:
get_spectrograph:
aimg:
tslits (bool, optional):
Load the tslits_dict
tilts:
datasec:
wvcalib:
Returns:
list: List of calibration items
"""
spectrograph = load_spectrograph('shane_kast_blue')
spectrograph.naxis = (2112, 350) # Image shape with overscan
master_dir = os.path.join(os.getenv('PYPEIT_DEV'), 'Cooked',
'Shane_Kast_blue')
# master_dir = root_path+'_'+spectrograph.spectrograph
reuse_masters = True
# Load up the Masters
ret = []
# if get_spectrograph:
# ret.append(spectrograph)
master_key = 'A_1_01'
if aimg:
AImg = arcimage.ArcImage(spectrograph,
master_key=master_key,
master_dir=master_dir,
reuse_masters=reuse_masters)
msarc = AImg.load()
ret.append(msarc)
if tslits:
trace_file = os.path.join(
master_dir, MasterFrame.construct_file_name('Trace', master_key))
tslits_dict, mstrace = traceslits.TraceSlits.load_from_file(trace_file)
ret.append(tslits_dict)
ret.append(mstrace)
if tilts:
tilts_file = os.path.join(
master_dir, MasterFrame.construct_file_name('Tilts', master_key))
tilts_dict = wavetilts.WaveTilts.load_from_file(tilts_file)
ret.append(tilts_dict)
if wvcalib:
calib_file = os.path.join(
master_dir,
MasterFrame.construct_file_name('WaveCalib',
master_key,
file_format='json'))
wv_calib = waveio.load_wavelength_calibration(calib_file)
ret.append(wv_calib)
# Pixelflat
if pixflat:
flatField = flatfield.FlatField(
spectrograph,
spectrograph.default_pypeit_par()['calibrations']
['pixelflatframe'])
calib_file = os.path.join(
master_dir, MasterFrame.construct_file_name('Flat', master_key))
pixelflat = flatField.load_from_file(calib_file, 2)
ret.append(pixelflat)
# Return
return ret
def main(args):
import os
import sys
import astropy.io.fits as fits
from pypeit.masterframe import MasterFrame
from pypeit.spectrographs.util import load_spectrograph
from pypeit.core import parse
from pypeit.core.gui import identify as gui_identify
from pypeit.core.wavecal import waveio, templates
from pypeit.wavecalib import WaveCalib
from pypeit import edgetrace
from pypeit.images import pypeitimage
# Load the MasterArc file
if os.path.exists(args.file):
arcfil = args.file
else:
try:
arcfil = "Masters/{0:s}".format(args.file)
except FileNotFoundError:
print("Could not find MasterArc file.")
sys.exit()
msarc = pypeitimage.PypeItImage.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 tslits_dict
trc_file = os.path.join(mdir, MasterFrame.construct_file_name('Edges', mkey, file_format='fits.gz'))
tslits_dict = edgetrace.EdgeTraceSet.from_file(trc_file).convert_to_tslits_dict()
# Check if a solution exists
solnname = os.path.join(mdir, MasterFrame.construct_file_name('WaveCalib', mkey, file_format='json'))
wv_calib = waveio.load_wavelength_calibration(solnname) if os.path.exists(solnname) else None
# Load the MasterFrame (if it exists and is desired)?
wavecal = WaveCalib(msarc, tslits_dict, spec, par)
arccen, arc_maskslit = wavecal.extract_arcs()
binspec, binspat = parse.parse_binning(spec.get_meta_value(msarc.head0['F1'], 'binning'))
# Launch the identify window
arcfitter = gui_identify.initialise(arccen, slit=int(args.slit), par=par, wv_calib_all=wv_calib)
final_fit = arcfitter.get_results()
# Ask the user if they wish to store the result in PypeIt calibrations
ans = ''
while ans != 'y' and ans != 'n':
ans = input("Would you like to store this wavelength solution in the archive? (y/n):")
if ans == 'y' and final_fit['rms'] < 0.1:
gratname = fits.getheader(msarc.head0['F1'])[spec.meta['dispname']['card']].replace("/", "_")
dispangl = "UNKNOWN"
templates.pypeit_identify_record(final_fit, binspec, specname, gratname, dispangl, outdir=mdir)
print("Your wavelength solution has been stored")
print("Please consider sending your solution to the PypeIt team!")
def load_kast_blue_masters(aimg=False,
tslits=False,
tilts=False,
datasec=False,
wvcalib=False):
"""
Load up the set of shane_kast_blue master frames
Args:
get_spectrograph:
aimg:
tslits:
tilts:
datasec:
wvcalib:
Returns:
"""
spectrograph = load_spectrograph('shane_kast_blue')
spectrograph.naxis = (2112, 350) # Image shape with overscan
master_dir = os.path.join(os.getenv('PYPEIT_DEV'), 'Cooked',
'Shane_Kast_blue')
# master_dir = root_path+'_'+spectrograph.spectrograph
reuse_masters = True
# Load up the Masters
ret = []
# if get_spectrograph:
# ret.append(spectrograph)
master_key = 'A_1_01'
if aimg:
AImg = arcimage.ArcImage(spectrograph,
master_key=master_key,
master_dir=master_dir,
reuse_masters=reuse_masters)
msarc = AImg.load()
ret.append(msarc)
if tslits:
trace_file = os.path.join(
master_dir, MasterFrame.construct_file_name('Trace', master_key))
tslits_dict, mstrace = traceslits.TraceSlits.load_from_file(trace_file)
ret.append(tslits_dict)
ret.append(mstrace)
if tilts:
tilts_file = os.path.join(
master_dir, MasterFrame.construct_file_name('Tilts', master_key))
tilts_dict = wavetilts.WaveTilts.load_from_file(tilts_file)
ret.append(tilts_dict)
if datasec:
datasec_img = spectrograph.get_datasec_img(data_path('b1.fits.gz'), 1)
ret.append(datasec_img)
if wvcalib:
calib_file = os.path.join(
master_dir,
MasterFrame.construct_file_name('WaveCalib',
master_key,
file_format='json'))
wv_calib = waveio.load_wavelength_calibration(calib_file)
ret.append(wv_calib)
# Return
return ret