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