def idNewYoung(alignRoot): s = starset.StarSet(alignRoot) young_new_dat = '/u/ghezgroup/data/gc/source_list/young_new.dat' yng = youngStarNames(datfile=young_new_dat) ourName = s.getArray('name') x = s.getArray('x') y = s.getArray('y') mag = s.getArray('mag') # Load up Paumard paum = tabs.Paumard2006() for i in range(len(paum.name)): dx = x - paum.x[i] dy = y - paum.y[i] dm = mag - paum.mag[i] dr = sqrt(dx**2 + dy**2) idx = (where((dr < 0.5) & (abs(dm) < 0.5)))[0] if (len(idx) > 0): print('Possible matches for:') print(' %-14s %4.1f %7.3f %7.3f (%s)' % \ (paum.name[i], paum.mag[i], paum.x[i], paum.y[i], paum.ourName[i])) for k in idx: print(' %-14s %4.1f %7.3f %7.3f %5.2f %5.2f %3.1f' % \ (ourName[k], mag[k], x[k], y[k], dx[k], dy[k], dm[k])) else: print('No match for: %s' % (paum.name[i]))
def process_align_output(suffix='_t'): """ Deal with the trim_align output that has all 3 users' starlists and all 3 frames and all 4 chips (separate align for each chip). Make them into a FITS catalog. """ for ii in range(1, 4+1): s = starset.StarSet('align_{0}{1}'.format(ii, suffix)) print 'Loaded starset ', ii n_users = 3 n_frames = 3 n_stars = len(s.stars) x = np.zeros((n_users, n_frames, n_stars), dtype=float) y = np.zeros((n_users, n_frames, n_stars), dtype=float) m = np.zeros((n_users, n_frames, n_stars), dtype=float) for uu in range(n_users): for ff in range(n_frames): icol = ff*n_frames + uu x[uu, ff, :] = s.getArrayFromEpoch(icol, 'xpix') y[uu, ff, :] = s.getArrayFromEpoch(icol, 'ypix') m[uu, ff, :] = s.getArrayFromEpoch(icol, 'mag') cat = np.array((x, y, m)) pyfits.writeto('catalog_quad_{0}{1}.fits'.format(ii, suffix), cat, output_verify='silentfix', clobber=True)
def loadYoungStars(root, align='align/align_d_rms_1000_abs_t', fit='polyfit_c/fit', points='points_c/', radiusCut=0.8, relErr=1, verbose=False, withRVonly=False, silent=False, mosaic=False): if not os.path.exists(root + align + '.trans'): align = 'align/align_d_rms_100_abs_t' #align = 'align/align_d_rms1000_t' # Load up the absolute position of Sgr A* based on S0-2's orbit t = objects.Transform() t.loadAbsolute() # Load up position/velocity information s = starset.StarSet(root + align, relErr=relErr, trans=t) s.loadPolyfit(root + fit, arcsec=1, silent=silent) if mosaic == False: s.loadPolyfit(root + fit, arcsec=1, accel=1, silent=silent) yng = youngStarNames() # Tables in database w/ RV information ucla = tabs.UCLAstars() bart = tabs.Bartko2009() paum = tabs.Paumard2006() cc = objects.Constants() # Pull out from the set of stars those that are young # stars. stars = [] names = [star.name for star in s.stars] for name in yng: # Find the star in our star lists try: idx = names.index(name) star = s.stars[idx] if (star.r2d >= radiusCut): stars.append(star) # Number of Epochs Detected should be corrected # for epochs trimmed out of the *.points files. pntsFile = '%s%s%s.points' % (root, points, star.name) _pnts = asciidata.open(pntsFile) star.velCnt = _pnts.nrows pntDate = _pnts[0].tonumpy() pntX = _pnts[1].tonumpy() pntY = _pnts[2].tonumpy() pntXe = _pnts[3].tonumpy() pntYe = _pnts[4].tonumpy() # Load up data from the points files. for ee in range(len(star.years)): tt = (where(abs(pntDate - star.years[ee]) < 0.001))[0] if (len(tt) == 0): star.e[ee].x_pnt = -1000.0 star.e[ee].y_pnt = -1000.0 star.e[ee].xe_pnt = -1000.0 star.e[ee].ye_pnt = -1000.0 else: tt = tt[0] star.e[ee].x_pnt = pntX[tt] star.e[ee].y_pnt = pntY[tt] star.e[ee].xe_pnt = pntXe[tt] star.e[ee].ye_pnt = pntYe[tt] if mosaic == True: # We only have 3 epochs (as of 2011) star.fitXv.v *= cc.asy_to_kms star.fitYv.v *= cc.asy_to_kms star.fitXv.verr *= cc.asy_to_kms star.fitYv.verr *= cc.asy_to_kms star.vx = star.fitXv.v star.vy = star.fitYv.v star.vxerr = star.fitXv.verr star.vyerr = star.fitYv.verr else: star.fitXa.v *= cc.asy_to_kms star.fitYa.v *= cc.asy_to_kms star.fitXa.verr *= cc.asy_to_kms star.fitYa.verr *= cc.asy_to_kms star.vx = star.fitXa.v star.vy = star.fitYa.v star.vxerr = star.fitXa.verr star.vyerr = star.fitYa.verr star.rv_ref = 'None' def other_RV_tables(): # If not found in UCLA tables, then check Bartko+2009 idx = np.where(bart.ourName == name)[0] if len(idx) > 0: star.vz = bart.vz[idx][0] star.vzerr = bart.vzerr[idx][0] star.vzt0 = bart.t0_spectra[idx][0] star.rv_ref = 'Bartko+2009' else: # Next check Paumard+2006 idx = np.where(paum.ourName == name)[0] if len(idx) > 0: star.vz = paum.vz[idx][0] star.vzerr = paum.vzerr[idx][0] star.vzt0 = paum.t0_spectra[idx][0] star.altName = paum.name[idx][0] star.rv_ref = 'Paumard+2006' #else: # print 'Could not find radial velocity for %s' % name # Find the radial velocity for each star # First look in OSIRIS data, then Bartko, then Paumard idx = np.where(ucla.ourName == name)[0] if len(idx) > 0: star.vz = ucla.vz[idx][0] star.vzerr = ucla.vzerr[idx][0] star.vzt0 = ucla.t0_spectra[idx][0] star.rv_ref = 'UCLA' # A star could be in the stars table but still not have vz if star.vz == None: # then check other tables star.rv_ref = None other_RV_tables() else: other_RV_tables() if withRVonly == True: if star.rv_ref == None: # remove this star stars.remove(star) if (verbose == True): print('Matched %15s to %12s' % (name, star.rv_ref)) star.jz = (star.x * star.vy) - (star.y * star.vx) star.jz /= (star.r2d * hypot(star.vx, star.vy)) except ValueError as e: # Couldn't find the star in our lists continue # Set the starset's star list s.stars = stars print('Found %d young stars' % len(stars)) return s
def save_starset_to_pickle(align_root, n_lists=12, n_good=9): s = starset.StarSet(align_root) x_all = s.getArrayFromAllEpochs('xpix') y_all = s.getArrayFromAllEpochs('ypix') m_all = s.getArrayFromAllEpochs('mag') xe_all = s.getArrayFromAllEpochs('xpixerr_a') ye_all = s.getArrayFromAllEpochs('ypixerr_a') x_old_tmp = x_all[0:n_lists, :] y_old_tmp = y_all[0:n_lists, :] m_old_tmp = m_all[0:n_lists, :] x_new_tmp = x_all[n_lists:, :] y_new_tmp = y_all[n_lists:, :] m_new_tmp = m_all[n_lists:, :] xe_old_tmp = xe_all[0:n_lists, :] ye_old_tmp = ye_all[0:n_lists, :] xe_new_tmp = xe_all[n_lists:, :] ye_new_tmp = ye_all[n_lists:, :] x_old = np.ma.masked_where((x_old_tmp < -900), x_old_tmp) y_old = np.ma.masked_where((x_old_tmp < -900), y_old_tmp) m_old = np.ma.masked_where((x_old_tmp < -900), m_old_tmp) x_new = np.ma.masked_where((x_new_tmp < -900), x_new_tmp) y_new = np.ma.masked_where((x_new_tmp < -900), y_new_tmp) m_new = np.ma.masked_where((x_new_tmp < -900), m_new_tmp) xe_old = np.ma.masked_where((x_old_tmp < -900), xe_old_tmp) ye_old = np.ma.masked_where((x_old_tmp < -900), ye_old_tmp) xe_new = np.ma.masked_where((x_new_tmp < -900), xe_new_tmp) ye_new = np.ma.masked_where((x_new_tmp < -900), ye_new_tmp) cnt_old = n_lists - x_old.mask.sum(axis=0) cnt_new = n_lists - x_new.mask.sum(axis=0) idx = np.where((cnt_old >= n_good) & (cnt_new >= n_good))[0] cnt_old = cnt_old[idx] cnt_new = cnt_new[idx] x_old = x_old[:, idx] y_old = y_old[:, idx] m_old = m_old[:, idx] x_new = x_new[:, idx] y_new = y_new[:, idx] m_new = m_new[:, idx] xe_old = xe_old[:, idx] ye_old = ye_old[:, idx] xe_new = xe_new[:, idx] ye_new = ye_new[:, idx] xm_old = x_old.mean(axis=0) ym_old = y_old.mean(axis=0) mm_old = m_old.mean(axis=0) xm_new = x_new.mean(axis=0) ym_new = y_new.mean(axis=0) mm_new = m_new.mean(axis=0) xs_old = x_old.std(axis=0) ys_old = y_old.std(axis=0) ms_old = m_old.std(axis=0) xs_new = x_new.std(axis=0) ys_new = y_new.std(axis=0) ms_new = m_new.std(axis=0) _out = open(align_root + '.pickle', 'w') pickle.dump(x_old, _out) pickle.dump(y_old, _out) pickle.dump(m_old, _out) pickle.dump(x_new, _out) pickle.dump(y_new, _out) pickle.dump(m_new, _out) pickle.dump(xe_old, _out) pickle.dump(ye_old, _out) pickle.dump(xe_new, _out) pickle.dump(ye_new, _out) pickle.dump(xm_old, _out) pickle.dump(ym_old, _out) pickle.dump(mm_old, _out) pickle.dump(xm_new, _out) pickle.dump(ym_new, _out) pickle.dump(mm_new, _out) pickle.dump(xs_old, _out) pickle.dump(ys_old, _out) pickle.dump(ms_old, _out) pickle.dump(xs_new, _out) pickle.dump(ys_new, _out) pickle.dump(ms_new, _out) pickle.dump(cnt_old, _out) pickle.dump(cnt_new, _out) _out.close() return
def run(args=None): """ align_rms main routine. """ options = parse_options(args) # Read in the align output. Determine the number of # individual starlists are in the stack. s = starset.StarSet(options.root_name) N_lists = len(s.years) if options.idx_min == None: options.idx_min = N_lists if options.idx_max == None: options.idx_max = N_lists # Trim down the starlist to just those that are # in the desired number of epochs and are detected # in the reference epoch. s.stars = trim_stars(s, options) # Fetch the data off the starset name = s.getArray('name') x = s.getArrayFromAllEpochs('xpix') y = s.getArrayFromAllEpochs('ypix') m = s.getArrayFromAllEpochs('mag') f = 10**(m / -2.5) flux_dn = s.getArrayFromAllEpochs('fwhm') corr = s.getArrayFromAllEpochs('corr') nimg = s.getArrayFromAllEpochs('nframes') snr = s.getArrayFromAllEpochs('snr') # Identify where we have measurements and where are non-detections. good = ((x > -1000) & (y > -1000) & (m != 0)) # Calculate the number of epochs the stars are detected in. cnt = good[options.idx_min:options.idx_max, :].sum(axis=0) # Mask the bad data. x_msk = np.ma.masked_where(good == False, x, copy=True) y_msk = np.ma.masked_where(good == False, y, copy=True) f_msk = np.ma.masked_where(good == False, f, copy=True) m_msk = np.ma.masked_where(good == False, m, copy=True) flux_dn = np.ma.masked_where(good == False, flux_dn, copy=True) corr_msk = np.ma.masked_where(good == False, corr, copy=True) nimg_msk = np.ma.masked_where(good == False, nimg, copy=True) snr_msk = np.ma.masked_where(good == False, snr, copy=True) # Calculate the average x, y, m, f if options.idx_ref != None: print 'Using epoch {0} as average pos/flux'.format(options.idx_ref) x_avg = x[options.idx_ref, :] y_avg = y[options.idx_ref, :] m_avg = m[options.idx_ref, :] f_avg = f[options.idx_ref, :] year = s.dates[options.idx_ref] corr_avg = corr[options.idx_ref, :] flux_dn_avg = flux_dn[options.idx_ref, :] nimg_avg = nimg[options.idx_ref, :] snr_orig = snr[options.idx_ref, :] else: print 'Calculate average pos/flux ' print 'from epochs {0} - {1}'.format(options.idx_min, options.idx_max) x_avg = x_msk[options.idx_min:options.idx_max, :].mean(axis=0) y_avg = y_msk[options.idx_min:options.idx_max, :].mean(axis=0) f_avg = f_msk[options.idx_min:options.idx_max, :].mean(axis=0) m_avg = -2.5 * np.log10(f_avg) year = s.years[options.idx_min:options.idx_max].mean() corr_avg = corr_msk[options.idx_min:options.idx_max, :].mean(axis=0) flux_dn_avg = flux_dn[options.idx_min:options.idx_max, :].mean(axis=0) nimg_avg = cnt snr_orig = None # Calculate the error on x, y, m, f x_std = calc_error(x_msk, x_avg, cnt, options) y_std = calc_error(y_msk, y_avg, cnt, options) f_std = calc_error(f_msk, f_avg, cnt, options) m_std = f_std / f_avg # Estimate a new signal to noise ratio new_snr = f_avg / f_std if (options.calc_rel_err == False) and (snr_orig != None): new_snr = 1.0 / np.hypot(1.0 / new_snr, 1.0 / snr_orig) # Fix up any infinities in the SNR. Set them to 0. new_snr[np.isinf(new_snr)] = 0.0 new_snr[new_snr.mask] = 0.0 _out = open(options.out_root + '.lis', 'w') hdr = '{name:13s} {mag:>6s} {year:>8s} ' hdr += '{x:>9s} {y:>9s} {xe:>9s} {ye:>9s} ' hdr += '{snr:>20s} {corr:>6s} {nimg:>8s} {flux:>20s}\n' _out.write( hdr.format(name='# name', mag='mag', year='year', x='x', y='y', xe='xe', ye='ye', snr='snr', corr='corr', nimg='nimg', flux='flux')) fmt = '{name:13s} {mag:6.3f} {year:8.3f} ' fmt += '{x:9.3f} {y:9.3f} {xe:9.3f} {ye:9.3f} ' fmt += '{snr:20.4f} {corr:6.2f} {nimg:8f} {flux:20.0f}\n' for ss in range(len(x_avg)): _out.write( fmt.format(name=name[ss], mag=m_avg[ss], year=float(year), x=x_avg[ss], y=y_avg[ss], xe=x_std[ss], ye=y_std[ss], snr=new_snr[ss], corr=corr_avg[ss], nimg=nimg_avg[ss], flux=flux_dn_avg[ss])) _out.close() return s
def plot_gsaoi_compare_nights(): alignDir = '/u/jlu/data/gsaoi/commission/reduce/ngc1851/' alignDir += 'align_G2_2_nodith/' alignRootAll = [alignDir + 'align_2_t', alignDir + 'align_4_t'] py.close(1) py.figure(1, figsize=(12, 6)) py.subplots_adjust(left=0.1) py.axis('equal') for ii in range(len(alignRootAll)): alignRoot = alignRootAll[ii] s = starset.StarSet(alignRoot) x = s.getArrayFromAllEpochs('x') y = s.getArrayFromAllEpochs('y') m = s.getArrayFromAllEpochs('mag') x = x[1:, :] y = y[1:, :] m = m[1:, :] name = s.getArray('name') ndet = s.getArray('velCnt') # Set up masks to get rid of invalid values xm = np.ma.masked_where(x <= -1e5, x) ym = np.ma.masked_where(x <= -1e5, y) mm = np.ma.masked_where(x <= -1e5, m) # Read in the align.list file and figure out the dates. starlistsTab = atpy.Table(alignRoot + '.list', type='ascii', delimiter=' ', data_start=1) starlists = starlistsTab.col1 xavg = xm.mean(axis=0) xstd = xm.std(axis=0) * 1e3 xerr = xstd / math.sqrt(xm.shape[0]) yavg = ym.mean(axis=0) ystd = ym.std(axis=0) * 1e3 yerr = ystd / math.sqrt(ym.shape[0]) dates = np.array([ss[1:9] for ss in starlists]) uniqueDates = np.unique(dates) idx_n1 = np.where(dates == uniqueDates[0])[0] idx_n2 = np.where(dates == uniqueDates[1])[0] x_n1 = xm[idx_n1, :] y_n1 = ym[idx_n1, :] m_n1 = mm[idx_n1, :] x_n2 = xm[idx_n2, :] y_n2 = ym[idx_n2, :] m_n2 = mm[idx_n2, :] xavg_n1 = x_n1.mean(axis=0) yavg_n1 = y_n1.mean(axis=0) mavg_n1 = m_n1.mean(axis=0) xavg_n2 = x_n2.mean(axis=0) yavg_n2 = y_n2.mean(axis=0) mavg_n2 = m_n2.mean(axis=0) xstd_n1 = x_n1.std(axis=0) * 1e3 ystd_n1 = y_n1.std(axis=0) * 1e3 mstd_n1 = m_n1.std(axis=0) * 1e3 xstd_n2 = x_n2.std(axis=0) * 1e3 ystd_n2 = y_n2.std(axis=0) * 1e3 mstd_n2 = m_n2.std(axis=0) * 1e3 # Correct error to report (assuming random errors) is the error on the mean. xerr_n1 = xstd_n1 / math.sqrt(x_n1.shape[0]) yerr_n1 = ystd_n1 / math.sqrt(x_n1.shape[0]) merr_n1 = mstd_n1 / math.sqrt(x_n1.shape[0]) xerr_n2 = xstd_n2 / math.sqrt(x_n2.shape[0]) yerr_n2 = ystd_n2 / math.sqrt(x_n2.shape[0]) merr_n2 = mstd_n2 / math.sqrt(x_n2.shape[0]) dx = (xavg_n2 - xavg_n1) * 1.0e3 dy = (yavg_n2 - yavg_n1) * 1.0e3 py.subplot(1, 2, ii + 1) py.errorbar(dx, dy, xerr=xerr_n1, yerr=yerr_n1, fmt='k.') py.plot([0], [0], 'rs', ms=8) py.xlabel('X Difference (mas)') py.ylabel('Y Difference (mas)') py.title('GSAOI Night 2 - Night 1') lim = 6 py.axis([-lim, lim, -lim, lim]) outFile = '/u/jlu/doc/papers/proceed_2014_spie/gems_ngc1851_comp_nights.png' py.savefig(outFile)