def main(args): """ Parameters ---------- args Returns ------- """ import numpy as np from pypit import pyputils msgs = pyputils.get_dummy_logger() from pypit import arqa from linetools.utils import loadjson # Read JSON fdict = loadjson(args.wave_soln) for key in fdict.keys(): if isinstance(fdict[key], list): fdict[key] = np.array(fdict[key]) # Generate QA arqa.arc_fit_qa(None, fdict, outfil=args.outfile, ids_only=True, title=args.title) print("Wrote {:s}".format(args.outfile))
def main() : parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('file', type = str, default = None, help = 'FITS file') parser.add_argument("--list", default=False, help="List the extensions only?", action="store_true") parser.add_argument('--raw_lris', action="store_true") parser.add_argument('--exten', type=int, help="FITS extension") pargs = parser.parse_args() # List? if pargs.list: from astropy.io import fits hdu = fits.open(pargs.file) print(hdu.info()) return kludge_fil = 'tmp_ginga.fits' # Setup for PYPIT imports import subprocess from astropy.io import fits from pypit import pyputils msgs = pyputils.get_dummy_logger() from pypit import arlris # Extension if pargs.exten is not None: hdu = fits.open(pargs.file) img = hdu[pargs.exten].data # Write msgs.warn('Writing kludge file to {:s}'.format(kludge_fil)) hdunew = fits.PrimaryHDU(img) hdulist = fits.HDUList([hdunew]) hdulist.writeto(kludge_fil,clobber=True) # pargs.file = kludge_fil # RAW_LRIS?? if pargs.raw_lris: # img, head, _ = arlris.read_lris(pargs.file) # Generate hdu hdu = fits.PrimaryHDU(img) hdulist = fits.HDUList([hdu]) # Write msgs.warn('Writing kludge file to {:s}'.format(kludge_fil)) hdulist.writeto(kludge_fil,clobber=True) pargs.file = kludge_fil # Spawn ginga subprocess.call(["ginga", pargs.file]) if pargs.raw_lris: msgs.warn('Removing kludge file {:s}'.format(kludge_fil)) subprocess.call(["rm", pargs.file])
def tst_unknwn_wvcen(spec, lines, wv_cen, disp, siglev=20., min_ampl=300., swv_uncertainty=350., pix_tol=2, plot_fil=None, wvoff=1000.): """ As named """ dcen = swv_uncertainty * 0.8 wvcens = np.arange(wv_cen - wvoff, wv_cen + wvoff + dcen, dcen) # Best best_dict = dict(nmatch=0, nID=0, rms=0., ibest=-1, bwv=0.) # Loop for ss, iwv_cen in enumerate(wvcens): print('wv_cen guess = {:g}'.format(iwv_cen)) stuff = grail.basic(spec, lines, iwv_cen, disp, siglev=siglev, min_ampl=min_ampl, swv_uncertainty=swv_uncertainty, pix_tol=pix_tol, plot_fil=None) if stuff[0] == -1: print("Solution failed for iwv_cen={:g}. Nmatch={:d}".format( iwv_cen, stuff[1])) elif stuff[0] == 1: # Unpack status, nmatch, match_idx, scores, final_fit = stuff print("Fit finished for iwv_cen={:g}".format(iwv_cen)) # Metrics -- nmatch, nID, RMS nID = len(final_fit['xfit']) print(" Nmatch={:d}, nID={:d}, RMS={:g}".format( nmatch, nID, final_fit['rms'])) # Best? if nID > best_dict['nID']: best_dict['nmatch'] = nmatch best_dict['nID'] = nID best_dict['rms'] = final_fit['rms'] best_dict['ibest'] = ss best_dict['bwv'] = iwv_cen best_dict['fit'] = final_fit # Report print("Here is the best:") print(best_dict) # QA if plot_fil is not None: from pypit import pyputils msgs = pyputils.get_dummy_logger() from pypit import arqa arqa.arc_fit_qa(None, best_dict['fit'], outfil=plot_fil)
def main(args): # List only? from astropy.io import fits if args.list: hdu = fits.open(args.file) print(hdu.info()) return kludge_fil = 'tmp_ginga.fits' # Setup for PYPIT imports import subprocess from pypit import pyputils msgs = pyputils.get_dummy_logger() from pypit import arlris # Extension if args.exten is not None: hdu = fits.open(args.file) img = hdu[args.exten].data # Write msgs.warn('Writing kludge file to {:s}'.format(kludge_fil)) hdunew = fits.PrimaryHDU(img) hdulist = fits.HDUList([hdunew]) hdulist.writeto(kludge_fil,clobber=True) # args.file = kludge_fil # RAW_LRIS?? if args.raw_lris: # img, head, _ = arlris.read_lris(args.file) # Generate hdu hdu = fits.PrimaryHDU(img) hdulist = fits.HDUList([hdu]) # Write msgs.warn('Writing kludge file to {:s}'.format(kludge_fil)) hdulist.writeto(kludge_fil,clobber=True) args.file = kludge_fil # Spawn ginga subprocess.call(["ginga", args.file]) if args.raw_lris: msgs.warn('Removing kludge file {:s}'.format(kludge_fil)) subprocess.call(["rm", args.file])
# Module to run tests on simple fitting routines for arrays ### TEST_UNICODE_LITERALS import numpy as np import sys import os, pdb import pytest from astropy import units as u from pypit import pyputils import pypit msgs = pyputils.get_dummy_logger() # from xastropy.xutils import afits as xafits # from xastropy.xutils import xdebug as xdb # def data_path(filename): # data_dir = os.path.join(os.path.dirname(__file__), 'files') # return os.path.join(data_dir, filename) def test_find_standard(): from pypit import arutils as arut from pypit import arflux as arflx # Dummy self slf = arut.dummy_self() # G191b2b
def main(args): from pypit.scripts import run_pypit from pypit import pyputils from pypit.pypit import load_input import os import datetime ''' # Check for existing .setups file setup_files = glob.glob('./{:s}*.setups'.format(args.spectrograph)) if len(setup_files) > 0: print("Working directory already includes a .setups file") for ifile in setup_files: print("Remove: {:s}".format(ifile)) print("Then you can re-run this script") sys.exit() ''' # Generate a dummy .pypit file if not args.pypit_file: # Name date = str(datetime.date.today().strftime('%Y-%b-%d')) root = args.spectrograph+'_'+date pyp_file = args.redux_path+root+'.pypit' # Generate dfname = "{:s}*{:s}*".format(args.files_root, args.extension) # parlines parlines = ['run ncpus 1\n', 'output overwrite True\n'] parlines += ["run spectrograph {:s}\n".format(args.spectrograph)] parlines += ["output sorted {:s}\n".format(root)] pyputils.make_pypit_file(pyp_file, args.spectrograph, [dfname], setup_script=True, parlines=parlines) print("Wrote {:s}".format(pyp_file)) else: pyp_file = args.files_root # Run pinp = [pyp_file] if args.develop: pinp += ['-d'] pargs = run_pypit.parser(pinp) sorted_file = pyp_file.replace('.pypit', '.sorted') run_pypit.main(pargs) # ##################### # Generate custom .pypit files if not args.custom: return # Read master file from pypit import pyputils from pypit import arsort msgs = pyputils.get_dummy_logger() pyp_dict = load_input(pyp_file, msgs) parlines, datlines, spclines, dfnames = [pyp_dict[ii] for ii in ['par','dat','spc','dfn']] # Get paths paths = [] for datline in datlines: islsh = datline.rfind('/') path = datline[:islsh+1] if path not in paths: paths.append(path) # Remove run setup from parlines for jj,parline in enumerate(parlines): if 'run setup' in parline: #parlines[jj] = 'run setup False\n' parlines[jj] = '\n' # Generate .pypit files and sub-folders all_setups, all_setuplines, all_setupfiles = arsort.load_sorted(sorted_file) for setup, setuplines,setupfiles in zip(all_setups, all_setuplines,all_setupfiles): root = args.spectrograph+'_setup_' # Make the dir newdir = args.redux_path+root+setup if not os.path.exists(newdir): os.mkdir(newdir) # Now the file pyp_file = newdir+'/'+root+setup+'.pypit' # Modify parlines for kk,pline in enumerate(parlines): if 'output sorted' in pline: parlines.pop(kk) parlines += ["output sorted {:s}\n".format(root+setup)] pyputils.make_pypit_file(pyp_file, args.spectrograph, [], parlines=parlines, spclines=None, setuplines=setuplines, setupfiles=setupfiles, paths=paths, calcheck=False) print("Wrote {:s}".format(pyp_file))
# Module to run tests on armasters import pytest from pypit import pyputils msgs = pyputils.get_dummy_logger() #develop=True) from pypit import armasters #def data_path(filename): # data_dir = os.path.join(os.path.dirname(__file__), 'files') # return os.path.join(data_dir, filename) #@pytest.fixture #def fitsdict(): # return arutils.dummy_fitsdict() def test_master_name(): """ Test master name method """ types = [ 'bias', 'badpix', 'trace', 'normpixelflat', 'arc', 'wave', 'wv_calib', 'tilts' ] suff = [ 'Bias', 'BadPix', 'Trace', 'FlatField', 'Arc', 'Wave', 'WaveCalib', 'Tilts' ] for isuff, itype in zip(suff, types): if itype == 'wv_calib': exten = 'json'
def generate_hdf(sav_file, instr, lamps, outfil, dtoler=0.6): """ Given an input LR IDL save file, generate an hdf5 IDs arc lines too Parameters ---------- sav_file : str Root name of the IDL save file from LowRedux, e.g. lris_blue_600.sav lamps outfil Returns ------- """ from pypit import pyputils msgs = pyputils.get_dummy_logger() from pypit import arwave from pypit import arutils arutils.dummy_settings() # from arclines.pypit_utils import find_peaks from arclines.io import load_line_lists # # Read IDL save file sav_file = os.getenv('LONGSLIT_DIR') + 'calib/linelists/' + sav_file s = readsav(sav_file) ctbl = Table(s['calib']) # For writing later # Line list alist = load_line_lists(lamps) # One spectrum? ashape = s['archive_arc'].shape if len(ashape) == 1: nspec = 1 npix = ashape[0] else: nspec = s['archive_arc'].shape[0] npix = ashape[1] # Meta data mdict = dict( npix=npix, instr=instr, lamps=[str(ilamp) for ilamp in lamps], # For writing to hdf5 nspec=nspec, infil=sav_file, IDairvac='vac') print("Processing {:d} spectra in {:s}".format(mdict['nspec'], sav_file)) # Start output outh5 = h5py.File(out_path + outfil, 'w') outh5.create_group('arcs') # Loop on spectra for ss in range(mdict['nspec']): sss = str(ss) # Parse if nspec == 1: spec = s['archive_arc'] else: spec = s['archive_arc'][ss] calib = s['calib'][ss] # Peaks tampl, tcent, twid, w, yprep = find_peaks(spec) pixpk = tcent[w] pixampl = tampl[w] # Wavelength solution if calib['func'] == 'CHEBY': wv_air = cheby_val(calib['ffit'], np.arange(mdict['npix']), calib['nrm'], calib['nord']) elif calib['func'] == 'POLY': wv_air = poly_val(calib['ffit'], np.arange(mdict['npix']), calib['nrm']) # Check blue->red or vice-versa if ss == 0: if wv_air[0] > wv_air[-1]: mdict['bluered'] = False else: mdict['bluered'] = True # Peak waves if calib['func'] == 'CHEBY': twave_air = cheby_val(calib['ffit'], pixpk, calib['nrm'], calib['nord']) else: twave_air = poly_val(calib['ffit'], pixpk, calib['nrm']) # Air to Vac twave_vac = arwave.airtovac(twave_air * u.AA) wave_vac = arwave.airtovac(wv_air * u.AA) if ss == 0: disp = np.median(np.abs(wave_vac - np.roll(wave_vac, 1))) print("Average dispersion = {:g}".format(disp)) # IDs idwv = np.zeros_like(pixpk) idsion = np.array([str('12345')] * len(pixpk)) for kk, twv in enumerate(twave_vac.value): # diff diff = np.abs(twv - alist['wave']) if np.min(diff) < dtoler: imin = np.argmin(diff) idwv[kk] = alist['wave'][imin] #idsion[kk] = alist['Ion'][imin] NIST idsion[kk] = alist['ion'][imin] # Red to blue? if mdict['bluered'] is False: pixpk = mdict['npix'] - 1 - pixpk # Re-sort asrt = np.argsort(pixpk) pixpk = pixpk[asrt] idwv = idwv[asrt] # Reverse spec = spec[::-1] wave_vac = wave_vac[::-1] # Output outh5['arcs'].create_group(sss) # Datasets outh5['arcs'][sss]['wave'] = wave_vac outh5['arcs'][sss]['wave'].attrs['airvac'] = 'vac' outh5['arcs'][sss]['spec'] = spec outh5['arcs'][sss]['spec'].attrs['flux'] = 'counts' outh5['arcs'][sss]['pixpk'] = pixpk outh5['arcs'][sss]['ID'] = idwv outh5['arcs'][sss]['ID'].attrs['airvac'] = 'vac' outh5['arcs'][sss]['Ion'] = idsion # LR wavelengths outh5['arcs'][sss]['LR_wave'] = wv_air outh5['arcs'][sss]['LR_wave'].attrs['airvac'] = 'air' # LR Fit outh5['arcs'][sss].create_group('LR_fit') for key in ctbl.keys(): outh5['arcs'][sss]['LR_fit'][key] = ctbl[ss][key] # Meta data outh5.create_group('meta') for key in mdict.keys(): try: outh5['meta'][key] = mdict[key] except TypeError: # Probably a unicode thing pdb.set_trace() # Close outh5.close() print('Wrote {:s}'.format(out_path + outfil))
# Module to run tests on ararclines import os import numpy as np import pytest from astropy.table import Table from pypit import pyputils msgs = pyputils.get_dummy_logger() from pypit import arutils from pypit import artrace from pypit import arcytrace def data_path(filename): data_dir = os.path.join(os.path.dirname(__file__), 'files') return os.path.join(data_dir, filename) def test_very_close_obj(): """ Find objects with minima algorithm """ # Read trace example tbl = Table.read(data_path('real_close_trace.fits')) trcprof = tbl['trc'].data.astype(np.float64) # Call objl, objr, bckl, bckr = artrace.find_obj_minima(trcprof, fwhm=3., nsmooth=0) assert objl[1] == 55 assert objr[1] == 63
def main(): parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('file', type=str, default=None, help='FITS file') parser.add_argument("--list", default=False, help="List the extensions only?", action="store_true") parser.add_argument('--raw_lris', action="store_true") parser.add_argument('--exten', type=int, help="FITS extension") pargs = parser.parse_args() # List? if pargs.list: from astropy.io import fits hdu = fits.open(pargs.file) print(hdu.info()) return kludge_fil = 'tmp_ginga.fits' # Setup for PYPIT imports import subprocess from astropy.io import fits from pypit import pyputils msgs = pyputils.get_dummy_logger() from pypit import arlris # Extension if pargs.exten is not None: hdu = fits.open(pargs.file) img = hdu[pargs.exten].data # Write msgs.warn('Writing kludge file to {:s}'.format(kludge_fil)) hdunew = fits.PrimaryHDU(img) hdulist = fits.HDUList([hdunew]) hdulist.writeto(kludge_fil, clobber=True) # pargs.file = kludge_fil # RAW_LRIS?? if pargs.raw_lris: # img, head, _ = arlris.read_lris(pargs.file) # Generate hdu hdu = fits.PrimaryHDU(img) hdulist = fits.HDUList([hdu]) # Write msgs.warn('Writing kludge file to {:s}'.format(kludge_fil)) hdulist.writeto(kludge_fil, clobber=True) pargs.file = kludge_fil # Spawn ginga subprocess.call(["ginga", pargs.file]) if pargs.raw_lris: msgs.warn('Removing kludge file {:s}'.format(kludge_fil)) subprocess.call(["rm", pargs.file])
def test_dummy_logger(): msgs = pyputils.get_dummy_logger() msgs.info('testing 123')
def iterative_fitting(spec, tcent, ifit, IDs, llist, disp, plot_fil=None, verbose=False, load_pypit=False, aparm=None): if aparm is None: aparm = dict( llist='', disp=disp, # Ang/unbinned pixel disp_toler=0.1, # 10% tolerance match_toler=3., # Matcing tolerance (pixels) func='legendre', # Function for fitting n_first=3, # Order of polynomial for first fit n_final=4, # Order of polynomial for final fit nsig_rej=2., # Number of sigma for rejection nsig_rej_final=3.0) # Number of sigma for rejection (final fit) # PYPIT if load_pypit: from pypit import pyputils msgs = pyputils.get_dummy_logger() from pypit import arutils from pypit import arqa if load_pypit: arutils.dummy_settings() npix = spec.size # Setup for fitting sv_ifit = list(ifit) # Keep the originals all_ids = -999. * np.ones(len(tcent)) all_idsion = np.array(['UNKNWN'] * len(tcent)) all_ids[ifit] = IDs # Fit n_order = aparm['n_first'] flg_quit = False fmin, fmax = -1., 1. while (n_order <= aparm['n_final']) and (flg_quit is False): # Fit with rejection xfit, yfit = tcent[ifit], all_ids[ifit] mask, fit = arutils.robust_polyfit(xfit, yfit, n_order, function=aparm['func'], sigma=aparm['nsig_rej'], minv=fmin, maxv=fmax) rms_ang = arutils.calc_fit_rms(xfit[mask == 0], yfit[mask == 0], fit, aparm['func'], minv=fmin, maxv=fmax) rms_pix = rms_ang / disp if verbose: print("RMS = {:g}".format(rms_pix)) # DEBUG # Reject but keep originals (until final fit) ifit = list(ifit[mask == 0]) + sv_ifit # Find new points (should we allow removal of the originals?) twave = arutils.func_val(fit, tcent, aparm['func'], minv=fmin, maxv=fmax) for ss, iwave in enumerate(twave): mn = np.min(np.abs(iwave - llist['wave'])) if mn / aparm['disp'] < aparm['match_toler']: imn = np.argmin(np.abs(iwave - llist['wave'])) #if verbose: # print('Adding {:g} at {:g}'.format(llist['wave'][imn],tcent[ss])) # Update and append all_ids[ss] = llist['wave'][imn] all_idsion[ss] = llist['ion'][imn] ifit.append(ss) # Keep unique ones ifit = np.unique(np.array(ifit, dtype=int)) # Increment order if n_order < (aparm['n_final'] + 2): n_order += 1 else: # This does 2 iterations at the final order flg_quit = True # Final fit (originals can now be rejected) fmin, fmax = 0., 1. xfit, yfit = tcent[ifit] / (npix - 1), all_ids[ifit] mask, fit = arutils.robust_polyfit(xfit, yfit, n_order, function=aparm['func'], sigma=aparm['nsig_rej_final'], minv=fmin, maxv=fmax) #, debug=True) irej = np.where(mask == 1)[0] if len(irej) > 0: xrej = xfit[irej] yrej = yfit[irej] if verbose: for kk, imask in enumerate(irej): wave = arutils.func_val(fit, xrej[kk], aparm['func'], minv=fmin, maxv=fmax) print('Rejecting arc line {:g}; {:g}'.format( yfit[imask], wave)) else: xrej = [] yrej = [] xfit = xfit[mask == 0] yfit = yfit[mask == 0] ions = all_idsion[ifit][mask == 0] # Final RMS rms_ang = arutils.calc_fit_rms(xfit, yfit, fit, aparm['func'], minv=fmin, maxv=fmax) rms_pix = rms_ang / disp # ''' if msgs._debug['arc']: msarc = slf._msarc[det-1] wave = arutils.func_val(fit, np.arange(msarc.shape[0])/float(msarc.shape[0]), 'legendre', minv=fmin, maxv=fmax) debugger.xplot(xfit,yfit, scatter=True, xtwo=np.arange(msarc.shape[0])/float(msarc.shape[0]), ytwo=wave) debugger.xpcol(xfit*msarc.shape[0], yfit) debugger.set_trace() ''' #debugger.xplot(xfit, np.ones(len(xfit)), scatter=True, # xtwo=np.arange(msarc.shape[0]),ytwo=yprep) #debugger.xplot(xfit,yfit, scatter=True, xtwo=np.arange(msarc.shape[0]), # ytwo=wave) #debugger.set_trace() #wave = arutils.func_val(fit, np.arange(msarc.shape[0])/float(msarc.shape[0]), # 'legendre', min=fmin, max=fmax) # Pack up fit final_fit = dict(fitc=fit, function=aparm['func'], xfit=xfit, yfit=yfit, ions=ions, fmin=fmin, fmax=fmax, xnorm=float(npix), xrej=xrej, yrej=yrej, mask=mask, spec=spec, nrej=aparm['nsig_rej_final'], shift=0., tcent=tcent, rms=rms_pix) # QA if plot_fil is not None: arqa.arc_fit_qa(None, final_fit, outfil=plot_fil) # Return return final_fit
def main(args): # List only? import os from astropy.io import fits hdu = fits.open(args.file) head0 = hdu[0].header if args.list: print(hdu.info()) return # Setup for PYPIT imports from pypit import pyputils from pypit import armasters from pypit.arparse import get_dnum from pypit.arspecobj import get_slitid from astropy.table import Table msgs = pyputils.get_dummy_logger() from pypit import ginga as pyp_ginga import pdb as debugger # Init sdet = get_dnum(args.det, prefix=False) # One detector, sky sub for now names = [hdu[i].name for i in range(len(hdu))] try: exten = names.index('DET{:s}-SKYSUB'.format(sdet)) except ValueError: # Backwards compatability exten = names.index('DET{:d}-SKYSUB'.format(args.det)) skysub = hdu[exten].data # Show Image cwd = os.getcwd() wcs_img = cwd + '/' + head0[ 'PYPMFDIR'] + '/MasterWave_' + '{:s}_{:02d}_{:s}.fits'.format( head0['PYPCNFIG'], args.det, head0['PYPCALIB']) viewer, ch = pyp_ginga.show_image(skysub, chname='DET{:s}'.format(sdet), wcs_img=wcs_img) # Add slits testing = False if testing: mdir = 'MF_keck_lris_blue/' setup = 'A_{:s}_aa'.format(sdet) else: mdir = head0['PYPMFDIR'] + '/' setup = '{:s}_{:s}_{:s}'.format(head0['PYPCNFIG'], sdet, head0['PYPCALIB']) trc_file = armasters.master_name('trace', setup, mdir=mdir) trc_hdu = fits.open(trc_file) lordloc = trc_hdu[1].data # Should check name rordloc = trc_hdu[2].data # Should check name # Get slit ids stup = (trc_hdu[0].data.shape, lordloc, rordloc) slit_ids = [ get_slitid(stup, None, ii)[0] for ii in range(lordloc.shape[1]) ] pyp_ginga.show_slits(viewer, ch, lordloc, rordloc, slit_ids) #, args.det) # Object traces spec1d_file = args.file.replace('spec2d', 'spec1d') hdulist_1d = fits.open(spec1d_file) det_nm = 'D{:s}'.format(sdet) for hdu in hdulist_1d: if det_nm in hdu.name: tbl = Table(hdu.data) trace = tbl['obj_trace'] obj_id = hdu.name.split('-')[0] pyp_ginga.show_trace(viewer, ch, trace, obj_id, color='green') #hdu.name)