diff --git a/jlu/observe/data_download.py b/jlu/observe/data_download.py index 0bfe2aa..56cbfc8 100644 --- a/jlu/observe/data_download.py +++ b/jlu/observe/data_download.py @@ -25,7 +25,7 @@ def download_for_mulab(instrument, date, cookie_file): inst_upp = instrument.upper() date_hyphens = date - date_nohyphs = date.replace("_", "") + date_nohyphs = date.replace("-", "") data_dir = f'/g/lu/data/KECK/{date_nohyphs}_{inst_upp}/' data_table = data_dir + 'data.tbl' diff --git a/jlu/observe/skycalc.py b/jlu/observe/skycalc.py index 9e0e81f..af13ef8 100644 --- a/jlu/observe/skycalc.py +++ b/jlu/observe/skycalc.py @@ -117,7 +117,7 @@ def plot_airmass(ra, dec, year, months, days, observatory, outfile='plot_airmass if proposal_cycle == 'A': text_offset = 1.1 else: - text_offset = 1.3 + text_offset = 1.1 py.text(-3.5, text_offset + (ii*0.1), labels[ii], color=colors[ii], fontsize=20) diff --git a/jlu/papers/huston_2025_lens.py b/jlu/papers/huston_2025_lens.py new file mode 100755 index 0000000..6f5c992 --- /dev/null +++ b/jlu/papers/huston_2025_lens.py @@ -0,0 +1,8441 @@ +import numpy as np +import pylab as plt +from astropy.table import Table, Column, vstack +from astropy.io import fits +from dynesty import plotting as dyplot +from flystar import starlists +from scipy.interpolate import UnivariateSpline +import scipy.stats +from scipy.optimize import curve_fit, least_squares +from popsycle import ebf +import matplotlib.ticker +import matplotlib.colors +from matplotlib.pylab import cm +from matplotlib.colors import Normalize, LogNorm +from mpl_toolkits.axes_grid1.axes_divider import make_axes_locatable +from matplotlib.ticker import NullFormatter +import os, shutil +from scipy.ndimage import gaussian_filter as norm_kde +from microlens.jlu import multinest_utils, multinest_plot, munge +from bagle import model, model_fitter, parallax +import dynesty.utils as dyutil +from astropy.stats import sigma_clipped_stats +from matplotlib.colors import LinearSegmentedColormap, colorConverter +import pdb +import pickle +import math +import copy +import yaml +from scipy.stats import norm, poisson +import warnings +warnings.simplefilter(action='ignore', category=FutureWarning) +from astropy.coordinates import SkyCoord +from astropy import units as u +from scipy import interpolate +from astropy.time import Time + +mpl_o = '#ff7f0e' +mpl_b = '#1f77b4' +mpl_g = '#2ca02c' +mpl_r = '#d62728' + +ep_ob120169 = ['12jun', '12jul', '13apr', '13jul', '15may05', + '15jun07', '16may24', '16jul14'] + +ep_ob140613 = ['15jun07', '15jun28', '16apr17', '16may24', '16aug02', + '17jun05', '17jul14', '18may11', '18aug16', '19apr17', + '19apr21os'] #, '25aug02os'] + +ep_ob150029 = ['15jun07', '15jul23', '16may24', '16jul14', '17may21', + '17jul14', '17jul19', '18aug21', '19apr17'] + +ep_ob150211 = ['15may05', '15jun07', '15jun28', '15jul23', '16may03', + '16jul14', '16aug02', '17jun05', '17jun08', '17jul19', + '18may11', '18aug02', '18aug16', '19jun28os', '20may25os'] + + +epochs = {'ob120169': ep_ob120169, 'ob140613': ep_ob140613, 'ob150029': ep_ob150029, 'ob150211': ep_ob150211} + +# paper_dir = '/u/jlu/doc/papers/ob150211/' +paper_dir = '/u/mhuston/work/kecktargs_paper/paper_figs/' +# paper_dir = '/u/casey/scratch/code/JLU-python-code/jlu/papers/' +mlens_dir = '/u/jlu/work/microlens/' + +a_date = {'ob120169': '2026_01_07', + 'ob140613': '2026_01_07', + 'ob150029': '2026_01_07', + 'ob150211': '2026_01_07'} + +comp_stars = {'ob120169': ['ob120169_L', 'S24_18_0.8'], + 'ob140613': ['S002_15_0.7', 'S001_15_0.9'], + 'ob150029': ['S002_16_0.3', 'S003_16_0.9'], + 'ob150211': ['S001_13_1.3', 'S003_15_1.4']} + +#astrom_pass = {'ob120169': 'p5', +# 'ob140613': 'p5', +# 'ob150029': 'p4', +# 'ob150211': 'p5'} +# +#astrom_suffix = {'ob120169': '', +# 'ob140613': '_os', +# 'ob150029': '', +# 'ob150211': ''} + +a_dir = {} +for targ in a_date: + a_dir[targ] = mlens_dir + targ.upper() + '/a_' + a_date[targ] + '/' + #astrom_data[targ] = a_dir[targ] + targ + '_plx_final.fits' + +astrom_data = {'ob120169' : a_dir['ob120169'] + 'ob120169_plx_gaia_final.fits', + 'ob140613' : a_dir['ob140613'] + 'ob140613_plx_sp_noos.fits', + 'ob150029' : a_dir['ob150029'] + 'ob150029_plx_gaia_final.fits', + 'ob150211' : a_dir['ob150211'] + 'ob150211_plx_gaia_final.fits' + } +astrom_data['ob110462_23apr'] = None + +ogle_phot_all = {'ob120169_none' : a_dir['ob120169'] + 'model_fits/ogle_only/102_fit_phot_parallax/a1_', + 'ob120169_add' : a_dir['ob120169'] + 'model_fits/ogle_only/103_fit_phot_parallax_aerr/a3_', + 'ob120169_mult' : a_dir['ob120169'] + 'model_fits/ogle_only/101_fit_phot_parallax_merr/a0_', + 'ob120169_addmult' : a_dir['ob120169'] + 'model_fits/ogle_only/104_fit_phot_parallax_aerr_merr/a2_', + 'ob120169_gp' : a_dir['ob120169'] + 'model_fits/ogle_only/201_phot_ogle_gp/b2_', + 'ob140613_none' : a_dir['ob140613'] + 'model_fits/perlmutter/ogle_moa_only/102_phot/a1_', + 'ob140613_add' : a_dir['ob140613'] + 'model_fits/perlmutter/ogle_moa_only/103_phot_aerr/a4_', + 'ob140613_mult' : a_dir['ob140613'] + 'model_fits/perlmutter/ogle_moa_only/101_phot_merr/a4_', + 'ob140613_addmult' : a_dir['ob140613'] + 'model_fits/perlmutter/ogle_moa_only/104_phot_aerr_merr/a1_', + 'ob140613_gp' : a_dir['ob140613'] + 'model_fits/perlmutter/ogle_moa_only/201_phot_gp/b1_', + 'ob150029_none' : a_dir['ob150029'] + 'model_fits/perlmutter/ogle_moa_only/102_phot/a2_', + 'ob150029_add' : a_dir['ob150029'] + 'model_fits/perlmutter/ogle_moa_only/103_phot_aerr/a0_', + 'ob150029_mult' : a_dir['ob150029'] + 'model_fits/perlmutter/ogle_moa_only/101_phot_merr/a4_', + 'ob150029_addmult' : a_dir['ob150029'] + 'model_fits/perlmutter/ogle_moa_only/104_phot_aerr_merr/a3_', + 'ob150029_gp' : a_dir['ob150029'] + 'model_fits/perlmutter/ogle_moa_only/201_phot_gp/b0_', + 'ob150211_none' : a_dir['ob150211'] + 'model_fits/ogle_only/102_fit_phot_parallax/a1_', + 'ob150211_add' : a_dir['ob150211'] + 'model_fits/ogle_only/103_fit_phot_parallax_aerr/a2_', + 'ob150211_mult' : a_dir['ob150211'] + 'model_fits/ogle_only/101_fit_phot_parallax_merr/a4_', + 'ob150211_addmult' : a_dir['ob150211'] + 'model_fits/ogle_only/104_fit_phot_parallax_aerr_merr/a4_', + 'ob150211_gp' : a_dir['ob150211'] + 'model_fits/ogle_only/0201_phot_ogle_gp_old/b2_'} + +photom_spitzer = {'ob120169': None, + 'ob140613': '/g/lu/data/microlens/spitzer/calchi_novati_2015/ob140613_phot_2.txt', + 'ob150029': '/g/lu/data/microlens/spitzer/calchi_novati_2015/ob150029_phot_2.txt', + 'ob150211': '/g/lu/data/microlens/spitzer/calchi_novati_2015/ob150211_phot_3.txt'} + +pspl_phot = {'ob120169' : ogle_phot_all['ob120169_addmult'], + 'ob140613' : ogle_phot_all['ob140613_addmult'], + 'ob150029' : ogle_phot_all['ob150029_addmult'], + 'ob150211' : ogle_phot_all['ob150211_add']} + +pspl_ast_multiphot = {'ob120169' : a_dir['ob120169'] + 'model_fits/ogle_keck/124_phot_astrom_aerr_merr/a4_', + 'ob140613' : a_dir['ob140613'] + 'model_fits/perlmutter/NOOS/ogle_moa_keck/124_phot_astrom_aerr_merr/a2_', + 'ob150029' : a_dir['ob150029'] + 'model_fits/perlmutter/ogle_moa_keck/124noV_phot_astrom_aerr_merr/a1_', + 'ob150211' : a_dir['ob150211'] + 'model_fits/ogle_keck/123_phot_astrom_aerr/a0_', + 'OB110462' : "/u/jlu/work/microlens/OB110462/a_2023_04_23/model_fits/hst_phot_ast/trunc_ogle/all_hst/base_a/a0_"} + +# 0-based... so 0 = first mode (after the global solution). +pspl_ast_multiphot_mode = {'ob120169': 0, + 'ob140613': 0, + 'ob150029': 2, + 'ob150211': 0} + +# WITH GP WAS BAD - RETHINK +pspl_multiphot = {'ob120169' : a_dir['ob120169'] + 'model_fits/0211_phot_ogle_keck_gp_old/b0_', + 'ob140613' : a_dir['ob140613'] + 'model_fits/0211_phot_ogle_keck_gp_old/b0_', + 'ob150029' : a_dir['ob150029'] + 'model_fits/0211_phot_ogle_keck_gp_old/b0_', + 'ob150211' : a_dir['ob150211'] + 'model_fits/0211_phot_ogle_keck_gp_old/b0_'} + +ogle_phot = {} +# ogle_phot['ob120169'] = ogle_phot_all['ob120169_add'] +# ogle_phot['ob140613'] = ogle_phot_all['ob140613_mult'] +# ogle_phot['ob150029'] = ogle_phot_all['ob150029_add'] +# ogle_phot['ob150211'] = ogle_phot_all['ob150211_add'] + +ogle_phot['ob120169'] = ogle_phot_all['ob120169_gp'] +ogle_phot['ob140613'] = ogle_phot_all['ob140613_gp'] +ogle_phot['ob150029'] = ogle_phot_all['ob150029_gp'] +ogle_phot['ob150211'] = ogle_phot_all['ob150211_gp'] + +popsycle_events = '/u/casey/scratch/papers/microlens_2019/popsycle_rr_files/Mock_EWS_v2_NEW_DELTAM.fits' + +#keck_phot_2020 = {'kb200101' : mlens_dir + 'KB200101/a_2020_09_10/model_fits/kmtnet_phot_par/a0_', +# 'mb19284' : mlens_dir + '', +# 'ob190017' : mlens_dir + 'OB190017/a_2020_09_10/model_fits/ogle_phot_par/a0_', +# 'ob170019' : mlens_dir + 'OB170019/a_2020_09_10/model_fits/ogle_phot_par/a0_', +# 'ob170095' : mlens_dir + 'OB170095/a_2021_09_18/model_fits/base_a/a0_'} +#hst_phot = {'MB09260' : mlens_dir + 'MB09260/a_2021_07_08/model_fits/moa_hst_phot_ast_gp/base_a/a0_', +# 'MB10364' : mlens_dir +'MB10364/a_2021_07_08/model_fits/moa_hst_phot_ast_gp/base_a/a0_', +# 'OB110037' : mlens_dir +'OB110037/a_2021_07_08/model_fits/ogle_hst_phot_ast_gp/base_a/a0_', +# 'OB110310' : mlens_dir +'OB110310/a_2021_07_08/model_fits/ogle_hst_phot_ast_gp/base_a/a0_', +# 'OB110462' : mlens_dir +'OB110462/a_2021_07_08/model_fits/ogle_hst_phot_ast_gp/base_a/a0_'} + + +def all_paper(): + #plot_images() + #make_obs_table() + #calc_base_mag() + #plot_pos_err() + + #compare_all_linear_motions() + #plot_linear_motion_all() + + # separate_modes_all() + # separate_ob150211_modes() + + #plot_ob120169_phot_ast() + #plot_ob140613_phot_ast() + #plot_ob150029_phot_ast() + #plot_ob150211_phot_ast() + + # PSPL Fit Tables and Results Values + # org_solutions_for_table() + # -- Manually adjust which solutions are positive/negative/best + # -- and the order to display the solutions in the table functions below. +# table_ob120169_phot_astrom() +# table_ob140613_phot_astrom() +# table_ob150029_phot_astrom() +# table_ob150211_phot_astrom() +# table_ob150211_phot() + + # Parameters and confidence intervals for the results text. + # results_best_params_all() + + # Lens Geometry, velocity plots +# targets = ['ob120169', 'ob140613', 'ob150029', 'ob150211'] +# for targ in targets: +# #plot_linear_motion(targ) +# plot_lens_geometry(targ, axis_lim_scale=1, vel_scale=0.25) +# calc_velocity(targ) +# plot_trace_corner(targ) + +# # Mass Posteriors +# plot_ob150211_mass_posterior_modes() +# plot_all_mass_posteriors() +# plot_ob150211_mass_piE_muRel_all_modes() +# +# # Statistics +# for targ in targets: +# calc_bayes_factor(targ) +# +# # tE vs. piE vs. deltaC plots +# piE_tE_deltac(fit_type='ast') + + # CMDs + plot_cmds() + +# dark_lens_prob('ob150211', use_surot_ext=True) +# dark_lens_prob('ob150211', mode='best', use_surot_ext=True) +# dark_lens_prob('ob120169', use_surot_ext=True) +# dark_lens_prob('ob140613', use_surot_ext=True) +# dark_lens_prob('ob150029', use_surot_ext=True) + + ##### + # OLD BROKEN STUFF + ##### + # plot_linear_fits() + + # Appendix -- DROP THIS TABLE + # make_BIC_comparison_table() + + return + +def make_obs_table(): + """ + Make a LaTeX table for all of the observations of the three targets from 2014/2015. + """ + + targets = list(epochs.keys()) + + tables = {} + + # Build three different tables with all the columns we need. + for ii in range(len(targets)): + target = targets[ii] + n_epochs = len(epochs[target]) + + obj_name = np.repeat(target.upper(), n_epochs) + obj_name[1:] = '' + + date = np.zeros(n_epochs, dtype='S10') + tint = np.zeros(n_epochs, dtype=int) + n_exp = np.zeros(n_epochs, dtype=int) + strehl = np.zeros(n_epochs, dtype=float) + fwhm = np.zeros(n_epochs, dtype=float) + strehl_e = np.zeros(n_epochs, dtype=float) + fwhm_e = np.zeros(n_epochs, dtype=float) + n_star = np.zeros(n_epochs, dtype=int) + m_base = np.zeros(n_epochs, dtype=float) + ast_err = np.zeros(n_epochs, dtype=float) + phot_err = np.zeros(n_epochs, dtype=float) + + # Loop through each epoch and grab information to populate our table. + for ee in range(n_epochs): + filt = 'kp' + if epochs[target][ee]=='20may25os': + filt ='kp_tdHband' + try: + epoch = epochs[target][ee] + img_file = '/g/lu/data/microlens/{0:s}_iraf/combo/mag{0:s}_{1:s}_{2:s}.fits'.format(epoch, target, filt) + log_file = '/g/lu/data/microlens/{0:s}_iraf/combo/mag{0:s}_{1:s}_{2:s}.log'.format(epoch, target, filt) + pos_file = '/g/lu/data/microlens/{0:s}_iraf/combo/starfinder/plotPosError_{1:s}_{2:s}.txt'.format(epoch, target, filt) + + # Fetch stuff from the image header. + hdr = fits.getheader(img_file) + date[ee] = hdr['DATE-OBS'].strip() + tint[ee] = np.round(float(hdr['ITIME']) * float(hdr['COADDS']), 0) + + if epoch.endswith('os'): + tint[ee] = np.round(float(hdr['ITIME0']) * float(hdr['COADDS']) / 1e6, 0) + + # From the log file, average Strehl and FWHM + _log = Table.read(log_file, format='ascii') + _log.rename_column('col2', 'fwhm') + _log.rename_column('col3', 'strehl') + strehl[ee] = _log['strehl'].mean() + strehl_e[ee] = _log['strehl'].std() + fwhm[ee] = _log['fwhm'].mean() + fwhm_e[ee] = _log['fwhm'].std() + n_exp[ee] = len(_log) + + # Read in the stats file from the analysis of the AIROPA starlist. + _pos = open(pos_file, 'r') + lines = _pos.readlines() + _pos.close() + + n_star[ee] = int(lines[0].split(':')[-1]) + ast_err[ee] = float(lines[1].split(':')[-1]) + phot_err[ee] = float(lines[2].split(':')[-1]) + m_base[ee] = float(lines[3].split('=')[-1]) + except: + epoch = epochs[target][ee] + img_file = '/g/lu/data/microlens/{0:s}/combo/mag{0:s}_{1:s}_kp.fits'.format(epoch, target) + log_file = '/g/lu/data/microlens/{0:s}/combo/mag{0:s}_{1:s}_kp.log'.format(epoch, target) + pos_file = '/g/lu/data/microlens/{0:s}/combo/starfinder/plotPosError_{1:s}_kp.txt'.format(epoch, target) + + # Fetch stuff from the image header. + hdr = fits.getheader(img_file) + date[ee] = hdr['DATE-OBS'].strip() + tint[ee] = np.round(float(hdr['ITIME']) * float(hdr['COADDS']), 0) + + if epoch.endswith('os'): + tint[ee] = np.round(float(hdr['ITIME0']) * float(hdr['COADDS']) / 1e6, 0) + + # From the log file, average Strehl and FWHM + _log = Table.read(log_file, format='ascii') + _log.rename_column('col2', 'fwhm') + _log.rename_column('col3', 'strehl') + strehl[ee] = _log['strehl'].mean() + strehl_e[ee] = _log['strehl'].std() + fwhm[ee] = _log['fwhm'].mean() + fwhm_e[ee] = _log['fwhm'].std() + n_exp[ee] = len(_log) + + # Read in the stats file from the analysis of the AIROPA starlist. + _pos = open(pos_file, 'r') + lines = _pos.readlines() + _pos.close() + + n_star[ee] = int(lines[0].split(':')[-1]) + ast_err[ee] = float(lines[1].split(':')[-1]) + phot_err[ee] = float(lines[2].split(':')[-1]) + m_base[ee] = float(lines[3].split('=')[-1]) + + # Make our table + c_obj_name = Column(data=obj_name, name='Object', format='{:13s}') + c_date = Column(data=date, name='Date', format='{:10s}') + c_tint = Column(data=tint, name='t$_{int}$', format='{:3.0f}', unit='s') + c_nexp = Column(data=n_exp, name='N$_{exp}$', format='{:3d}') + c_fwhm = Column(data=fwhm, name='FWHM', format='{:3.0f}', unit='mas') + c_fwhm_err = Column(data=fwhm_e, name='FWHM$_{err}$', format='{:3.0f}', unit='mas') + c_strehl = Column(data=strehl, name='Strehl', format='{:4.2f}') + c_strehl_err = Column(data=strehl_e, name='Strehl$_{err}$', format='{:4.2f}') + c_nstar = Column(data=n_star, name='N$_{star}$', format='{:4d}') + c_mbase = Column(data=m_base, name='Kp$_{turn}$', format='{:4.1f}', unit='mag') + c_asterr = Column(data=ast_err, name='$\sigma_{ast}$', format='{:5.2f}', unit='mas') + c_photerr = Column(data=phot_err, name='$\sigma_{phot}$', format='{:5.2f}', unit='mag') + + tt = Table((c_obj_name, c_date, c_tint, c_nexp, + c_fwhm, c_fwhm_err, c_strehl, c_strehl_err, + c_nstar, c_mbase, c_asterr, c_photerr)) + + tables[target] = tt + + # Smash all the tables together. + final_table = vstack([tables['ob120169'], tables['ob140613'], tables['ob150029'], tables['ob150211']]) + + print(final_table) + + final_table.write(paper_dir + 'data_table.tex', format='aastex', overwrite=True) + + return + +def calc_base_mag(plot=True): + targets = ['ob120169', 'ob140613', 'ob150029', 'ob150211'] + + base_mags = {} + + if plot: + fig, axs = plt.subplots(nrows=1, ncols=4, figsize=(16, 6)) + plt.subplots_adjust(left=0.1) + + for tt in range(len(targets)): + target = targets[tt] + + fitter, data = get_data_and_fitter(pspl_ast_multiphot[target]) + + # Figure out the first MJD day of NIRC2 observations for this target. + keck_first_mjd = np.floor(data['t_phot2'].min()) + + # Get out all epochs that are after the first year. + keck_base_idx = np.where(data['t_phot2'] > (keck_first_mjd + 365))[0] + + # Figure out the peak yar of the OGLE observations for this target. + ogle_peak_mjd = data['t_phot1'][data['mag1'].argmin()] + ogle_base_idx = np.where(data['t_phot1'] > (ogle_peak_mjd + 365))[0] + + # Average the photometry. + I_base = data['mag1'][ogle_base_idx].mean() + kp_base = data['mag2'][keck_base_idx].mean() + + base_mags[target] = {} + base_mags[target]['OGLE_I'] = I_base + base_mags[target]['NIRC2_Kp'] = kp_base + + + if plot: + print('{0:10s} OGLE_I_base = {1:.2f} Kp_base = {2:.2f}'.format(target, I_base, kp_base)) + axs[tt].errorbar(data['t_phot2'], data['mag2'], yerr=data['mag_err2']) + axs[tt].axhline(kp_base, linestyle='--') + axs[tt].set_title(target) + axs[tt].invert_yaxis() + axs[tt].set_xlabel('MJD') + + if tt == 0: + axs[tt].set_ylabel('Kp (mag)') + + return base_mags + +def calc_poisson_prob_detection(): + """ + Calculate the probability of finding 0 (or 1) black holes from + a sample of 5 events with $t_E > $ 120 days. + """ + samp_size = 5 + sim_prob_bh_mean = 0.42 + sim_prob_bh_err = 0.06 + + sigma = np.arange(-3, 3.1, 1) + colors = plt.cm.get_cmap('plasma_r', len(sigma)).colors # discrete colors + + sim_prob_bh = sim_prob_bh_mean + sigma * sim_prob_bh_err + + mu_all = samp_size * sim_prob_bh + + n_bh = np.arange(0, 11) + + plt.close(1) + plt.figure(1) + for ss in range(len(sigma)): + prob_dist = poisson(mu_all[ss]) + legend_str = '{0:.0f}$\sigma$'.format(sigma[ss]) + + plt.vlines(n_bh + (ss*0.1), 0, prob_dist.pmf(n_bh), + colors=colors[ss], linestyles='-', lw=4, + label=legend_str) + + plt.legend(loc='best', frameon=False) + plt.xlabel('Number of black holes') + plt.ylabel('Probability of detection') + + return + + +def calc_date_resolved(): + """ + Calculate + """ + targets = ['ob120169', 'ob140613', 'ob150029', 'ob150211'] + + for tt in range(len(targets)): + target = targets[tt] + + fitter, data = get_data_and_fitter(pspl_ast_multiphot[target]) + stats_ast, data_ast, mod_ast = load_summary_statistics(pspl_ast_multiphot[target]) + tab_list = fitter.load_mnest_modes() + mode = pspl_ast_multiphot_mode[target] + + # Get the magnitude of muRel for the maximum-likelihood solution. + muRel = np.hypot( stats_ast['MaxLike_muRel_E'][mode], stats_ast['MaxLike_muRel_N'][mode]) + + # Calculate the credicble intervals on muRel + sigma_vals = np.array([0.682689, 0.9545, 0.9973]) + credi_ints_lo = (1.0 - sigma_vals) / 2.0 + credi_ints_hi = (1.0 + sigma_vals) / 2.0 + credi_ints_med = np.array([0.5]) + credi_ints = np.concatenate([credi_ints_med, credi_ints_lo, credi_ints_hi]) + + sumweights = np.sum(tab_list[mode]['weights']) + weights = tab_list[mode]['weights'] / sumweights + + # Calculate median, 1 sigma lo, and 1 sigma hi credible interval. + muRel_all = np.hypot( tab_list[mode]['muRel_E'], tab_list[mode]['muRel_N'] ) + tmp = model_fitter.weighted_quantile(muRel_all, credi_ints, sample_weight=weights) + + print('') + print('*** ' + target + ' ***') + print('Best muRel = {0:.3f} mas/yr'.format(muRel)) + print(' 68.3% CI: [{0:.3f} - {1:.3f} mas/yr]'.format(tmp[1], tmp[4])) + print(' 95.5% CI: [{0:.3f} - {1:.3f} mas/yr]'.format(tmp[2], tmp[5])) + print(' 99.7% CI: [{0:.3f} - {1:.3f} mas/yr]'.format(tmp[3], tmp[6])) + + # Figure out when the objects will be resolvable using + # ~Keck 2 micron diffraction limit. + dr_resolve = 0.25 * 2.0 * 1e3 / 10.0 # mas + + from astropy.time import Time + import datetime + + t0 = Time(stats_ast['MaxLike_t0'][mode], format='mjd', scale='utc') + t0_yr = t0.decimalyear + + t0_resolve = (dr_resolve / muRel) + t0_yr + + print('') + print('Resolvable in {0:.1f} (at Keck 2 micron resolution of {1:.1f} mas)'.format(t0_resolve, dr_resolve)) + + # Figure out when the objects will be resolvable using + # ~Keck 1 micron diffraction limit. + dr_resolve = 0.25 * 1.0 * 1e3 / 10.0 # mas + t0_resolve = (dr_resolve / muRel) + t0_yr + + print('Resolvable in {0:.1f} (at Keck 1 micron resolution of {1:.1f} mas)'.format(t0_resolve, dr_resolve)) + + # Figure out when the objects will be resolvable using + # ~TMT 1 micron diffraction limit. + dr_resolve = 0.25 * 1.0 * 1e3 / 30.0 # mas + t0_resolve = (dr_resolve / muRel) + t0_yr + + print('Resolvable in {0:.1f} (at TMT 1 micron resolution of {1:.1f} mas)'.format(t0_resolve, dr_resolve)) + + return + + +def epoch_figure(): + ''' + Makes a nice illustration of the OGLE and Keck data obtained for all targets. + ''' + from astropy.time import Time + import datetime + + # Obtain all dates + targets = list(epochs.keys()) + ast_dates = np.array([]) + pho_dates = np.array([]) + ast_per_target = np.zeros(len(targets), dtype=int) + pho_per_target = np.zeros(len(targets), dtype=int) + for t in range(len(targets)): + data = munge.getdata(targets[t], time_format='jyear', + use_astrom_file=astrom_data[info['target'].lower()]) + ast_dates = np.append(ast_dates, data['t_ast1'].data) + pho_dates = np.append(pho_dates, data['t_phot'].data) + ast_per_target[t] = len(data['t_ast1']) + pho_per_target[t] = len(data['t_phot']) + + # Convert to astropy Time objects + ast_dates = Time(ast_dates, format='jyear', scale='utc').datetime + pho_dates = Time(pho_dates, format='jyear', scale='utc').datetime + t_min = np.min([ast_dates.min(), pho_dates.min()]) + t_max = np.max([ast_dates.max(), pho_dates.max()]) + years = np.arange(t_min.year, t_max.year + 1) + num_t = (years[-1] - years[0])*12 + (t_max.month - t_min.month) + month_arr = np.arange(0, num_t+1) + + # Make grid + grid = np.zeros((3*len(targets), num_t+1)) + + # Find differences in months + delta_ast = np.zeros(len(ast_dates), dtype=int) + for i in range(len(delta_ast)): + delta_ast[i] = (ast_dates[i].year - years[0])*12 + (ast_dates[i].month - t_min.month) + delta_pho = np.zeros(len(pho_dates), dtype=int) + for i in range(len(delta_pho)): + delta_pho[i] = (pho_dates[i].year - years[0])*12 + (pho_dates[i].month - t_min.month) + + a = 0 + p = 0 + black = 1 + red = 2 + for t in range(len(targets)): + in_idx = 3*t + # Identify Keck astrometry + for d in delta_ast[a:a+ast_per_target[t]]: + if d in month_arr: + grid[in_idx:in_idx+2, d] = black + a += ast_per_target[t] + # Identify OGLE photometry + for d in delta_pho[p:p+pho_per_target[t]]: + if d in month_arr: + grid[in_idx+1, d] = red + p += pho_per_target[t] + + cmap = matplotlib.colors.ListedColormap(['#ffffff', 'black', 'red']) + boundaries = [-0.5, 0.5, 1.5, 2.5] + norm = matplotlib.colors.BoundaryNorm(boundaries, cmap.N, clip=True) + + x = np.linspace(Time(t_min).jyear, Time(t_max).jyear, num_t+1) + y = np.linspace(0, len(targets), grid.shape[0]) + + fig, ax = plt.subplots(figsize=(8,6)) + cax = ax.pcolormesh(x, y, grid, cmap=cmap, norm=norm) + plt.yticks(y[1::3], targets) + + #cbar = fig.colorbar(cax, ticks=[1, 2]) + #cbar.set_clim(black, red) + #cbar.ax.set_yticklabels(['Keck', 'OGLE']) + + plt.show() + plt.savefig(paper_dir + 'epochs.pdf') + +def perr_v_mag(mag, amp, index, mag_const, adderr): + """ + Model for a positional error vs. magnitude curve. The + functional form is: + + pos_err = adderr + amp * e^(index * (mag - mag_const)) + """ + perr = amp * np.exp(index * (mag - mag_const)) + perr += adderr + + return perr + +def fit_perr_v_mag(params, mag, perr_obs): + amp = params[0] + index = params[1] + mag_const = params[2] + adderr = params[3] + + perr_mod = perr_v_mag(mag, amp, index, mag_const, adderr) + + resid = perr_obs - perr_mod + + return resid + +def plot_pos_err(): + """ + Make one plot per target that shows the positional errors vs. magnitude for every epoch. + """ + targets = list(epochs.keys()) + + plt.close('all') + + # NIRC2 plate scale (for 2015 Apr 13 and later) + scale = 0.009971 + + # Make a color scale that is the same for all of them. + color_norm = Normalize(2015, 2019) + cmap = cm.get_cmap('rainbow') + + # Loop through targets and make 1 plot each + for tt in range(len(targets)): + # for tt in range(1): + target = targets[tt] + n_epochs = len(epochs[target]) + + plt.figure() + + # Calculate the pos error vs. mag curves for each epoch. + # for ee in range(4): + for ee in range(n_epochs): + epoch = epochs[target][ee] + + filt = 'kp' + if epochs[target][ee]=='20may25os': + filt ='kp_tdHband' + try: + pos_file = '/g/lu/data/microlens/{0:s}_iraf/combo/starfinder/mag{0:s}_{1:s}_{2:s}_rms_named.lis'.format(epoch, target, filt) + lis = starlists.StarList.from_lis_file(pos_file) + except: + pos_file = '/g/lu/data/microlens/{0:s}/combo/starfinder/mag{0:s}_{1:s}_{2:s}_rms_named.lis'.format(epoch, target, filt) + lis = starlists.StarList.from_lis_file(pos_file) + + # Trim down to stars within 4" of the target + tdx = np.where(lis['name'] == target)[0][0] + r2d = np.hypot(lis['x'] - lis['x'][tdx], lis['y'] - lis['y'][tdx]) + idx = np.where(r2d < 450)[0] + + lis = lis[idx] + + # Calc the 1D astrometric error by using the average over X and Y + perr = 0.5 * (lis['xe'] + lis['ye']) + kmag = lis['m'] + np.random.rand(len(lis))*1e-5 + # col_idx = np.argmin(np.abs(color_times - lis['t'][0])) + col = cmap(color_norm(lis['t'][0])) + # print(ee, col_idx, col, color_times[col_idx], lis['t'][0]) + + # REJECTED: Analytic Functional Forms and Fitting + # Determine relation for perr vs. mag. + # sdx = kmag.argsort() + # spl = UnivariateSpline(kmag[sdx], perr[sdx], k=4) + + # # Determine relation for perr vs. mag from our exponential functional form + # # (see Jia et al. 2019). + # p0 = [1e-7, 0.7, 5, 1e-3] + # popt, pcov = curve_fit(perr_v_mag, kmag, perr, p0=p0) + # print(popt) + + # # Determine relation for perr vs. mag from our exponential functional form + # # (see Jia et al. 2019). Now with outlier rejection. + # res_lsq = least_squares(fit_perr_v_mag, p0, args=(kmag, perr)) + # res_lsq2 = least_squares(fit_perr_v_mag, p0, args=(kmag, perr), loss='cauchy', f_scale=0.01) + + # plt.plot(p_mag, spl(p_mag), label='spline') + # plt.semilogy(p_mag, perr_v_mag(p_mag, *popt), label='curve_fit') + # plt.semilogy(p_mag, perr_v_mag(p_mag, *res_lsq.x), label='lsq') + + + # FIT a functional form similar to Jia et al. 2009 with outlier rejection. + p0 = [1e-7, 0.7, 5, 1e-3] + res_lsq2 = least_squares(fit_perr_v_mag, p0, args=(kmag, perr), loss='cauchy', f_scale=0.01) + + if epoch.endswith('os'): + day = epoch[-4:-2] + else: + day = epoch[-2:] + + if target == 'ob120169': + if epoch == '12jun': day = '23' + if epoch == '12jul': day = '10' + if epoch == '13apr': day = '30' + if epoch == '13jul': day = '15' + + epoch_label = '20{0:2s} {1:s}{2:s} {3:2s}'.format(epoch[0:2], epoch[2:3].upper(), epoch[3:5], day) + + # Make a magnitude array for the model curves. + p_mag = np.arange(kmag.min(), kmag.max(), 0.05) + + # Plot the data + # if target == 'ob140613' and ee == n_epochs-1: + # plt.plot(kmag, perr * scale * 1e3, '.', label=epoch_label + ' (obs)', color=col, ms=2) + + plt.semilogy(p_mag, scale * 1e3 * perr_v_mag(p_mag, *res_lsq2.x), label=epoch_label, color=col) + + plt.legend(fontsize=12, loc='upper left', ncol=2) + plt.xlabel('Kp (mag)') + plt.ylabel('$\sigma_{ast}$ (mas)') + plt.title(target.upper()) + plt.ylim(3e-2, 10) + plt.savefig(paper_dir + 'pos_err_' + target + '.png') + + return + +def plot_images(): + img_ob120169 = '/g/lu/data/microlens/16may24/combo/mag16may24_ob120169_kp.fits' + img_ob140613 = '/g/lu/data/microlens/18aug16_iraf/combo/mag18aug16_ob140613_kp.fits' + img_ob150029 = '/g/lu/data/microlens/17jul19_iraf/combo/mag17jul19_ob150029_kp.fits' + img_ob150211 = '/g/lu/data/microlens/17jun05_iraf/combo/mag17jun05_ob150211_kp.fits' + + images = {'ob120169': img_ob120169, + 'ob140613': img_ob140613, + 'ob150029': img_ob150029, + 'ob150211': img_ob150211} + + def plot_image_for_source(target, vmin, vmax): + combo_dir = os.path.dirname(images[target]) + img_base = os.path.basename(images[target]) + + img = fits.getdata(images[target]) + + psf_file = '/g/lu/data/microlens/source_list/' + target + '_psf.list' + psf_tab = Table.read(psf_file, format='ascii', header_start=-1) + pdx = np.where(psf_tab['PSF?'] == 1)[0] + psf_tab = psf_tab[pdx] + + lis_file = combo_dir + '/starfinder/' + img_base.replace('.fits', '_rms_named.lis') + lis_tab = starlists.StarList.from_lis_file(lis_file) + + # Find the target and get its pixel coordinates in this image. + tdx = np.where(lis_tab['name'] == target)[0] + coo_targ = np.array([lis_tab['x'][tdx[0]], lis_tab['y'][tdx[0]]]) + coo_targ -= 1 # Shift to a 0-based array system + + # Define the axes + scale = 0.00996 + x_axis = np.arange(img.shape[0], dtype=float) + y_axis = np.arange(img.shape[1], dtype=float) + x_axis = (x_axis - coo_targ[0]) * scale * -1.0 + y_axis = (y_axis - coo_targ[1]) * scale + + norm = LogNorm(vmin, vmax) + + plt.imshow(img, cmap='gist_heat_r', norm=norm, extent=[x_axis[0], x_axis[-1], y_axis[0], y_axis[-1]]) + plt.plot([0], [0], 'c*', ms=35, mec='black', mfc='none', mew=2) + plt.plot(psf_tab['Xarc'], psf_tab['Yarc'], 'go', ms=15, mec='teal', mfc='none', mew=2) + + plt.axis('equal') + plt.xlabel(r'$\Delta \alpha^*$ (")') + plt.ylabel(r'$\Delta \delta$ (")') + plt.title(target.upper()) + + date_label = '20{0:2s} {1:3s} {2:2s}'.format(img_base[3:5], img_base[5:8].upper(), img_base[8:10]) + plt.text(0.5, 0.94, date_label, color='black', ha='center', transform=plt.gca().transAxes) + + # plt.xlim(0.5, -0.5) + # plt.ylim(-0.5, 0.5) + + return + + plt.close('all') + + plt.figure(4) + plt.clf() + plot_image_for_source('ob120169', 10, 5e5) + plt.savefig(paper_dir + 'img_ob120169.png') + + plt.figure(1) + plt.clf() + plot_image_for_source('ob140613', 10, 5e5) + plt.savefig(paper_dir + 'img_ob140613.png') + + plt.figure(2) + plt.clf() + plot_image_for_source('ob150029', 10, 1e5) + plt.savefig(paper_dir + 'img_ob150029.png') + + plt.figure(3) + plt.clf() + plot_image_for_source('ob150211', 12, 1e6) + plt.savefig(paper_dir + 'img_ob150211.png') + + return + +def separate_modes_all(): + targets = ['ob120169', 'ob140613', 'ob150029', 'ob150211_unsplit'] + + for targ in targets: + print(targ.upper() + ':') + + # OGLE phot, Keck phot + astrom + print(' OGLE phot, Keck phot + astrom') + mod_fit_ast, data_ast = get_data_and_fitter(pspl_ast_multiphot[targ]) + # Force remake of all FITS files. + tab_ast = mod_fit_ast.load_mnest_results(remake_fits=True) + smy_ast = mod_fit_ast.load_mnest_summary(remake_fits=True) + mod_fit_ast.separate_modes() + mod_fit_ast.plot_dynesty_style() + + # OGLE phot + print(' OGLE phot') + mod_fit_phot, data_phot = get_data_and_fitter(pspl_phot[targ]) + tab_phot = mod_fit_phot.load_mnest_results(remake_fits=True) + smy_phot = mod_fit_phot.load_mnest_summary(remake_fits=True) + mod_fit_phot.separate_modes() + mod_fit_phot.plot_dynesty_style() + + # # OGLE phot, Keck phot + # print(' OGLE phot, Keck phot') + # mod_fit_mphot, data_mphot = get_data_and_fitter(pspl_multiphot[targ]) + # mod_fit_mphot.separate_modes() + # mod_fit_mphot.plot_dynesty_style() + + return + +def separate_ob150211_modes(): + """ + The u0 > 0 mode of OB150211 shows two modes that weren't split properly. + In this code, we will split them + """ + mod_fit_ast, data_ast = get_data_and_fitter(pspl_ast_multiphot['ob150211_unsplit']) + + smy = mod_fit_ast.load_mnest_summary() + tab = mod_fit_ast.load_mnest_modes() + + smy_global = smy[0] + + # Trim out the global mode of smy. + smy = smy[1:] + + # Find the u0 > 0 (maxL) solution + idx = np.where(smy['Mean_u0_amp'] > 0)[0][0] + ndx = np.where(smy['Mean_u0_amp'] <= 0)[0][0] + + smy_g = smy[idx] + tab_g = tab[idx] + tab_neg = tab[ndx] + + ########## + # Split criteria: + ########## + + # + # Add amplitude of muRel to table and summary + # + muRel = np.hypot(tab_g['muRel_E'], tab_g['muRel_N']) + + + # Plot muRel histogram to find mode separation + bins_murel = np.arange(0, 7, 0.04) + + plt.figure(1) + plt.clf() + n, b, p = plt.hist(muRel, weights=tab_g['weights'], bins=bins_murel) + plt.xlabel('muRel (mas/yr)') + plt.ylabel('Probability') + + # Find the min point between 0-2 mas/yr. + min_murel_idx = n[b[:-1]<2].argmin() + min_murel = b[:-1][min_murel_idx] + print(f'Minimum muRel = {min_murel:.3f}') + + plt.axvline(min_murel, color='k', linestyle='--', linewidth=2) + + + # Check how muRel correlates with mass. + bins_murel2 = np.arange(0, 7, 0.2) + bins_log_mass = np.arange(-3, 2, 0.1) + plt.figure(4) + plt.clf() + plt.hist2d(muRel, np.log10(tab_g['mL']), weights=tab_g['weights'], bins=[bins_murel2, bins_log_mass]) + plt.xlabel('muRel (mas/yr)') + plt.ylabel('log(mL)') + plt.colorbar() + + # Split the mode along the minimum muRel. + mode1_mask = muRel > min_murel + tab_g_hi_murel = tab_g[mode1_mask] + tab_g_lo_murel = tab_g[~mode1_mask] + + plt.figure(2) + plt.clf() + plt.hist(muRel[~mode1_mask], weights=tab_g_lo_murel['weights'], + bins=bins_murel, color='orange', label='lo') + plt.hist(muRel[mode1_mask], weights=tab_g_hi_murel['weights'], + bins=bins_murel, color='green', label='hi') + plt.xlabel('muRel (mas/yr)') + plt.ylabel('Probability') + plt.legend() + + # Find the maximum likelihood solution for OB150211... both modes. + maxL_idx_lo = np.argmax(tab_g_lo_murel['logLike']) + maxL_idx_hi = np.argmax(tab_g_hi_murel['logLike']) + + print('Low muRel Solution (u0>0):') + print(tab_g_lo_murel[maxL_idx_lo]['logLike', 'mL']) + print('High muRel Solution (u0>0):') + print(tab_g_hi_murel[maxL_idx_hi]['logLike', 'mL']) + + print() + print('Weights sum:') + print('lo = {0:.3f}'.format(tab_g_lo_murel['weights'].sum())) + print('hi = {0:.3f}'.format(tab_g_hi_murel['weights'].sum())) + + log_ev_neg_u0 = np.log(np.sum(tab_neg['weights'])) + smy['logZ'][ndx] + log_ev_lo_murel = np.log(np.sum(tab_g_lo_murel['weights'])) + smy['logZ'][idx] + log_ev_hi_murel = np.log(np.sum(tab_g_hi_murel['weights'])) + smy['logZ'][idx] + + print('\n Old evidence:') + print(smy['logZ']) + print('\n New evidence:') + print('neg_murel', log_ev_neg_u0) + print('pos_lo_murel', log_ev_lo_murel) + print('pos_hi_murel', log_ev_hi_murel) + + + ########## + # Make a new "run" with the proper mode split. + ########## + old_output = pspl_ast_multiphot['ob150211_unsplit'] + new_output = old_output + 'split_' + + # copy over the global files. + import shutil + shutil.copyfile(old_output + '.txt', new_output + '.txt') + shutil.copyfile(old_output + '.fits', new_output + '.fits') + shutil.copyfile(old_output + 'ev.dat', new_output + 'ev.dat') + shutil.copyfile(old_output + 'live.points', new_output + 'live.points') + shutil.copyfile(old_output + 'params.yaml', new_output + 'params.yaml') + shutil.copyfile(old_output + 'phys_live.points', new_output + 'phys_live.points') + + # Add the new modes as separate tables. + tab = [tab_g_hi_murel, tab_g_lo_murel, tab_neg] + + N_modes = len(tab) + print(f'N_modes = {N_modes}') + + # Make new mode files. + for mm in range(N_modes): + tab[mm].write(new_output + f'mode{mm}.fits', overwrite=True) + + + # Make the summary table + smy_add = vstack([smy[idx], smy[idx]]) # two new solutions. + + # Replace the values. + # First, we want the statistics for the following types of solutions. + sol_types = ['maxl', 'mean', 'map'] + sol_prefix = {'maxl': 'MaxLike_', + 'mean': 'Mean_', + 'map': 'MAP_'} + + for sol in sol_types: + par_hi = mod_fit_ast.calc_best_fit(tab_g_hi_murel, smy_add, s_idx=0, def_best=sol) + par_lo = mod_fit_ast.calc_best_fit(tab_g_lo_murel, smy_add, s_idx=1, def_best=sol) + + if sol == 'maxl' or sol == 'map': + best_par_hi = par_hi + best_par_lo = par_lo + else: + best_par_hi = par_hi[0] + best_par_lo = par_lo[0] + best_parerr_hi = par_hi[1] + best_parerr_lo = par_lo[1] + + for param in mod_fit_ast.all_param_names: + if sol_prefix[sol] + param not in smy_add.colnames: + smy_add[sol_prefix[sol] + param] = 0.0 + + smy_add[sol_prefix[sol] + param][0] = best_par_hi[param] + smy_add[sol_prefix[sol] + param][1] = best_par_lo[param] + + if sol == 'mean': + smy_add['StDev_' + param][0] = best_parerr_hi[param] + smy_add['StDev_' + param][1] = best_parerr_lo[param] + + + smy_add['logZ'][0] = log_ev_hi_murel + smy_add['logZ'][1] = log_ev_lo_murel + + smy_add['maxlogL'][0] = tab_g_hi_murel['logLike'].max() + smy_add['maxlogL'][1] = tab_g_lo_murel['logLike'].max() + + # order is global, murel hi + u0 pos, murel lo + u0 pos, u0 neg + # matches the order of the modes/table. + smy_new = vstack([smy_global, smy_add, smy[ndx]]) + + print('Final Summary Table (with global)') + print(smy_new['Mean_mL', 'MAP_mL', 'MaxLike_mL', 'logZ', 'maxlogL']) + + smy_new.write(new_output + 'summary.fits', overwrite=True) + + + ########## + # Test new format + ########## + mod_fit, data = get_data_and_fitter(pspl_ast_multiphot['ob150211_unsplit'] + 'split_') + tabs_new = mod_fit.load_mnest_modes() + + plt.figure(3) + plt.clf() + bins_mL = np.logspace(-2, 2, 50) + + plt.hist(tabs_new[0]['mL'], weights=tabs_new[0]['weights'], bins=bins_mL, label='hi murel', alpha=0.4) + plt.hist(tabs_new[1]['mL'], weights=tabs_new[1]['weights'], bins=bins_mL, label='lo murel', alpha=0.4) + plt.hist(tabs_new[2]['mL'], weights=tabs_new[2]['weights'], bins=bins_mL, label='u0 neg', alpha=0.4) + plt.xscale('log') + plt.xlabel('$m_L$ (M$_\odot$)') + plt.ylabel('Probability') + plt.legend() + + return + +def calc_bayes_factor(target): + fitter, data = get_data_and_fitter(pspl_ast_multiphot[target]) + stats_ast, data_ast, mod_ast = load_summary_statistics(pspl_ast_multiphot[target]) + tab_list = fitter.load_mnest_modes() + best_mode = pspl_ast_multiphot_mode[target] + + # Modify the priors to match what is in the run.py + if target == 'ob150211': + # Adjust the priors to encompass both possible solutions + t0_guess = 57225 + fitter.priors['t0'] = model_fitter.make_gen(t0_guess - 100, t0_guess + 100) + fitter.priors['u0_amp'] = model_fitter.make_gen(-1.5, 1.5) + fitter.priors['tE'] = model_fitter.make_gen(10, 1000) + fitter.priors['piE_E'] = model_fitter.make_gen(-1, 1) + fitter.priors['piE_N'] = model_fitter.make_gen(-1, 1) + fitter.priors['b_sff1'] = model_fitter.make_gen(0, 1.2) + fitter.priors['mag_base1'] = model_fitter.make_norm_gen(17.3, 0.5) + fitter.priors['b_sff2'] = model_fitter.make_gen(0, 1.0) + fitter.priors['mag_base2'] = model_fitter.make_norm_gen(11.25, 0.5) + elif target == 'ob120169': + # Adjust the priors to encompass both possible solutions + fitter.priors['t0'] = model_fitter.make_gen(56020 - 100, 56020 + 100) + fitter.priors['u0_amp'] = model_fitter.make_gen(-1.5, 1.5) + fitter.priors['tE'] = model_fitter.make_gen(10, 1000) + fitter.priors['piE_E'] = model_fitter.make_gen(-1, 1) + fitter.priors['piE_N'] = model_fitter.make_gen(-1, 1) + fitter.priors['b_sff1'] = model_fitter.make_gen(0, 1.2) + fitter.priors['mag_base1'] = model_fitter.make_norm_gen(19.4, 0.5) + fitter.priors['b_sff2'] = model_fitter.make_gen(0, 1.0) + fitter.priors['mag_base2'] = model_fitter.make_norm_gen(18.0, 0.5) + elif target == 'ob140613': + # Adjust the priors to encompass both possible solutions + fitter.priors['t0'] = model_fitter.make_gen(57150 - 100, 57150 + 100) + fitter.priors['u0_amp'] = model_fitter.make_gen(-1.0, 1.0) + fitter.priors['tE'] = model_fitter.make_gen(10, 1000) + fitter.priors['piE_E'] = model_fitter.make_gen(-1, 1) + fitter.priors['piE_N'] = model_fitter.make_gen(-1, 1) + fitter.priors['b_sff1'] = model_fitter.make_gen(0, 1.2) + fitter.priors['mag_base1'] = model_fitter.make_norm_gen(18.2, 0.5) + fitter.priors['b_sff2'] = model_fitter.make_gen(0, 1.0) + fitter.priors['mag_base2'] = model_fitter.make_norm_gen(14.3, 0.5) + elif target == 'ob150029': + # Adjust the priors + fitter.priors['t0'] = model_fitter.make_gen(57230 - 100, 57230 + 10) + fitter.priors['u0_amp'] = model_fitter.make_gen(-1.5, 1.5) + fitter.priors['tE'] = model_fitter.make_gen(10, 1000) + fitter.priors['piE_E'] = model_fitter.make_gen(-1, 1) + fitter.priors['piE_N'] = model_fitter.make_gen(-1, 1) + fitter.priors['b_sff1'] = model_fitter.make_gen(0, 1.2) + fitter.priors['mag_base1'] = model_fitter.make_norm_gen(15.1, 0.5) + fitter.priors['b_sff2'] = model_fitter.make_gen(0, 1.0) + fitter.priors['mag_base2'] = model_fitter.make_norm_gen(12.35, 0.5) + + # Draw samples on the priors. + N_samps = 10000 + N_params = len(fitter.fitter_param_names) + + cube = np.random.rand(N_samps, N_params) + + prior_samps = {} + + plt.close('all') + for i, param_name in enumerate(fitter.fitter_param_names): + prior_samps[param_name] = fitter.priors[param_name].ppf(cube[:, i]) + + plt.figure() + if param_name == 'gp_rho1': + bins = 5000 + else: + bins = 50 + n, b, p = plt.hist(prior_samps[param_name], bins=bins, density=True, + label='Prior', histtype='step') + plt.xlabel(param_name) + if param_name == 'gp_rho1': + plt.xlim(0, 2000) + + + for tt in range(len(tab_list)): + plt.hist(tab_list[tt][param_name], weights=tab_list[tt]['weights'], bins=b, + label=f'Obs Mode {tt}', density=True, histtype='step') + + plt.legend() + plt.tight_layout() + plt.savefig(paper_dir+f'{target}_prior_{param_name}.png') + + # print out the Bayes Factors + if target == 'ob120169': + print('Single mode... no Bayes Factor') + prior_vol = 1.0 + log_BF = None + + elif target == 'ob140613' or target == 'ob150029': + # Same prior volume, so Bayes Factor is just ratio of evidence. + log_BF = stats_ast['logZ'][0] - stats_ast['logZ'][1:] + print('Bayes Factor mode 1 / mode N: ', np.exp(log_BF)) + print(stats_ast['logZ', 'MaxLike_logL', 'Mean_logL']) + + prior_vol = np.ones(len(stats_ast), dtype=float) * (1.0 / len(stats_ast)) + + elif target == 'ob150211': + # Calculate muRel amplitude on the prior samples. + prior_samps['muRel'] = 10**prior_samps['log10_thetaE'] / prior_samps['tE'] # mas/day + prior_samps['muRel'] *= 365.25 # mas/yr + + # Solution 1: + #muRel_cut = np.hypot(tab_list[0]['muRel_E'], tab_list[0]['muRel_N']).min() + #idx1 = np.where((prior_samps['u0_amp'] > 0) & (prior_samps['muRel'] >= muRel_cut))[0] + + # Solution 2: + idx1 = np.where((prior_samps['u0_amp'] < 0))[0] #& (prior_samps['muRel'] < muRel_cut))[0] + + # Solution 3: + idx2 = np.where(prior_samps['u0_amp'] >= 0)[0] + + prior_vol1 = len(idx1) / N_samps + prior_vol2 = len(idx2) / N_samps + #prior_vol3 = len(idx3) / N_samps + + prior_vol = np.array([prior_vol1, prior_vol2]) #, prior_vol3]) + log_prior_vol = np.log(prior_vol) + + print('Prior volumes:') + print(f' Mode 1 - u0 < 0: {prior_vol1:.2f}') + #print(f' Mode 2 - u0 > 0, lo muRel: {prior_vol2:.2f}') + print(f' Mode 2 - u0 >= 0: {prior_vol2:.2f}') + + print('') + + log_BF = stats_ast['logZ'][0] - stats_ast['logZ'][1:] + log_BF -= log_prior_vol[0] - log_prior_vol[1:] + BF = np.exp(log_BF) + print(f'Bayes Factor mode 1 / mode 2: {BF[0]:.3f}') + #print(f'Bayes Factor mode 1 / mode 3: {BF[1]:.3f}') + print(stats_ast['logZ', 'MaxLike_logL', 'Mean_logL']) + + return prior_vol, log_BF + +def plot_ob120169_phot_ast(def_best='maxL'): + target = 'ob120169' + mod_fit, data = get_data_and_fitter(pspl_ast_multiphot[target]) + mod_all = mod_fit.get_best_fit_modes_model(def_best = def_best) + mode = pspl_ast_multiphot_mode[target] + img_f = '/g/lu/data/microlens/16may24/combo/mag16may24_ob120169_kp.fits' + + m2 = mod_fit.get_best_fit_model(def_best=def_best) + #pdb.set_trace() + + inset_kw = {'labelp1': [-0.8, -0.2], 'labelp2': [0.9, 0.2], # + 'scalex': [-8, -6], 'scaley': [-2, -2], + 'textx': -7, 'texty': -1.95, + 'padd': 1} + plot_4panel(data, m2, target, 1, img_f, inset_kw) #ref: 2016-05-24 + return + +def plot_ob140613_phot_ast(def_best='maxL'): + target = 'ob140613' + mod_fit, data = get_data_and_fitter(pspl_ast_multiphot[target]) + mod_all = mod_fit.get_best_fit_modes_model(def_best = def_best) + mode = pspl_ast_multiphot_mode[target] + img_f = '/g/lu/data/microlens/18aug16/combo/mag18aug16_ob140613_kp.fits' + + inset_kw = {'labelp1': [-0.8, -0.2], 'labelp2': [0.9, 0.2], + 'scalex': [-8, -6], 'scaley': [-1.5, -1.5], + 'textx': -7, 'texty': -1.45, + 'padd': 1} + plot_4panel(data, mod_all[mode], target, 6, img_f, inset_kw) #ref: 2018-08-16 + return + +def plot_ob150029_phot_ast(def_best='maxL'): + target = 'ob150029' + mod_fit, data = get_data_and_fitter(pspl_ast_multiphot[target]) + mod_all = mod_fit.get_best_fit_modes_model(def_best = def_best) + mode = pspl_ast_multiphot_mode[target] + img_f = '/g/lu/data/microlens/17jul19_iraf/combo/mag17jul19_ob150029_kp.fits' + m2 = mod_fit.get_best_fit_model(def_best=def_best) + + inset_kw = {'labelp1': [-0.8, -0.2], 'labelp2': [0.9, 0.2], + 'scalex': [-1, -3], 'scaley': [-1, -1], + 'textx': -2, 'texty': -0.95, + 'padd': 0.2} + plot_4panel(data, m2, target, 6, img_f, inset_kw) + return + +def plot_ob150211_phot_ast(def_best='maxL'): + target = 'ob150211' + mod_fit, data = get_data_and_fitter(pspl_ast_multiphot[target]) + mod_all = mod_fit.get_best_fit_modes_model(def_best = def_best) + mode = pspl_ast_multiphot_mode[target] + img_f = '/g/lu/data/microlens/17jun05/combo/mag17jun05_ob150211_kp.fits' + + inset_kw = {'labelp1': [-0.8, -0.2], 'labelp2': [0.9, 0.2], + 'scalex': [3, 5], 'scaley': [4, 4], + 'textx': 4, 'texty': 3.95, + 'padd': 2} + plot_4panel(data, mod_all[mode], target, 7, img_f, inset_kw) + return + + +def plot_4panel(data, mod, target, ref_epoch, img_f, inset_kw): + ''' + Plots a 2x2 figure of 1) the Keck image @ ref_epoch (which must coincide + with img_f), 2) magnitude vs time, 3) RA vs time, and 4) DEC vs time, + where the latter three have a residual to the model. + The astrometry plots include the lens and unlensed models. + inset_kw is a dictionary for plotting 1) with the following keywords: + {'labelp1': [x, y] list of first anchor for the label line, + 'labelp2': [x, y] list of the second anchor, + 'scalex': [x1, x2] list for plotting the pixel scale in mas, + 'scaley': [y1, y2] list for plotting the pixel scale in mas, + (y1 = y2 plots a flat line), + 'textx': the x coord of the scale text in mas, + 'texty': the y coord of the scale text in mas, + 'padd': the padding to add in mas, + }. + ''' + from mpl_toolkits.axes_grid1.inset_locator import (inset_axes, InsetPosition, + mark_inset) + #pdb.set_trace() + + # Sample time + tmax = np.max(np.append(data['t_phot1'], data['t_phot2'])) + 90.0 + t_mod_ast = np.arange(data['t_ast1'].min() - 180.0, tmax, 2) + t_mod_pho = np.arange(data['t_phot1'].min(), tmax, 2) + + # Get the linear motion curves for the source (includes parallax) + p_unlens_mod = mod.get_astrometry_unlensed(t_mod_ast) + p_unlens_mod_at_ast = mod.get_astrometry_unlensed(data['t_ast1']) + + # Get the lensed motion curves for the source + p_lens_mod = mod.get_astrometry(t_mod_ast) + p_lens_mod_at_ast = mod.get_astrometry(data['t_ast1']) + + # Get the predicted photometry + m_lens_mod = mod.get_photometry(t_mod_pho, filt_idx=0) + + m_lens_mod_at_phot1 = mod.get_photometry(data['t_phot1'], filt_idx=0) + m_lens_mod_at_phot2 = mod.get_photometry(data['t_phot2'], filt_idx=1) + use_gp = True + try: + m_lens_mod_gp = mod.get_photometry_with_gp(data['t_phot1'], data['mag1'], data['mag_err1'], filt_idx=0, t_pred=t_mod_pho)[0] + m_lens_mod_gp_at_phot1 = mod.get_photometry_with_gp(data['t_phot1'], data['mag1'], data['mag_err1'], filt_idx=0)[0] + m_lens_mod_gp_only_at_phot1 = m_lens_mod_gp_at_phot1 - m_lens_mod_at_phot1 + m_lens_obs1_detrend = data['mag1'] - m_lens_mod_gp_only_at_phot1 + except: + use_gp = False + + # Get the observed photometry, de-trended (GP noise removed) + + t_mod_all = np.append(t_mod_ast, t_mod_pho) + # Set the colorbar + cmap = plt.cm.viridis + norm = plt.Normalize(vmin=t_mod_all.min(), vmax=t_mod_all.max()) + smap = plt.cm.ScalarMappable(cmap=cmap, norm=norm) + smap.set_array([]) + + # Find the closest model date to the ref_epoch and + # center inset positions on it + mod_ref_epoch = np.abs(t_mod_ast - data['t_ast1'][ref_epoch]).argmin() + xpos_ins = (p_lens_mod[:, 0] - p_lens_mod[mod_ref_epoch, 0])*-1e3 + ypos_ins = (p_lens_mod[:, 1] - p_lens_mod[mod_ref_epoch, 1])*1e3 + + # Load the Keck image + combo_dir = os.path.dirname(img_f) + img_base = os.path.basename(img_f) + + img = fits.getdata(img_f) + + psf_file = '/g/lu/data/microlens/source_list/' + target + '_psf.list' + psf_tab = Table.read(psf_file, format='ascii', header_start=-1) + pdx = np.where(psf_tab['PSF?'] == 1)[0] + psf_tab = psf_tab[pdx] + + lis_file = combo_dir + '/starfinder/' + img_base.replace('.fits', '_rms_named.lis') + lis_tab = starlists.StarList.from_lis_file(lis_file) + + # Find the target and get its pixel coordinates in this image. + tdx = np.where(lis_tab['name'] == target)[0] + coo_targ = np.array([lis_tab['x'][tdx[0]], lis_tab['y'][tdx[0]]]) + coo_targ -= 1 # Shift to a 0-based array system + + # Define the axes + scale = 0.00996 + x_axis = np.arange(img.shape[0], dtype=float) + y_axis = np.arange(img.shape[1], dtype=float) + x_axis = (x_axis - coo_targ[0]) * scale * -1.0 + y_axis = (y_axis - coo_targ[1]) * scale + + # Set figure + plt.close(1) + fig = plt.figure(1, figsize = (11,10)) + wpad = 0.14 + hpad = 0.11 + ax_width = 0.37 * 10. / 11. + ax_height = 0.37 + + ##### + # TARGET IMAGE + ##### + ax1 = fig.add_axes([wpad, 1.0 - hpad/2 - ax_height, ax_width, ax_height]) + ax1.imshow(img, cmap='gist_heat_r', norm=LogNorm(12, 1e6), + extent=[x_axis[0], x_axis[-1], y_axis[0], y_axis[-1]]) + ax1.set_xlim(-4,2) + ax1.set_ylim(-4,2) + ax1.set_xlabel(r'$\Delta \alpha^*$ (")') + ax1.set_ylabel(r'$\Delta \delta$ (")') + ax1.invert_xaxis() + + # Label the target + line_color = "#7f0f18" + ax1.plot(inset_kw['labelp1'], inset_kw['labelp2'], + linestyle='-', color=line_color) + ax1.text(inset_kw['labelp1'][0], inset_kw['labelp2'][0], target.upper(), + fontsize=16, color=line_color) + + ##### + # INSET + ##### + # Note: the scale of the inset should be the same as the image plot. + axf = inset_axes(ax1, 1.05, 1) + # Model + axf.scatter(xpos_ins/1e3, ypos_ins/1e3, c=t_mod_ast, cmap=cmap, norm=norm, s=1) + # Data + axf.errorbar((data['xpos1'] - data['xpos1'][ref_epoch])*-1, (data['ypos1'] - data['ypos1'][ref_epoch])*1, + xerr = data['xpos_err1']*1, yerr=data['ypos_err1']*1, fmt='.k') + axf.set_xticks([]) + axf.set_yticks([]) + axf.invert_xaxis() + axf.set_aspect('equal') + + # Plot the scale in the inset + axf.plot(np.array(inset_kw['scalex'])/1e3, np.array(inset_kw['scaley'])/1e3, color=line_color) + axf.text(inset_kw['textx']/1e3, inset_kw['texty']/1e3, '2 mas', color=line_color, fontsize=12, + ha='center', va='bottom') + + # Enlarge the lims to create space for the points + axf.set_ylim(axf.get_ylim()[0] - (inset_kw['padd']/1e3), axf.get_ylim()[1] + (inset_kw['padd']/1e3)) + axf.set_xlim(axf.get_xlim()[0] + (inset_kw['padd']/1e3), axf.get_xlim()[1] - (inset_kw['padd']/1e3)) + axf.set_aspect('equal') + + + # Manually set the position and relative size of the inset axes within ax1 + ip = InsetPosition(ax1, [0.40, 0.05, 0.55, 0.45]) + axf.set_axes_locator(ip) + # axins.set_axes_locator(ip) + + # Mark the region corresponding to the inset axes on the parental axes + # and draw lines in grey linking the two axes. + mark_inset(parent_axes=ax1, inset_axes=axf, loc1=1, loc2=3, fc="none", ec='0.45') + + ##### + # MAGNITUDE VS TIME + ##### + ax10 = fig.add_axes([1.0 - wpad/2 - ax_width, 1.0 - hpad/2 - 0.75*ax_height, ax_width, 0.75*ax_height]) + ax11 = fig.add_axes([1.0 - wpad/2 - ax_width, 1.0 - hpad/2 - ax_height, ax_width, 0.25*ax_height]) + # ax10.errorbar(data['t_phot1'], data['mag1'], yerr=data['mag_err1'], + # fmt='k.', alpha=0.05) + if use_gp: + ax10.errorbar(data['t_phot1'], m_lens_obs1_detrend, yerr=data['mag_err1'], + fmt='k.', alpha=0.05) + else: + ax10.errorbar(data['t_phot1'], data['mag1'], yerr=data['mag_err1'], + fmt='k.', alpha=0.05) + ax10.scatter(t_mod_pho, m_lens_mod, c = t_mod_pho, cmap = cmap, norm = norm, s = 1) + ax10.invert_yaxis() + ax10.set_ylabel('$m_I$ (mag)') + ax10.set_aspect('auto', adjustable='box') + ax10.set_xticks([]) + ax11.axhline(0, color='grey', linestyle='--', zorder=1) + ax11.errorbar(data['t_phot1'], data['mag1'] - m_lens_mod_at_phot1, yerr=data['mag_err1'], + fmt='k.', alpha=0.05, zorder=2) + if use_gp: + ax11.scatter(t_mod_pho, m_lens_mod_gp - m_lens_mod, c = t_mod_pho, cmap = cmap, norm = norm, s = 1, zorder=3) + ax11.set_ylabel('GP') + else: + ax11.set_ylabel('res.') + ax11.yaxis.set_major_locator(plt.MaxNLocator(2)) + ax11.xaxis.set_major_locator(plt.MultipleLocator(1000)) + ax11.set_xlabel('Time (MJD)') + #pdb.set_trace() + + + # Center the position data and model off the reference epoch + p_lens_mod -= [data['xpos1'][ref_epoch], data['ypos1'][ref_epoch]] + p_unlens_mod -= [data['xpos1'][ref_epoch], data['ypos1'][ref_epoch]] + p_unlens_mod_at_ast -= [data['xpos1'][ref_epoch], data['ypos1'][ref_epoch]] + data['xpos1'] -= data['xpos1'][ref_epoch] + data['ypos1'] -= data['ypos1'][ref_epoch] + + ##### + # RA VS TIME + ##### + ax20 = fig.add_axes([wpad, hpad + 0.25*ax_height, ax_width, 0.75*ax_height]) + ax21 = fig.add_axes([wpad, hpad, ax_width, 0.25*ax_height]) + ax20.errorbar(data['t_ast1'], data['xpos1']*-1e3, + yerr=data['xpos_err1']*1e3, fmt='k.', zorder = 1000) + ax20.scatter(t_mod_ast, p_lens_mod[:, 0]*-1e3, c = t_mod_ast, cmap = cmap, norm = norm, s = 1) + ax20.plot(t_mod_ast, p_unlens_mod[:, 0]*-1e3, 'r--') + ax20.get_xaxis().set_visible(False) + ax20.set_ylabel(r'$\Delta \alpha^*$ (mas)') + ax20.get_shared_x_axes().join(ax20, ax21) + ax21.errorbar(data['t_ast1'], (data['xpos1'] - p_unlens_mod_at_ast[:,0]) * -1e3, + yerr=data['xpos_err1'] * 1e3, fmt='k.', alpha=1, zorder = 1000) + ax21.scatter(t_mod_ast, (p_lens_mod[:, 0] - p_unlens_mod[:, 0])*-1e3, c = t_mod_ast, cmap = cmap, norm = norm, s = 1) + ax21.axhline(0, linestyle='--', color='r') + ax21.set_xlabel('Time (MJD)') + ax21.set_ylabel('Res.') + + ##### + # DEC VS TIME + ##### + ax30 = fig.add_axes([1.0 - wpad/2 - ax_width, hpad + 0.25*ax_height, ax_width, 0.75*ax_height]) + ax31 = fig.add_axes([1.0 - wpad/2 - ax_width, hpad, ax_width, 0.25*ax_height]) + ax30.errorbar(data['t_ast1'], data['ypos1']*1e3, + yerr=data['ypos_err1']*1e3, fmt='k.', zorder = 1000) + ax30.scatter(t_mod_ast, p_lens_mod[:, 1]*1e3, c = t_mod_ast, cmap = cmap, norm = norm, s = 1) + ax30.plot(t_mod_ast, p_unlens_mod[:, 1]*1e3, 'r--') + ax30.get_xaxis().set_visible(False) + ax30.set_ylabel(r'$\Delta \delta$ (mas)') + ax30.get_shared_x_axes().join(ax30, ax31) + ax31.errorbar(data['t_ast1'], (data['ypos1'] - p_unlens_mod_at_ast[:, 1]) * 1e3, + yerr=data['ypos_err1'] * 1e3, fmt='k.', alpha=1, zorder = 1000) + ax31.scatter(t_mod_ast, (p_lens_mod[:, 1] - p_unlens_mod[:, 1])*1e3, c = t_mod_ast, cmap = cmap, norm = norm, s = 1) + ax31.axhline(0, linestyle='--', color='r') + ax31.set_xlabel('Time (MJD)') + ax31.set_ylabel('Res.') + if target.lower()=='ob150211': + ax21.set_ylim(-1.0,0.5) + ax31.set_ylim(-0.5,1) + + plt.savefig(paper_dir + target + '_phot_astrom.pdf') + #plt.close(1) + + return + + +def plot_comparison_stars_all(): + plot_comparison_stars('ob120169', res_rng=1.1) + plot_comparison_stars('ob140613', res_rng=0.4) + plot_comparison_stars('ob150029', res_rng=1.1) + plot_comparison_stars('ob150211', res_rng=1.3) + return + +def plot_comparison_stars(target, res_rng=0.8): + """ + target : str + Target name (lowercase) + + res_rng : float + +/- range of residuals in milli-arcseconds. + """ + plt.close('all') + + ast_data_file = astrom_data[target] + + data = Table.read(ast_data_file) + + # Flip the coordinates to what we see on sky (+x increase to the East) + data['x'] *= -1.0 + data['x0'] *= -1.0 + data['vx'] *= -1.0 + + # Make a list of the source and the two nearby comparison stars (3 all together) + targets = np.append([target], comp_stars[target]) + + # Figure out the min/max of the times for these sources. + tdx = np.where(data['name'] == target)[0][0] + tmin = data['t'][tdx].min() - 0.5 # in days + tmax = data['t'][tdx].max() + 0.5 # in days + + # Setup figure and color scales + fig = plt.figure(1, figsize=(13, 7.5)) + plt.clf() + grid_t = plt.GridSpec(1, 3, hspace=5.0, wspace=0.5, bottom=0.60, top=0.95, left=0.12, right=0.86) + grid_b = plt.GridSpec(2, 3, hspace=0.1, wspace=0.5, bottom=0.10, top=0.45, left=0.12, right=0.86) + + cmap = plt.cm.plasma + norm = plt.Normalize(vmin=tmin, vmax=tmax) + smap = plt.cm.ScalarMappable(cmap=cmap, norm=norm) + smap.set_array([]) + + def plot_each_star(star_num, star_name): + # Make two boxes for each star + ax_sky = fig.add_subplot(grid_t[0, star_num]) + ax_resX = fig.add_subplot(grid_b[1, star_num]) + ax_resY = fig.add_subplot(grid_b[0, star_num]) + + # Fetch the data + tdx = np.where(data['name'] == star_name)[0][0] + star = data[tdx] + + # Make the model curves + tmod = np.arange(tmin, tmax, 0.1) + xmod = star['x0'] + star['vx'] * (tmod - star['t0']) + ymod = star['y0'] + star['vy'] * (tmod - star['t0']) + xmode = np.hypot(star['x0e'], star['vxe'] * (tmod - star['t0'])) + ymode = np.hypot(star['y0e'], star['vye'] * (tmod - star['t0'])) + + xmod_at_t = star['x0'] + star['vx'] * (star['t'] - star['t0']) + ymod_at_t = star['y0'] + star['vy'] * (star['t'] - star['t0']) + + # Plot Positions on Sky + ax_sky.plot(xmod, ymod, '-', color='grey', zorder=1) + ax_sky.plot(xmod + xmode, ymod + ymode, '--', color='grey', zorder=1) + ax_sky.plot(xmod - xmode, ymod - ymode, '--', color='grey', zorder=1) + sc = ax_sky.scatter(star['x'], star['y'], c=star['t'], cmap=cmap, norm=norm, s=20, zorder=2) + ax_sky.errorbar(star['x'], star['y'], xerr=star['xe'], yerr=star['ye'], + ecolor=smap.to_rgba(star['t']), fmt='none', elinewidth=2, zorder=2) + ax_sky.set_aspect('equal', adjustable='datalim') + + # Figure out which axis has the bigger data range. + xrng = np.abs(star['x'].max() - star['x'].min()) + yrng = np.abs(star['y'].max() - star['y'].min()) + if xrng > yrng: + ax_sky.set_xlim(star['x'].min() - 0.001, star['x'].max() + 0.001) + else: + ax_sky.set_ylim(star['y'].min() - 0.001, star['y'].max() + 0.001) + + # Set labels + ax_sky.invert_xaxis() + ax_sky.set_title(star_name.upper()) + ax_sky.set_xlabel(r'$\Delta\alpha*$ (")') + if star_num == 0: + ax_sky.set_ylabel(r'$\Delta\delta$ (")') + + + # Plot Residuals vs. Time + xres = (star['x'] - xmod_at_t) * 1e3 + yres = (star['y'] - ymod_at_t) * 1e3 + xrese = star['xe'] * 1e3 + yrese = star['ye'] * 1e3 + ax_resX.errorbar(star['t'], xres, yerr=xrese, fmt='r.', label=r'$\alpha*$', elinewidth=2) + ax_resY.errorbar(star['t'], yres, yerr=yrese, fmt='b.', label=r'$\delta$', elinewidth=2) + ax_resX.plot(tmod, xmod - xmod, 'r-') + ax_resX.plot(tmod, xmode*1e3, 'r--') + ax_resX.plot(tmod, -xmode*1e3, 'r--') + ax_resY.plot(tmod, ymod - ymod, 'b-') + ax_resY.plot(tmod, ymode*1e3, 'b--') + ax_resY.plot(tmod, -ymode*1e3, 'b--') + ax_resX.set_xlabel('Date (yr)') + ax_resX.set_ylim(-res_rng, res_rng) + ax_resY.set_ylim(-res_rng, res_rng) + ax_resY.get_xaxis().set_visible(False) + if star_num == 0: + ax_resX.set_ylabel(r'$\alpha^*$') + ax_resY.set_ylabel(r'$\delta$') + plt.gcf().text(0.015, 0.3, 'Residuals (mas)', rotation=90, fontsize=24, + ha='center', va='center') + # if star_num == 2: + # ax_res.legend(loc='right', bbox_to_anchor= (1.5, 0.5), + # borderaxespad=0, frameon=True, numpoints=1, + # handletextpad=0.1) + # leg_ax = fig.add_axes([0.88, 0.12, 0.1, 0.1]) + # leg_ax.text( + + + return sc + + + + sc = plot_each_star(0, targets[0]) + sc = plot_each_star(1, targets[1]) + sc = plot_each_star(2, targets[2]) + cb_ax = fig.add_axes([0.88, 0.60, 0.02, 0.35]) + plt.colorbar(sc, cax=cb_ax, label='Year') + + plt.savefig(paper_dir + 'comparison_star_' + target + '.png') + + return + + +def weighted_avg_and_std(values, weights): + """ + Return the weighted average and standard deviation. + + values, weights -- Numpy ndarrays with the same shape. + """ + average = np.average(values, weights=weights) + # Fast and numerically precise: + variance = np.average((values-average)**2, weights=weights) + + return (average, np.sqrt(variance)) + + + +########## +# PREFER the piE_tE() version with contours. +# This one only has stars.... good for public talk. +########## +def OLD_tE_piE(): + plt.close('all') + + t = Table.read(popsycle_events) + + mas_to_rad = 4.848 * 10**-9 + + bh_idx = np.where(t['rem_id_L'] == 103)[0] + ns_idx = np.where(t['rem_id_L'] == 102)[0] + wd_idx = np.where((t['rem_id_L'] == 101) | + (t['rem_id_L'] == 6))[0] + st_idx = np.where(t['rem_id_L'] == 0)[0] + + # start with a rectangular Figure + plt.figure(15, figsize=(8, 8)) + plt.clf() + + minpiE = 0.003 + maxpiE = 5 + mintE = 0.8 + maxtE = 500 + + # the scatter plot: + plt.scatter(t['t_E'][st_idx], t['pi_E'][st_idx]/mas_to_rad, + alpha = 0.3, label = 'Star', marker = 's', + c = 'gold') + plt.scatter(t['t_E'][wd_idx], t['pi_E'][wd_idx]/mas_to_rad, + alpha = 0.3, label = 'WD', marker = 'P', + c = 'coral') + plt.scatter(t['t_E'][ns_idx], t['pi_E'][ns_idx]/mas_to_rad, + alpha = 0.3, label = 'NS', marker = 'v', + c = 'mediumblue') + plt.scatter(t['t_E'][bh_idx], t['pi_E'][bh_idx]/mas_to_rad, + alpha = 0.3, label = 'BH', + c = 'k') + + ############# + # Add the observations. + # OB110022 from Lu+16. + # Others are phot parallax solutions (global) + ############# + # OB110022 + piEE_110022 = -0.393 + piEN_110022 = -0.071 + piE_110022 = np.hypot(piEE_110022, piEN_110022) + tE_110022 = 61.4 + + plt.scatter(tE_110022, piE_110022, label = 'OB110022', + marker = '*', s = 400) + + + # Load up best-fits: OGLE + Keck photometry and astrometry fits + targets = ['ob120169', 'ob140613', 'ob150029', 'ob150211'] + piE = {} + tE = {} + + for targ in targets: + stats_ast, data_ast, mod_ast = load_summary_statistics(pspl_ast_multiphot[targ]) + + # Figure out which solution is the max logL solution. + mdx = stats_ast['MaxLike_logL'].argmax() + piE[targ] = np.hypot(stats_ast['MaxLike_piE_E'][mdx], stats_ast['MaxLike_piE_N'][mdx]) + tE[targ] = stats_ast['MaxLike_tE'][mdx] + + plt.scatter(tE[targ], piE[targ], label = targ.upper(), + marker = '*', s = 400) + + plt.xlabel('$t_E$ (days)') + plt.ylabel('$\pi_E$') + plt.xscale('log') + plt.yscale('log') + plt.legend(loc=2) + plt.xlim(mintE, maxtE) + plt.ylim(minpiE, maxpiE) + tEbins = np.logspace(-1, 2.5, 26) + piEbins = np.logspace(-4, 1, 26) + + plt.show() + plt.savefig(paper_dir + 'tE_piE.pdf') + + return + +def piE_tE_deltac(fit_type = 'ast'): + """ + Supports plotting for several different fit solutions: + + fit_type = 'ast' + Keck + OGLE photometry, Keck astrometry + fit_type = 'phot' + OGLE photometry + fit_type = 'multiphot' + Keck + OGLE photometry + """ + if fit_type == 'ast': + data_dict = pspl_ast_multiphot + if fit_type == 'phot': + data_dict = pspl_phot + if fit_type == 'multiphot': + data_dict = pspl_multiphot + + + ########## + # !!! NOTE: CHOICE OF THE quantiles_2d HAS A LARGE EFFECT + # ON THE WAY THIS PLOT LOOKS !!! + # Plot piE-tE 2D posteriors from OGLE photometry only fits. + # Also plot PopSyCLE simulations simultaneously. + ########## + span = 0.999999426697 + smooth = 0.04 + quantiles_2d = None + hist2d_kwargs = None + labels = None + label_kwargs = None + show_titles = False + title_fmt = ".2f" + title_kwargs = None + + # Initialize values. + if label_kwargs is None: + label_kwargs = dict() + if title_kwargs is None: + title_kwargs = dict() + if hist2d_kwargs is None: + hist2d_kwargs = dict() + + # Dictionary of dictionaries containing the tE and piE + # label position for each of the text labels. + # WARNING: THE 'PHOT' AND 'AST' ARE THE SAME FOR THE NEW + # TARGETS... THEY ARE JUST PHOT THOUGH. + label_pos = {'phot': {'ob110022': [70,0.4], + 'ob120169': [150, 0.01], + 'ob140613': [170, 0.1], + 'ob150029': [150, 0.2], + 'ob150211': [35, 0.04], + 'ob170019': [0, 0.04], + 'ob170095': [0, 0.04], + 'ob190017': [0, 0.04], + 'kb200101': [0, 0]}, + 'ast': {'ob110022': [17, 0.38], + 'ob120169': [130, 0.25], + 'ob140613': [300, 0.2], + 'ob150029': [36, 0.135], + 'ob150211': [150, 0.02], + 'ob170019': [120, 0.045], + 'ob170095': [30, 0.04], + 'ob190017': [180, 0.28], + 'kb200101': [180, 0.016], + 'mb190284': [300, 0.025], + 'OB110462': [210,0.065]} + } + + label_pos_ast = {'ob120169': [0.006, 0.06], + 'ob140613': [0.04, 0.145], + 'ob150029': [0.02, 0.25], + 'ob150211': [0.03, 0.012]} + + # These are hard-coded points from previous papers (no full posteriors). + tE_points = {'ob110022': 61.4} + tE_err_points = {'ob110022': 5} # CHECK + piE_points = {'ob110022': np.hypot(-0.393, -0.071)} + piE_err_points = {'ob110022': 0.05} # CHECK + deltac_points = {'ob110022': 2.19 / np.sqrt(8)} + deltac_err_points = {'ob110022': 1.06 / np.sqrt(8)} # CHECK + + colors = {'ob110022': 'gray', + 'ob120169': 'purple', + 'ob140613': 'red', + 'ob150029': 'darkorange', + 'ob150211': 'black', + 'ob170019': 'blue', + 'ob170095': 'blue', + 'ob190017': 'blue', + 'kb200101': 'blue', + 'MB09260' : 'gray', + 'MB10364' : 'gray', + 'mb190284' : 'gray', + 'OB110037' : 'gray', + 'OB110310' : 'gray', + 'OB110462' : 'limegreen'} + + include = {'ob110022': True, + 'ob120169': True, + 'ob140613': True, + 'ob150029': True, + 'ob150211': True, + 'ob170019': False, + 'ob170095': False, + 'ob190017': False, + 'kb200101': False, + 'MB09260' : False, + 'mb190284' : False, + 'MB10364' : False, + 'OB110037' : False, + 'OB110310' : False, + 'OB110462' : True} + + include_ast = {'ob110022': True, + 'ob120169': True, + 'ob140613': True, + 'ob150029': True, + 'ob150211': True, + 'ob170019': False, + 'ob170095': False, + 'ob190017': False, + 'kb200101': False, + 'MB09260' : False, + 'mb190284' : False, + 'MB10364' : False, + 'OB110037' : False, + 'OB110310' : False, + 'OB110462' : True} + + use_label = {'ob110022': True, + 'ob120169': True, + 'ob140613': True, + 'ob150029': True, + 'ob150211': True, + 'ob170019': False, + 'ob170095': False, + 'ob190017': False, + 'kb200101': False, + 'MB09260' : False, + 'mb190284': False, + 'MB10364' : False, + 'OB110037': False, + 'OB110310': False, + 'OB110462': True} + + + ast_ulim = {'ob110022': True, + 'ob120169': False, + 'ob140613': False, + 'ob150029': False, + 'ob150211': False, + 'ob170019': False, + 'ob170095': False, + 'ob190017': False, + 'kb200101': False, + 'MB09260' : False, + 'mb190284': False, + 'MB10364' : False, + 'OB110037': True, + 'OB110310': False, + 'OB110462': False} + + # Set defaults. + hist2d_kwargs['alpha'] = hist2d_kwargs.get('alpha', 0.2) + hist2d_kwargs['levels'] = hist2d_kwargs.get('levels', quantiles_2d) + + ########## + # Load up the data + ########## + targets = ['ob120169', 'ob140613', 'ob150029', 'ob150211'] + hst_targets = ['MB09260', 'MB10364', 'OB110037', 'OB110310', 'OB110462'] + phot_targets = ['ob170019', 'ob170095', 'ob190017', 'kb200101', 'ob110022'] + tE = {} + piE = {} + theta_E = {} + deltaC = {} + weights = {} + + for targ in hst_targets: + if not include[targ] or targ in tE_points: + continue + + fit_targ, dat_targ = get_data_and_fitter(pspl_ast_multiphot[targ]) + + stats_targ = calc_summary_statistics(fit_targ) + samps_targ = fit_targ.load_mnest_modes() + + mode = stats_targ['logZ'].argmax() + # mode = pspl_ast_multiphot_mode[targ] + + # Find the best-fit solution + samps_targ = samps_targ[mode] + stats_targ = stats_targ[mode] + + param_targ = get_best_fit_from_stats(fit_targ, stats_targ, def_best='median') + + # Add thetaE (from log thetaE) + if ('log10_thetaE' in samps_targ.colnames) and ('thetaE' not in samps_targ.colnames): + theta_E[targ] = 10**samps_targ['log10_thetaE'] + else: + theta_E[targ] = samps_targ['thetaE'] + + tE[targ] = samps_targ['tE'] + piE[targ] = np.hypot(samps_targ['piE_E'], samps_targ['piE_N']) + deltaC[targ] = theta_E[targ] * 2**0.5 / 4.0 + weights[targ] = samps_targ['weights'] + + + for targ in targets: + if not include[targ] or targ in tE_points: + continue + + fit_targ, dat_targ = get_data_and_fitter(pspl_ast_multiphot[targ]) + mode = pspl_ast_multiphot_mode[targ] + + stats_targ = calc_summary_statistics(fit_targ) + samps_targ = fit_targ.load_mnest_modes() + + # Find the best-fit solution + samps_targ = samps_targ[mode] + stats_targ = Table(stats_targ[mode]) + + param_targ = get_best_fit_from_stats(fit_targ, stats_targ, def_best='median') + + # Add thetaE (from log thetaE) + if ('log10_thetaE' in samps_targ.colnames) and ('thetaE' not in samps_targ.colnames): + theta_E[targ] = 10**samps_targ['log10_thetaE'] + else: + theta_E[targ] = samps_targ['thetaE'] + + tE[targ] = samps_targ['tE'] + piE[targ] = np.hypot(samps_targ['piE_E'], samps_targ['piE_N']) + deltaC[targ] = theta_E[targ] * 2**0.5 / 4.0 + weights[targ] = samps_targ['weights'] + + for targ in phot_targets: + if not include[targ] or targ in tE_points: + continue + + fit_targ, dat_targ = get_data_and_fitter(keck_phot_2020[targ]) + + stats_targ = calc_summary_statistics(fit_targ) + samps_targ = fit_targ.load_mnest_modes() + + mode = stats_targ['logZ'].argmax() + # mode = pspl_ast_multiphot_mode[targ] + + # Find the best-fit solution + samps_targ = samps_targ[mode] + stats_targ = stats_targ[mode] + + param_targ = get_best_fit_from_stats(fit_targ, stats_targ, def_best='median') + + tE[targ] = samps_targ['tE'] + piE[targ] = np.hypot(samps_targ['piE_E'], samps_targ['piE_N']) + weights[targ] = samps_targ['weights'] + + + # MB190284 fit results (from Dave Bennett) + data_tab = '/u/jlu/doc/proposals/hst/cycle28_mid2/mcmc_bsopcnC_3.dat' + + # chi^2 1/t_E t0 umin sep theta eps1=q/(1+q) 1/Tbin dsxdt dsydt t_fix Tstar(=0) pi_E,N piE,E 0 0 0 0 0 0 0 0 0 A0ogleI A2ogleI A0ogleV A2ogleV A0moa2r A2moa2r A0moa2V + data = Table.read(data_tab, format='ascii.fixed_width_no_header', delimiter=' ') + data.rename_column('col1', 'chi2') + data.rename_column('col2', 'tE_inv') + data.rename_column('col3', 't0') + data.rename_column('col4', 'u0') + data.rename_column('col5', 'sep') + data.rename_column('col6', 'theta') + data.rename_column('col7', 'eps1') + data.rename_column('col8', 'Tbin_inv') + data.rename_column('col9', 'dsxdt') + data.rename_column('col10', 'dsydt') + data.rename_column('col11', 't_fix') + data.rename_column('col12', 'Tstar') + data.rename_column('col13', 'piEE') + data.rename_column('col14', 'piEN') + data['tE'] = 1.0 / data['tE_inv'] + data['piEE'] = data['piEE'].astype('float') + data['weight'] = np.ones(len(data)) + data['piE'] = np.hypot(data['piEE'], data['piEN']) + + targ = 'mb190284' + tE[targ] = data['tE'] + piE[targ] = data['piE'] + weights[targ] = data['weight'] + phot_targets.append(targ) + + + ########## + # Load up the PopSyCLE simulation points. + ########## + popsyc = Table.read(popsycle_events) + bh_idx = np.where(popsyc['rem_id_L'] == 103)[0] + ns_idx = np.where(popsyc['rem_id_L'] == 102)[0] + wd_idx = np.where(popsyc['rem_id_L'] == 101)[0] + st_idx = np.where(popsyc['rem_id_L'] == 0)[0] + + # Stores the maximum astrometric shift + popsyc_delta_arr = np.zeros(len(popsyc)) + + # Stores the lens-source separation corresponding + # to the maximum astrometric shift + popsyc_u_ast_max_arr = np.zeros(len(popsyc)) + + # Flux ratio of lens to source (and make it 0 if dark lens) + popsyc_g_arr = 10**(-0.4 * (popsyc['ubv_i_app_L'] - popsyc['ubv_i_app_S'])) + popsyc_g_arr = popsyc_g_arr.filled(0) + + # First calculate max astrometric shift using + # approximation that only works for u0 > 2**0.5 + g = popsyc_g_arr + u = popsyc['u0'] + numer = 1 + g * (u**2 - u * np.sqrt(u**2 + 4) + 3) + denom = u**2 + 2 + g * u * np.sqrt(u**2 + 4) + popsyc['deltaC'] = (u * popsyc['theta_E']/(1 + g)) * (numer/denom) + + # Now fix those that have u0 < 2**0.5. + idx_fix = np.where(popsyc['u0'] < 2**0.5)[0] + for i in idx_fix: + g = popsyc_g_arr[i] + thetaE = popsyc['theta_E'][i] + # Try all values between u0 and sqrt(2) to find max + # astrometric shift + u = np.linspace(popsyc['u0'][i], np.sqrt(2), 100) + numer = 1 + g * (u**2 - u * np.sqrt(u**2 + 4) + 3) + denom = u**2 + 2 + g * u * np.sqrt(u**2 + 4) + delta = (u * thetaE/(1 + g)) * (numer/denom) + max_idx = np.argmax(delta) + popsyc['deltaC'][i] = delta[max_idx] + + ########## + # Plot the piE-tE 2D posteriors from observed targets. + ########## + fig = plt.figure(1, figsize=(6,6)) + plt.clf() + axes = plt.gca() + plt.subplots_adjust(bottom=0.15) + + sx = smooth + sy = smooth + + hist2d_kwargs['fill_contours'] = hist2d_kwargs.get('fill_contours', False) + hist2d_kwargs['plot_contours'] = hist2d_kwargs.get('plot_contours', True) + + for targ in targets + phot_targets + hst_targets: + if not include[targ]: + continue + + if targ in tE_points: + plt.errorbar(tE_points[targ], piE_points[targ], + xerr=tE_err_points[targ], yerr=piE_err_points[targ], + marker = 's', ms = 4, color=colors[targ]) + else: + model_fitter.contour2d_alpha(tE[targ], piE[targ], span=[span, span], quantiles_2d=quantiles_2d, + weights=weights[targ], ax=axes, smooth=[sy, sx], color=colors[targ], + **hist2d_kwargs, plot_density=False, sigma_levels=[1, 2]) + + if include[targ] and use_label[targ]: + axes.text(label_pos[fit_type][targ][0], label_pos[fit_type][targ][1], + targ.upper(), color=colors[targ]) + + + + axes.scatter(popsyc['t_E'][st_idx], popsyc['pi_E'][st_idx], + alpha = 0.4, marker = '.', s = 25, + color = 'paleturquoise') + axes.scatter(popsyc['t_E'][wd_idx], popsyc['pi_E'][wd_idx], + alpha = 0.4, marker = '.', s = 25, + color = 'aqua') + axes.scatter(popsyc['t_E'][ns_idx], popsyc['pi_E'][ns_idx], + alpha = 0.4, marker = '.', s = 25, + color = 'tab:cyan') + axes.scatter(popsyc['t_E'][bh_idx], popsyc['pi_E'][bh_idx], + alpha = 0.8, marker = '.', s = 25, + color = 'black') + + # Trickery to make the legend darker + axes.scatter(0.01, 100, + alpha = 0.8, marker = '.', s = 25, + label = 'Star', color = 'paleturquoise') + axes.scatter(0.01, 100, + alpha = 0.8, marker = '.', s = 25, + label = 'WD', color = 'aqua') + axes.scatter(0.01, 100, + alpha = 0.8, marker = '.', s = 25, + label = 'NS', color = 'tab:cyan') + axes.scatter(0.01, 100, + alpha = 0.8, marker = '.', s = 25, + label = 'BH', color = 'black') + + axes.set_xlim(10, 1000) + axes.set_ylim(0.005, 0.5) + axes.set_xlabel('$t_E$ (days)') + axes.set_ylabel('$\pi_E$') + axes.set_xscale('log') + axes.set_yscale('log') + axes.legend(loc=3) + plt.savefig(paper_dir + 'piE_tE_' + fit_type + '.png') + plt.show() + + + ########## + # delta_c vs. piE + ########## + fig = plt.figure(2, figsize=(6,6)) + plt.clf() + axes = plt.gca() + plt.subplots_adjust(bottom=0.15) + + # Observed + for targ in targets + phot_targets + hst_targets: + if not include_ast[targ]: + continue + + # Targets with only upper limits to deltaC. + if ast_ulim[targ]: + # Check to see if we have posteriors and + # calculate the 3 sigma upper limits. + if targ not in tE_points: + deltac_conf_ints = get_CIs(deltaC[targ], weights[targ]) + piE_conf_ints = get_CIs(piE[targ], weights[targ]) + + deltac_3sig_hi = deltac_conf_ints[-1] + piE_median = model_fitter.weighted_quantile(piE[targ], [0.5], sample_weight=weights[targ])[0] + piE_err = np.array([piE_conf_ints[0:2]]).T + else: + deltac_3sig_hi = deltac_points[targ] + 3*deltac_err_points[targ] + piE_median = piE_points[targ] + piE_err = piE_err_points[targ] + + axes.errorbar(deltac_3sig_hi, piE_median, + xerr = deltac_3sig_hi * 0.25, + yerr = piE_err, + fmt = 'o', color = colors[targ], markersize = 5, + xuplims = True) + else: + # Targets with posteriors and contours. + model_fitter.contour2d_alpha(deltaC[targ], piE[targ], span=[span, span], quantiles_2d=quantiles_2d, + weights=weights[targ], ax=axes, smooth=[sy, sx], color=colors[targ], + **hist2d_kwargs, plot_density=False, sigma_levels=[1, 2]) + + + # Mass Gap Band + xarr = np.linspace(0.001, 4, 1000) + axes.fill_between(xarr, xarr*0.18, xarr*0.07, alpha=0.15, color='orange') + axes.text(0.05, 0.006, 'Mass Gap', rotation=45) + + # PopSyCLE + axes.scatter(popsyc['deltaC'][st_idx], popsyc['pi_E'][st_idx], + alpha = 0.4, marker = '.', s = 25, + c = 'paleturquoise') + axes.scatter(popsyc['deltaC'][wd_idx], popsyc['pi_E'][wd_idx], + alpha = 0.4, marker = '.', s = 25, + c = 'aqua') + axes.scatter(popsyc['deltaC'][ns_idx], popsyc['pi_E'][ns_idx], + alpha = 0.4, marker = '.', s = 25, + c = 'tab:cyan') + axes.scatter(popsyc['deltaC'][bh_idx], popsyc['pi_E'][bh_idx], + alpha = 0.8, marker = '.', s = 25, + c = 'black') + + axes.set_xlabel('$\delta_{c,max}$ (mas)') + axes.set_ylabel('$\pi_E$') + axes.set_xscale('log') + axes.set_yscale('log') +# axes.set_xlim(0.005, 4) +# axes.set_ylim(0.009, 0.5) + axes.set_xlim(0.02, 2.5) + axes.set_ylim(0.005, 0.5) + plt.savefig(paper_dir + 'piE_deltac_' + fit_type + '.png') + plt.show() + + return + +def shift_vs_piE(): + plt.close('all') + + # This assumes blending from source and lens. + t = Table.read(popsycle_events) + + u0_arr = t['u0'] + thetaE_arr = t['theta_E'] + + # Stores the maximum astrometric shift + final_delta_arr = np.zeros(len(u0_arr)) + + # Stores the lens-source separation corresponding + # to the maximum astrometric shift + final_u_arr = np.zeros(len(u0_arr)) + + # Sort by whether the maximum astrometric shift happens + # before or after the maximum photometric amplification + big_idx = np.where(u0_arr > np.sqrt(2))[0] + small_idx = np.where(u0_arr <= np.sqrt(2))[0] + + # Flux ratio of lens to source (and make it 0 if dark lens) + g_arr = 10**(-0.4 * (t['ubv_i_app_L'] - t['ubv_i_app_S'])) + dark_L_idx = np.where(t['ubv_i_app_L'] == -99) + g_arr[dark_L_idx] = 0 + + # Uncomment next line if want to do this without blending + # g_arr = np.zeros(len(t['ubv_i_app_L'])) + + for i in np.arange(len(u0_arr)): + g = g_arr[i] + thetaE = thetaE_arr[i] + # Try all values between u0 and sqrt(2) to find max + # astrometric shift + if u0_arr[i] < np.sqrt(2): + u_arr = np.linspace(u0_arr[i], np.sqrt(2), 100) + delta_arr = np.zeros(len(u_arr)) + for j in np.arange(len(u_arr)): + u = u_arr[j] + numer = 1 + g * (u**2 - u * np.sqrt(u**2 + 4) + 3) + denom = u**2 + 2 + g * u * np.sqrt(u**2 + 4) + delta = (u * thetaE/(1 + g)) * (numer/denom) + delta_arr[j] = delta + max_idx = np.argmax(delta_arr) + final_delta_arr[i] = delta_arr[max_idx] + final_u_arr[i] = u_arr[max_idx] + # Maximum astrometric shift will occur at sqrt(2) + if u0_arr[i] > np.sqrt(2): + u = u0_arr[i] + numer = 1 + g * (u**2 - u * np.sqrt(u**2 + 4) + 3) + denom = u**2 + 2 + g * u * np.sqrt(u**2 + 4) + delta = (u * thetaE/(1 + g)) * (numer/denom) + final_delta_arr[i] = delta + final_u_arr[i] = u + + mas_to_rad = 4.848 * 10**-9 + + bh_idx = np.where(t['rem_id_L'] == 103)[0] + other_idx = np.where(t['rem_id_L'] != 103)[0] + + fig = plt.figure(1, figsize=(6, 6)) + plt.clf() + + norm = matplotlib.colors.Normalize(np.log10(np.min(t['t_E'])), np.log10(np.max(t['t_E']))) + plt.subplots_adjust(bottom = 0.15, right = 0.95, top = 0.9) + plt.set_cmap('inferno_r') + plt.scatter(t['pi_E'][bh_idx]/mas_to_rad, final_delta_arr[bh_idx], + alpha = 0.2, c = 'black', label = 'PopSyCLE BH', norm = norm) + plt.scatter(t['pi_E'][other_idx]/mas_to_rad, final_delta_arr[other_idx], + alpha = 0.2, c = 'grey', label = 'PopSyCLE Other', s = 2, norm = norm) + ax = plt.gca() + + ############# + # Add the observations + ############# + targets = ['ob120169', 'ob140613', 'ob150029', 'ob150211'] + deltaC = {} + tE = {} + piE = {} + weights = {} + + for targ in targets: + fit_targ, dat_targ = get_data_and_fitter(pspl_ast_multiphot[targ]) + mode = pspl_ast_multiphot_mode[targ] + + stats_targ = calc_summary_statistics(fit_targ) + samps_targ = fit_targ.load_mnest_modes() + + # Find the best-fit solution + samps_targ = samps_targ[mode] + stats_targ = stats_targ[mode] + + param_targ = get_best_fit_from_stats(fit_targ, stats_targ, def_best='median') + + # Add thetaE (from log thetaE) + if ('log10_thetaE' in samps_targ.colnames) and ('thetaE' not in samps_targ.colnames): + thetaE_samp = 10**samps_targ['log10_thetaE'] + else: + thetaE_samp = samps_targ['thetaE'] + + tE[targ] = samps_targ['tE'] + deltaC[targ] = thetaE_samp * 2**0.5 / 4.0 + piE[targ] = np.hypot(samps_targ['piE_E'], samps_targ['piE_N']) + weights[targ] = samps_targ['weights'] + + # Get ready for some plotting + span = 0.999999426697 + smooth = 0.04 + quantiles_2d = None + hist2d_kwargs = None + labels = None + label_kwargs = None + show_titles = False + title_fmt = ".2f" + title_kwargs = None + + # Initialize values. + if label_kwargs is None: + label_kwargs = dict() + if title_kwargs is None: + title_kwargs = dict() + if hist2d_kwargs is None: + hist2d_kwargs = dict() + + sx = smooth + sy = smooth + + hist2d_kwargs['fill_contours'] = hist2d_kwargs.get('fill_contours', False) + hist2d_kwargs['plot_contours'] = hist2d_kwargs.get('plot_contours', True) + + label_pos = {'ob120169': [0.1, 1.8], + 'ob140613': [0.15, 0.15], + 'ob150029': [0.2, 0.4], + 'ob150211': [0.01, 0.6]} + + colors = {'ob120169': 'purple', + 'ob140613': 'red', + 'ob150029': 'darkorange', + 'ob150211': 'black'} + + for targ in targets: + model_fitter.contour2d_alpha(piE[targ], deltaC[targ], span=[span, span], quantiles_2d=quantiles_2d, + weights=weights[targ], ax=ax, smooth=[sy, sx], color=colors[targ], + **hist2d_kwargs, plot_density=False) + + ax.text(label_pos[targ][0], label_pos[targ][1], + targ.upper(), color=colors[targ]) + + ax.set_xscale('log') + ax.set_yscale('log') + ax.set_xlabel('$\pi_E$') + ax.set_ylabel('$\delta_{c,max}$ (mas)') + ax.set_xlim(5 * 10**-3, 1) + ax.set_ylim(5 * 10**-2, 4) + ax.legend(loc='upper left', fontsize=12) + + plt.savefig(paper_dir + 'deltac_vs_piE.png') + + + return + +def calc_peak_astrometry(): + """ + Calculate the time of peak astrometric shift (t_{max,ast}) + and the maximum amplitude of the astrometric shift (\delta_{c,max}) + for all targets. + """ + targets = ['ob120169', 'ob140613', 'ob150029', 'ob150211'] + + # Create two figures for PDF(t_max,ast) and PDF(delta_c,max). + # plt.close('all') + + f1 = plt.figure(1) + f2 = plt.figure(2) + f1.clf() + f2.clf() + + a1 = f1.subplots(1, 1) + a2 = f2.subplots(1, 1) + + bins1 = np.arange(0, 1.5, 0.05) + bins2 = np.arange(0, 1000, 20) + + for targ in targets: + fitter, data = get_data_and_fitter(pspl_ast_multiphot[targ]) + sampls = fitter.load_mnest_results() + + # Add thetaE (from log thetaE) + if ('log10_thetaE' in sampls.colnames) and ('thetaE' not in sampls.colnames): + sampls['thetaE'] = 10**sampls['log10_thetaE'] + + sampls['piE'] = np.hypot(sampls['piE_E'], sampls['piE_N']) + sampls['delta_c_max'] = sampls['thetaE'] * 2**0.5 / 4.0 + sampls['delta_t_c_max'] = sampls['tE'] * (2 - sampls['u0_amp']**2)**0.5 + + a1.hist(sampls['delta_c_max'], weights=sampls['weights'], label=targ, + histtype='step', bins=bins1) + a2.hist(sampls['delta_t_c_max'], weights=sampls['weights'], label=targ, + histtype='step', bins=bins2) + + a1.set_xlabel(r'$\delta_{c,max}$ (mas)') + a2.set_xlabel(r'$t_{c,max} - t_0$ (days)') + a1.set_ylabel('Probability') + a2.set_ylabel('Probability') + a1.legend() + a2.legend() + + return + + +def calc_pythag_err(A, sigA, B, sigB): + """ + For a function of the form f = sqrt(A^2 + B^2) where + A and B have errors sigA and sigB, calculate the + error on f, assuming A and B are uncorrelated. + """ + + f = np.hypot(A, B) + sigf = np.hypot(A * sigA, B * sigB)/f + + return sigf + +def calc_ob110022_shift(): + # THIS IS DUMB + # REDO + # Values from webplot scraper... + + ##### + # Try 1 + ##### + x1 = np.array([2.6779 * 10**-1, -4.5596 * 10**-1]) + x2 = np.array([5.8423 * 10**-2, 1.0510 * 10**-1]) + + y1 = np.array([-4.4928, -3.0920]) + y2 = np.array([-5.0524, -3.9513]) + + ##### + # Try 2 + ##### + z1 = np.array([-2.5699 * 10**-1, -4.6569 * 10**-1]) + z2 = np.array([6.7393 * 10**-2, 8.7739 * 10**-2]) + + w1 = np.array([-4.4914, -3.1114]) + w2 = np.array([-5.0585, -2.9629]) + + print(np.linalg.norm(x1 - x2)) + print(np.linalg.norm(y1 - y2)) + print(np.linalg.norm(z1 - z2)) + print(np.linalg.norm(w1 - w2)) + + return + +def calc_velocity(target): + import astropy.coordinates as coord + import astropy.units as u + + fitter, data = get_data_and_fitter(pspl_ast_multiphot[target]) + mod_all = fitter.get_best_fit_modes_model(def_best = 'median') + stats = calc_summary_statistics(fitter, verbose=False) + mode = pspl_ast_multiphot_mode[target] + bf_mod = mod_all[mode] + + # Hack for old models + fitter.all_param_names.remove('thetaE') + fitter.all_param_names.remove('mag_src1') + fitter.all_param_names.remove('mag_src2') + + bf_mod = fitter.get_best_fit_model() + + def print_vel_info(ra, dec, muE, muN, muE_e, muN_e, dist): + c1 = coord.ICRS(ra=ra*u.degree, dec=data['decL']*u.degree, + distance=dist*u.pc, + pm_ra_cosdec=muE*u.mas/u.yr, + pm_dec=muN*u.mas/u.yr) + + galcen_distance = 8*u.kpc + pm_en = [muE, muN] * u.mas/u.yr + v_e, v_n = -(galcen_distance * pm_en).to(u.km/u.s, u.dimensionless_angles()) + ve_e = -(galcen_distance * muE_e * u.mas/u.yr).to(u.km/u.s, u.dimensionless_angles()) + ve_n = -(galcen_distance * muN_e * u.mas/u.yr).to(u.km/u.s, u.dimensionless_angles()) + + gal = c1.transform_to(coord.Galactic) + mu_l = gal.pm_l_cosb + mu_b = gal.pm_b + v_l = -(galcen_distance * mu_l).to(u.km/u.s, u.dimensionless_angles()) + v_b = -(galcen_distance * mu_b).to(u.km/u.s, u.dimensionless_angles()) + + fmt = ' {0:8s} = {1:8.3f} +/- {2:8.3f} {3:8s}' + + print('Proper Motion for ' + target + ':') + print(' Celestial:') + print(fmt.format('mu_E', muE, muE_e, 'mas/yr')) + print(fmt.format('mu_N', muN, muN_e, 'mas/yr')) + print(' Galactic:') + print(fmt.format('mu_l', mu_l, 0.0, 'mas/yr')) + print(fmt.format('mu_b', mu_b, 0.0, 'mas/yr')) + + print('Velocity for ' + target + ' at dist={0:.1f}'.format(dist)) + print(' Celestial:') + print(fmt.format('v_E', v_e, ve_e, 'km/s')) + print(fmt.format('v_N', v_n, ve_n, 'km/s')) + print(' Galactic:') + print(fmt.format('v_l', v_l, 0.0, 'km/s')) + print(fmt.format('v_b', v_b, 0.0, 'km/s')) + + return + + + # Fetch the lens proper motions. Only for the "best" solution + # as this is the one we will adopt for the paper. + dL = bf_mod.dL + muL_E = bf_mod.muL[0] + muL_N = bf_mod.muL[1] + muLe_E = np.diff([stats['lo68_muL_E'][mode], stats['hi68_muL_E'][mode]])[0] / 2.0 + muLe_N = np.diff([stats['lo68_muL_N'][mode], stats['hi68_muL_N'][mode]])[0] / 2.0 + + print('\n*** Lens ***') + print_vel_info(data['raL'], data['decL'], muL_E, muL_N, muLe_E, muLe_N, dL) + + # Fetch the source proper motions. Only for the "best" solution + # as this is the one we will adopt for the paper. + dS = bf_mod.dS + muS_E = bf_mod.muS[0] + muS_N = bf_mod.muS[1] + muSe_E = np.diff([stats['lo68_muS_E'][mode], stats['hi68_muS_E'][mode]])[0] / 2.0 + muSe_N = np.diff([stats['lo68_muS_N'][mode], stats['hi68_muS_N'][mode]])[0] / 2.0 + + print('\n*** Source ***') + print_vel_info(data['raL'], data['decL'], muS_E, muS_N, muSe_E, muSe_N, dS) + + # Fetch the base magnitudes. + base_mags = calc_base_mag(plot=False) + + # Load up PopSyCLE + sim = Table.read(popsycle_events) + + # Filter out really faint stuff. CHOOSE NOT TO TRIM becuase we are + # looking at the whole field of stars, not just the target. + # sdx = np.where(sim['ubv_i_app_LSN'] < (base_mags[target]['OGLE_I'] + 0.5))[0] + # print('Keeping sims: {0:d} of {1:d}'.format(len(sdx), len(sim))) + # sim = sim[sdx] + + sim_coo = coord.Galactic(l=sim['glon_S']*u.degree, b=sim['glat_S']*u.degree, + distance=sim['px_S']*u.pc, + pm_l_cosb=sim['mu_lcosb_S']*u.mas/u.yr, + pm_b=sim['mu_b_S']*u.mas/u.yr) + + sim_icrs = sim_coo.transform_to(coord.ICRS) + sim_muS_astar = sim_icrs.pm_ra_cosdec + sim_muS_delta = sim_icrs.pm_dec + + # Load up the data to make a VPD: + ast = Table.read(data['ast_files'][0]) + + # Get rid of stuff without proper motion errors. + idx = np.where((ast['vx_err'] > 0) & (ast['vy_err'] > 0))[0] + ast = ast[idx] + + tdx = np.where(ast['name'] == target)[0][0] + ast['vx'] *= -1e3 # mas/yr increasing to the East + ast['vy'] *= 1e3 + ast['vx_err'] *= 1e3 + ast['vy_err'] *= 1e3 + +# # Shift the observed astrometry into the popsycle reference frame. +# weights = 1.0 / np.hypot(ast['vx_err'], ast['vy_err']) +# vx_obs_mean = np.average(ast['vx'], weights=weights) +# vy_obs_mean = np.average(ast['vy'], weights=weights) +# vx_sim_mean = sim_muS_astar.mean().value +# vy_sim_mean = sim_muS_delta.mean().value +# +# dvx = vx_sim_mean - vx_obs_mean +# dvy = vy_sim_mean - vy_obs_mean +# print('dvx = {0:6.2f} mas/yr'.format(dvx)) +# print('dvy = {0:6.2f} mas/yr'.format(dvy)) +# +# ast['vx'] += dvx +# ast['vy'] += dvy +# muL_E += dvx +# muL_N += dvy +# muS_E += dvx +# muS_N += dvy + + plt.close(1) + plt.figure(1, figsize=(6, 6)) + plt.clf() + plt.plot(ast['vx'][tdx], ast['vy'][tdx], 'r*', ms=10, label='Src, Keck') + plt.errorbar([muS_E], [muS_N], xerr=[muSe_E], yerr=[muSe_N], + marker='s', color='red', label='Src, Fit', ms=10, lw=2, mfc='none', mew=4) + plt.errorbar([muL_E], [muL_N], xerr=[muLe_E], yerr=[muLe_N], + marker='s', color='black', label='Lens, Fit', ms=10, lw=2, mfc='none', mew=4) + + plt.errorbar(ast['vx'], ast['vy'], xerr=ast['vx_err'], yerr=ast['vy_err'], + marker='.', color='b', linestyle='none', + label='Other, Keck', alpha=0.3) + plt.scatter(sim_muS_astar, sim_muS_delta, + alpha = 0.2, marker = '.', s = 10, + color = 'grey', label='PopSyCLE') + + plt.gca().invert_xaxis() + + plt.axis('equal') + plt.xlim(7, -12) + plt.ylim(-15, 5) + plt.xlabel(r'$\mu_{\alpha^*}$ (mas/yr)') + plt.ylabel(r'$\mu_{\delta}$ (mas/yr)') + + handles, labels = plt.gca().get_legend_handles_labels() + leg_idx = [0, 3, 4, 1, 2] + handles = [handles[ii] for ii in leg_idx] + labels = [labels[ii] for ii in leg_idx] + plt.legend(handles, labels, fontsize=14, ncol=2, loc='upper center') + + plt.title(target.upper()) + + plt.savefig(paper_dir + 'pm_vpd_' + target + '.png') + + return + +def calc_zp_ob150211(): + # Load up the Keck photometry (on arbitrary flux scale) and the + # 2MASS photometry. + ast = Table.read(data['ast_files'][0]) + tmass = Table.read('/Users/jlu/work/microlens/OB150211/tmass.fits') + + tt_t = np.where(tmass['name'] == 'ob150211')[0][0] + tt_a = np.where(ast['name'] == 'ob150211')[0][0] + + # Get the Keck stars within 4" radius. + rad = np.hypot(ast['x'] - ast['x'][tt_a], ast['y'] - ast['y'][tt_a]) + rdx = np.where(rad < 4.) + + +def plot_cmds(): + plot_cmd_ob150211() + return + +def plot_cmd_ob150211(): + """ + Everything is in + /Users/jlu/work/microlens/OB150211/a_2019_05_04/notes/7_other_phot.ipynb + """ + # Read in the Gaia and 2MASS catalogs. + tmass = Table.read('/Users/jlu/work/microlens/OB150211/tmass.fits') + gaia = Table.read('/Users/jlu/work/microlens/OB150211/current/gaia3_large.fits') + + tt_t = np.where(tmass['name'] == 'ob150211') + tt_g = np.where(gaia['source_id'] == '4058004814930630912') + + # Also fetch our best fit and figure out the source and lens/neighbor + # brightness. + foo = get_data_fitter_params_models_samples('ob150211', return_mode = 'best') + fitter = foo[0] + data = foo[1] + stats = foo[2] + params = foo[3] + models = foo[4] + sampls = foo[5] + + magS_I = params['mag_src1'] + magS_Kp = params['mag_src2'] + magLN_I = magS_I - 2.5 * math.log10((1.0 - params['b_sff1']) / params['b_sff1']**2) + magLN_Kp = magS_Kp - 2.5 * math.log10((1.0 - params['b_sff2']) / params['b_sff2']**2) + + # Get the baseline magnitude (with all blending) + magSLN_I = magS_I + 2.5 * math.log10(params['b_sff1']) + magSLN_Kp = magS_Kp + 2.5 * math.log10(params['b_sff2']) + + # Assume J-K color is the same for the lens, source, and baseline. + jk_color = tmass['Jmag'][tt_t[0][0]] - tmass['Kmag'][tt_t[0][0]] + magS_J = magS_Kp + jk_color + magLN_J = magLN_Kp + jk_color + magSLN_J = magSLN_Kp + jk_color + + print(' {0:5s} {1:5s} {2:5s} {3:7s} {4:7s}'.format('I', 'J', 'Kp', 'J_2MASS', 'K_2MASS')) + print('b_SFF: {0:5.2f} {1:5.2f} {2:5.2f}'.format(params['b_sff1'], -1, params['b_sff2'])) + print('magS: {0:5.2f} {1:5.2f} {2:5.2f}'.format(magS_I, magS_J, magS_Kp)) + print('magLN: {0:5.2f} {1:5.2f} {2:5.2f}'.format(magLN_I, magLN_J, magLN_Kp)) + print('magSLN: {0:5.2f} {1:5.2f} {2:5.2f} {3:7.2f} {4:7.2f}'.format(magSLN_I, magSLN_J, magSLN_Kp, + tmass['Jmag'][tt_t[0][0]], + tmass['Kmag'][tt_t[0][0]] + )) + + plt.close(1) + plt.figure(1, figsize=(10, 4)) + plt.subplots_adjust(bottom=0.2, left=0.1, right=0.8, wspace=0.4) + + plt.subplot(1, 2, 1) + plt.plot(tmass['Jmag'] - tmass['Kmag'], tmass['Kmag'], 'k.', alpha=0.5, mec='none') + # plt.plot(tmass['Jmag'][tt_t] - tmass['Kmag'][tt_t], tmass['Kmag'][tt_t], 'ro', ms=5, label='2MASS @ target') + plt.plot(magS_J - magS_Kp, magS_Kp, marker='s', color='orange', linestyle='none', ms=5, label='Source') + plt.plot(magLN_J - magLN_Kp, magLN_Kp, 'bs', ms=5, label='Lens + Neighbors') + plt.arrow(magLN_J - magLN_Kp, magLN_Kp, 0, 0.5, color='blue', + width=0.05, head_width=0.15, head_length=0.3) + plt.plot(magSLN_J - magSLN_Kp, magSLN_Kp, marker='*', linestyle='none', color='magenta', + mec='deeppink', ms=10, label='Total') + plt.xlim(0, 3) + plt.gca().invert_yaxis() + plt.xlabel('J-K (mag)') + plt.ylabel('K (mag)') + plt.title('2MASS') + plt.legend(fontsize=10) + + plt.subplot(1, 2, 2) + + # color code only those sources with significant parallax + good_par = np.where(np.abs(gaia['parallax']) > (3*gaia['parallax_error']))[0] + plt.plot(gaia['bp_rp'], gaia['phot_g_mean_mag'], 'k.', ms=8, alpha=0.5, zorder=1, mec='none') + sc = plt.scatter(gaia['bp_rp'][good_par], gaia['phot_g_mean_mag'][good_par], + c=gaia['parallax'][good_par], s=10, zorder=2, edgecolors='none', + vmin=-1, vmax=2, cmap=plt.cm.viridis) + plt.plot(gaia['bp_rp'][tt_g], gaia['phot_g_mean_mag'][tt_g], linestyle='none', marker='*', color='magenta', + mec='deeppink', ms=10, zorder=3) + plt.xlim(0, 6.5) + plt.gca().invert_yaxis() + plt.xlabel('G$_{BP}$ - G$_{RP}$ (mag)') + plt.ylabel('G (mag)') + plt.title('Gaia') + + fig = plt.gcf() + cb_ax = fig.add_axes([0.83, 0.13, 0.02, 0.77]) + cbar = fig.colorbar(sc, cax=cb_ax, label='Parallax (mas)') + + plt.savefig(paper_dir + 'ob150211_cmds.png') + + return + +def plot_cmd_other3(): + """ + Everything is in + /Users/jlu/work/microlens/OB150211/a_2019_05_04/notes/7_other_phot.ipynb + """ + raise NotImplementedError("This function is not set up to generate the other cmds.") + # Read in the Gaia and 2MASS catalogs. + tmass = Table.read('/Users/jlu/work/microlens/OB150211/tmass.fits') + gaia = Table.read('/Users/jlu/work/microlens/OB150211/gaia.fits') + + tt_t = np.where(tmass['name'] == 'ob150211') + tt_g = np.where(gaia['name'] == 'ob150211') + + # Also fetch our best fit and figure out the source and lens/neighbor + # brightness. + foo = get_data_fitter_params_models_samples('ob150211', return_mode = 'best') + fitter = foo[0] + data = foo[1] + stats = foo[2] + params = foo[3] + models = foo[4] + sampls = foo[5] + + magS_I = params['mag_src1'] + magS_Kp = params['mag_src2'] + magLN_I = magS_I - 2.5 * math.log10((1.0 - params['b_sff1']) / params['b_sff1']**2) + magLN_Kp = magS_Kp - 2.5 * math.log10((1.0 - params['b_sff2']) / params['b_sff2']**2) + + # Get the baseline magnitude (with all blending) + magSLN_I = magS_I + 2.5 * math.log10(params['b_sff1']) + magSLN_Kp = magS_Kp + 2.5 * math.log10(params['b_sff2']) + + # Assume J-K color is the same for the lens, source, and baseline. + jk_color = tmass['Jmag'][tt_t[0][0]] - tmass['Kmag'][tt_t[0][0]] + magS_J = magS_Kp + jk_color + magLN_J = magLN_Kp + jk_color + magSLN_J = magSLN_Kp + jk_color + + print(' {0:5s} {1:5s} {2:5s} {3:7s} {4:7s}'.format('I', 'J', 'Kp', 'J_2MASS', 'K_2MASS')) + print('b_SFF: {0:5.2f} {1:5.2f} {2:5.2f}'.format(params['b_sff1'], -1, params['b_sff2'])) + print('magS: {0:5.2f} {1:5.2f} {2:5.2f}'.format(magS_I, magS_J, magS_Kp)) + print('magLN: {0:5.2f} {1:5.2f} {2:5.2f}'.format(magLN_I, magLN_J, magLN_Kp)) + print('magSLN: {0:5.2f} {1:5.2f} {2:5.2f} {3:7.2f} {4:7.2f}'.format(magSLN_I, magSLN_J, magSLN_Kp, + tmass['Jmag'][tt_t[0][0]], + tmass['Kmag'][tt_t[0][0]] + )) + + plt.close(1) + plt.figure(1, figsize=(10, 4)) + plt.subplots_adjust(bottom=0.2, left=0.1, right=0.8, wspace=0.4) + + plt.subplot(1, 2, 1) + plt.plot(tmass['Jmag'] - tmass['Kmag'], tmass['Kmag'], 'k.', alpha=0.5, mec='none') + plt.plot(tmass['Jmag'][tt_t] - tmass['Kmag'][tt_t], tmass['Kmag'][tt_t], 'ro', ms=5, label='2MASS @ target') + plt.plot(magS_J - magS_Kp, magS_Kp, 'rs', ms=5, label='Source') + plt.plot(magLN_J - magLN_Kp, magLN_Kp, 'bs', ms=5, label='Lens + Neighbors') + plt.plot(magSLN_J - magSLN_Kp, magSLN_Kp, 'g*', ms=10, label='Total') + plt.xlim(0, 3) + plt.gca().invert_yaxis() + plt.xlabel('J-K (mag)') + plt.ylabel('K (mag)') + plt.title('2MASS') + plt.legend(fontsize=10) + + plt.subplot(1, 2, 2) + + # color code only those sources with significant parallax + good_par = np.where(np.abs(gaia['parallax']) > (3*gaia['parallax_error']))[0] + plt.plot(gaia['bp_rp'], gaia['phot_g_mean_mag'], 'k.', ms=8, alpha=0.5, zorder=1, mec='none') + sc = plt.scatter(gaia['bp_rp'][good_par], gaia['phot_g_mean_mag'][good_par], + c=gaia['parallax'][good_par], s=10, zorder=2, edgecolors='none', + vmin=-1, vmax=2, cmap=plt.cm.viridis) + plt.plot(gaia['bp_rp'][tt_g], gaia['phot_g_mean_mag'][tt_g], 'ro', ms=5, zorder=3) + plt.xlim(0, 6.5) + plt.gca().invert_yaxis() + plt.xlabel('G$_{BP}$ - G$_{RP}$ (mag)') + plt.ylabel('G (mag)') + plt.title('Gaia') + + fig = plt.gcf() + cb_ax = fig.add_axes([0.83, 0.13, 0.02, 0.77]) + cbar = fig.colorbar(sc, cax=cb_ax, label='Parallax (mas)') + + plt.savefig(paper_dir + 'cmds.png') + + return + +def print_lens_brightness(mode='global'): + """ + Print out the lens brightness (mean and std) for all targets + based on the baseline magnitude and the source flux fraction. + """ + targets = ['ob120169', 'ob140613', 'ob150029', 'ob150211'] + + for target in targets: + if mode == 'global': + fitter, data = get_data_and_fitter(pspl_ast_multiphot[target]) + sampls = fitter.load_mnest_results() + elif mode == 'best': + foo = get_data_fitter_params_models_samples(target, return_mode = 'best') + fitter = foo[0] + data = foo[1] + stats = foo[2] + params = foo[3] + models = foo[4] + sampls = foo[5] + else: + foo = get_data_fitter_params_models_samples(target, return_mode = 'all') + fitter = foo[0] + data = foo[1] + stats = foo[2] + params = foo[3] + models = foo[4] + sampls = foo[5] + + sampls = sampls[mode] + + + bsff2_idx = np.where(sampls['b_sff2'] > 1)[0] + sampls['b_sff2'][bsff2_idx] = 0.999999 + kpL_fit = sampls['mag_base2'] + 2.5*np.log10(1/(1 - sampls['b_sff2'])) + # Properly weighted mean and STD. + kpL_mean = np.average(kpL_fit, weights=sampls['weights']) + kpL_std = np.sqrt(np.average((kpL_fit-kpL_mean)**2, weights=sampls['weights'])) + + bsff1_idx = np.where(sampls['b_sff1'] > 1)[0] + sampls['b_sff1'][bsff1_idx] = 0.999999 + oIL_fit = sampls['mag_base1'] + 2.5*np.log10(1/(1 - sampls['b_sff1'])) + # Properly weighted mean and STD. + oIL_mean = np.average(oIL_fit, weights=sampls['weights']) + oIL_std = np.sqrt(np.average((oIL_fit-oIL_mean)**2, weights=sampls['weights'])) + + # Kp-band + print(f'\n*** {target} ***') + print(f' Kp_L = {kpL_mean:.2f} +/- {kpL_std:.2f}') + print(f' I_L = {oIL_mean:.2f} +/- {oIL_std:.2f}') + + return + + + +def run_galaxia_all_targets(): + """ + Must run in the paper directory. + """ + targets = ['ob120169', 'ob140613', 'ob150029', 'ob150211'] + + gal_param_file = paper_dir + 'galaxy_model_params.txt' + if not os.path.exists(gal_param_file): + orig_file = '/Users/casey/scratch/papers/hst_sahu_2020/scratch_work/vpd/galaxy_model_params.txt' + shutil.copyfile(orig_file, gal_param_file) + + from popsycle import synthetic + + for target in targets: + output_root = f'popsycle_{target:s}' + + if os.path.exists(output_root + '.ebf'): + continue + + print(f'Running Galaxia for {target} to save in {output_root}.') + + # Get the galactic lat and lon of the target + ra = munge.ra[target] + dec = munge.dec[target] + sim_radius = 60.0 # arcsec + + sim_area = math.pi * sim_radius**2 + sim_area_deg2 = sim_area / 3600**2 + + print(sim_area, ' arcsec^2') + print(sim_area_deg2, ' deg^2') + + target_coords = SkyCoord(ra, dec, unit=(u.hourangle, u.deg), frame='icrs') + + gal_l = target_coords.galactic.l.degree + gal_b = target_coords.galactic.b.degree + + + synthetic.run_galaxia(output_root, + gal_l, + gal_b, + sim_area_deg2, + gal_param_file) + + return + +def dark_lens_prob(target, plot=True, mode='global', use_surot_ext=False): + ########## + # Load up all the data and fit samples. + ########## + if mode == 'global': + fitter, data = get_data_and_fitter(pspl_ast_multiphot[target]) + sampls = fitter.load_mnest_results() + elif mode == 'best': + foo = get_data_fitter_params_models_samples(target, return_mode = 'best') + fitter = foo[0] + data = foo[1] + stats = foo[2] + params = foo[3] + models = foo[4] + sampls = foo[5] + else: + foo = get_data_fitter_params_models_samples(target, return_mode = 'all') + fitter = foo[0] + data = foo[1] + stats = foo[2] + params = foo[3] + models = foo[4] + sampls = foo[5] + + sampls = sampls[mode] + + + # We will be using PopSyCLE (Galaxia) runs to sample on the age. + # We need to get indices for ages. This means we need a distance-dependent + # age weighting (or sampling) scheme. +# ebf_list = {'ob120169': paper_dir + 'popsycle_ob120169.ebf', +# 'ob140613': paper_dir + 'popsycle_ob140613.ebf', +# 'ob150029': paper_dir + 'popsycle_ob150029.ebf', +# 'ob150211': paper_dir + 'popsycle_ob150211.ebf' +# } + ebf_list = {'ob120169': '/u/nsabrams/work/PopSyCLE_runs/v2023/ob12-15_targets/single_runs_v3_N20'\ + '_macy_targets_24-03-04/runs/OB120169_0/OB120169.ebf', + 'ob140613': '/u/nsabrams/work/PopSyCLE_runs/v2023/ob12-15_targets/single_runs_v3_N20'\ + '_macy_targets_24-03-04/runs/OB140613_0/OB140613.ebf', + 'ob150029': '/u/nsabrams/work/PopSyCLE_runs/v2023/ob12-15_targets/single_runs_v3_N20'\ + '_macy_targets_24-03-04/runs/OB150029_0/OB150029.ebf', + 'ob150211': '/u/jlu/work/microlens/OB150211/a_2020_08_18/notes/ob150211.ebf' + } + + ########## + # Make a 3D grid on distance, mass, and age containing + # the Kp and OLGE I magnitude of each star. Populate + # the grid from model isochrones. + # Distance grid + ########## + dL_arr_list = {'ob120169': np.arange(4.0, 12.01, 0.5), + 'ob140613': np.arange(4.0, 12.01, 0.5), + 'ob150029': np.arange(4.0, 12.01, 0.5), + 'ob150211': np.arange(4.0, 12.01, 0.5) + } + + dL_arr = dL_arr_list[target] + + # Age grid + age_arr = np.arange(7, 10.01, 0.5) + + # Mass grid + mass_arr = np.append(np.arange(0.08, 3.0, 0.05), + np.logspace(np.log10(3.0), np.log10(120), num=32)) + + if not use_surot_ext: + spisea_kp_oI_file = paper_dir + 'spisea_kp_oI_3d_' + target + '.pkl' + else: + spisea_kp_oI_file = paper_dir + 'spisea_kp_oI_surot_3d_' + target + '.pkl' + + if os.path.exists(spisea_kp_oI_file): + print('Loading existing SPISEA 3D arrays') + _tmp = open(spisea_kp_oI_file, 'rb') + kp_3d = pickle.load(_tmp) + oI_3d = pickle.load(_tmp) + _tmp.close() + else: + kp_3d = np.empty((len(dL_arr), len(age_arr), len(mass_arr)), dtype=float) + oI_3d = np.empty((len(dL_arr), len(age_arr), len(mass_arr)), dtype=float) + + # Calculate the extinction at each distance using a 3D exitnction map. + coords_arr = SkyCoord(data['raL'] * u.deg, + data['decL'] * u.deg, + distance = dL_arr * u.kpc, frame='icrs') + + from spisea import synthetic, evolution, atmospheres, reddening #, ifmr + from spisea.imf import imf #, multiplicityimport dustmaps + + if not use_surot_ext: + print("Using Marshall extinction map") + import dustmaps.marshall + from dustmaps.marshall import MarshallQuery + dustmaps.marshall.fetch() + q = MarshallQuery() + AKs_arr = q(coords_arr) + else: + print("Using Surot extinction map") + from synthpop.modules.extinction import surot + q = surot.Surot().extinction_in_map + coords_lb = coords_arr.transform_to('galactic') + AKs_arr = q(coords_lb.l.degree, coords_lb.b.degree, coords_lb.distance.kpc) + print("AKs_arr") + print(AKs_arr) + + # Define evolution/atmosphere models and extinction law + from spisea import synthetic, evolution, atmospheres, reddening + evo_model = evolution.MISTv1(version=1.2, synthpop_extension=True) + atm_func = atmospheres.get_merged_atmosphere + red_law = reddening.RedLawDamineli16() + + + # Loop through every distance and age and make an isochrone. + for dd in range(len(dL_arr)): + dL = dL_arr[dd] + AKs = AKs_arr[dd] + + for aa in range(len(age_arr)): + logAge = age_arr[aa] + + # Make Isochrone object. Note that is calculation will take a few minutes, unless the + # isochrone has been generated previously. + print(f'Making isochrone: dist={dL:.2f} kpc, logAge={logAge:.2f}, AKs={AKs:.2f}') + my_iso = synthetic.IsochronePhot(logAge, AKs, dL*1000, + metallicity=0, + evo_model=evo_model, atm_func=atm_func, + red_law=red_law, filters=['ubv,I', 'nirc2,Kp'], + recomp=False, + iso_dir=paper_dir + 'iso/') + + iso_interp_kp = interpolate.interp1d(my_iso.points['mass'], + my_iso.points['m_nirc2_Kp'], + kind='linear', + bounds_error=False, + fill_value=np.nan) + iso_interp_I = interpolate.interp1d(my_iso.points['mass'], + my_iso.points['m_ubv_I'], + kind='linear', + bounds_error=False, + fill_value=np.nan) + + # Loop through each mass bin and find the minimum kp and I magnitudes. + for mm in range(len(mass_arr)): + mass = mass_arr[mm] + kp_3d[dd, aa, mm] = iso_interp_kp(mass) + oI_3d[dd, aa, mm] = iso_interp_I(mass) + + _tmp = open(spisea_kp_oI_file, 'wb') + pickle.dump(kp_3d, _tmp) + pickle.dump(oI_3d, _tmp) + _tmp.close() + + ######### + # Figure out which bins our posterior samples fall into. + # + # Sample age from the distance-dependent age distribution from PopSyCLE. + ######### + # Setup bins for histogramming. + dL_delta = np.diff(dL_arr) + dL_bins = dL_arr[1:] - (dL_delta / 2.0) + dL_bins = np.insert(dL_bins, 0, dL_arr[0] - dL_delta[0] / 2.0) + dL_bins = np.append(dL_bins, dL_arr[-1] + dL_delta[-1] / 2.0) + + mL_delta = np.diff(mass_arr) + mL_bins = mass_arr[1:] - (mL_delta / 2.0) + mL_bins = np.insert(mL_bins, 0, mass_arr[0] - mL_delta[0] / 2.0) + mL_bins = np.append(mL_bins, mass_arr[-1] + mL_delta[-1] / 2.0) + + age_delta = np.diff(age_arr) + age_bins = age_arr[1:] - (age_delta / 2.0) + age_bins = np.insert(age_bins, 0, age_arr[0] - age_delta[0] / 2.0) + age_bins = np.append(age_bins, age_arr[-1] + age_delta[-1] / 2.0) + + + # Re-normalize the posterior weights array to sum to 1.0 + sampls['weights'] /= sampls['weights'].sum() + + # Take a random sample of the lens fits (weighted) so that we + # have a proper posterior sample. + samp_idx = np.random.choice(np.arange(len(sampls['weights'])), + size=5000, replace=False, p=sampls['weights']) + resamp = sampls[samp_idx] + + # Define our sample for the posteriors in + # all filters for: + # Kp( mag_base_kp, b_sff_kp ) + # oI( mag_base_oI, b_sff_oI ) + bsff2_idx = np.where(resamp['b_sff2'] > 1)[0] + resamp['b_sff2'][bsff2_idx] = 0.999999 + kpL_fit = resamp['mag_base2'] + 2.5*np.log10(1/(1 - resamp['b_sff2'])) + + bsff1_idx = np.where(resamp['b_sff1'] > 1)[0] + resamp['b_sff1'][bsff1_idx] = 0.999999 + oIL_fit = resamp['mag_base1'] + 2.5*np.log10(1/(1 - resamp['b_sff1'])) + + # For the same sample, loop through and figure out which bins each + # falls in (in our 3D model array). + # Kp( dL, mL, age(dL | popsycle) ) -- random sampling on age from PopSyCLE. + # oI( dL, mL, age(dL | popsycle) ) -- random sampling on age from PopSyCLE. + mL_fit = resamp['mL'] + dL_fit = 1.0 / resamp['piL'] + + mL_idx = np.digitize(mL_fit, bins=mL_bins) - 1 + dL_idx = np.digitize(dL_fit, bins=dL_bins) - 1 + + sim = ebf.read(ebf_list[target], '/') + + # Loop through our distance bins and make an age array. + wgt_dL_age = np.empty((len(dL_arr), len(age_arr)), dtype=float) + + age_idx = np.ones(len(mL_idx), dtype=int) * -1 + + import pdb + for dd in range(len(dL_arr)): + # Select PopSyCLE stars in this radius bin. + sdx = np.where((sim['rad'] >= dL_bins[dd]) & (sim['rad'] < dL_bins[dd+1]))[0] + + age_hist, age_be = np.histogram(sim['age'], bins=age_bins) + age_hist = age_hist / age_hist.sum() # normalize + + wgt_dL_age[dd, :] = age_hist + + idx = np.where(dL_idx == dd)[0] + age_idx[idx] = np.random.choice(np.arange(len(age_arr)), + size=1, replace=False, p=age_hist) + + print("Total points in sample: ", len(dL_fit)) + print('Too small distances: ', (dL_fit < dL_bins[0]).sum()) + print('Too large distances: ', (dL_fit > dL_bins[-1]).sum()) + print('Too small masses: ', (mL_fit < mL_bins[0]).sum()) + print('Too large masses: ', (mL_fit > mL_bins[-1]).sum()) + + good = np.where((age_idx >= 0))[0] + print('Bad entries: ', len(age_idx) - len(good)) + dL_fit = dL_fit[good] + mL_fit = mL_fit[good] + kpL_fit = kpL_fit[good] + oIL_fit = oIL_fit[good] + age_idx = age_idx[good] + dL_idx = dL_idx[good] + mL_idx = mL_idx[good] + + kpL_mod = np.full(len(dL_fit), np.nan, dtype=float) + oIL_mod = np.full(len(dL_fit), np.nan, dtype=float) + + # Only query the 3D arrays where we have good masses. + gm = np.where((mL_fit >= mL_bins[0]) & (mL_fit <= mL_bins[-1]))[0] + + age_mod = age_arr[age_idx] + kpL_mod[gm] = kp_3d[dL_idx[gm], age_idx[gm], mL_idx[gm]] + oIL_mod[gm] = oI_3d[dL_idx[gm], age_idx[gm], mL_idx[gm]] + + + # Kp probabilities + no_mass_match_idx_kp = np.argwhere(np.isnan(kpL_mod)) + dark_idx_kp = np.where(kpL_fit > kpL_mod)[0] + lum_idx_kp = np.where(kpL_fit <= kpL_mod)[0] + + p_no_mass_match_kp = len(no_mass_match_idx_kp)/len(mL_fit) + p_dark_kp = len(dark_idx_kp)/len(mL_fit) + p_lum_kp = len(lum_idx_kp)/len(mL_fit) + + # OGLE I probabilities + no_mass_match_idx_oI = np.argwhere(np.isnan(oIL_mod)) + dark_idx_oI = np.where(oIL_fit > oIL_mod)[0] + lum_idx_oI = np.where(oIL_fit <= oIL_mod)[0] + + p_no_mass_match_oI = len(no_mass_match_idx_oI)/len(mL_fit) + p_dark_oI = len(dark_idx_oI)/len(mL_fit) + p_lum_oI = len(lum_idx_oI)/len(mL_fit) + + # Joint probabilities + no_mass_match_idx = np.argwhere(np.isnan(kpL_mod) | np.isnan(oIL_mod)) + dark_idx = np.where((kpL_fit > kpL_mod) | (oIL_fit > oIL_mod))[0] + lum_idx = np.where((kpL_fit <= kpL_mod) & (oIL_fit <= oIL_mod))[0] + + p_no_mass_match = len(no_mass_match_idx)/len(mL_fit) + p_dark = len(dark_idx)/len(mL_fit) + p_lum = len(lum_idx)/len(mL_fit) + + print('') + print('Total points in sample after final cuts: ', len(dL_fit)) + print(f'Dark stars (kp): N = {len(dark_idx_kp):4d} p = {p_dark_kp:.4f}') + print(f'Dead stars (kp): N = {len(no_mass_match_idx_kp):4d} p = {p_no_mass_match_kp:.4f}') + print(f'Luminous stars (kp): N = {len(lum_idx_kp):4d} p = {p_lum_kp:.4f}') + print('Total Prob (kp): p = {0:.2f}'.format(p_dark_kp + p_no_mass_match_kp + p_lum_kp)) + print('') + print(f'Dark stars (oI): N = {len(dark_idx_oI):4d} p = {p_dark_oI:.4f}') + print(f'Dead stars (oI): N = {len(no_mass_match_idx_oI):4d} p = {p_no_mass_match_oI:.4f}') + print(f'Luminous stars (oI): N = {len(lum_idx_oI):4d} p = {p_lum_oI:.4f}') + print('Total Prob (oI): p = {0:.2f}'.format(p_dark_oI + p_no_mass_match_oI + p_lum_oI)) + print('') + print(f'Dark stars (joint): N = {len(dark_idx):4d} p = {p_dark:.4f}') + print(f'Dead stars (joint): N = {len(no_mass_match_idx):4d} p = {p_no_mass_match:.4f}') + print(f'Luminous stars (joint): N = {len(lum_idx):4d} p = {p_lum:.4f}') + print('Total Prob (joint): p = {0:.2f}'.format(p_dark + p_no_mass_match + p_lum)) + print('') + + + ########## + # Plotting + ########## + mass_bins_plot = {'ob120169': np.logspace(-2, 0.5, 10), + 'ob140613': np.logspace(-1, 0.5, 15), + 'ob150029': np.logspace(-2.5, 0.5, 15), + 'ob150211': np.logspace(np.log10(mL_fit.min()), np.log10(mL_fit.max()+0.01), 11) + } + + mass_bins = mass_bins_plot[target] + n_no_mass_kp = np.zeros(len(mass_bins) - 1) + n_dark_kp = np.zeros(len(mass_bins) - 1) + n_lum_kp = np.zeros(len(mass_bins) - 1) + + n_no_mass_oI = np.zeros(len(mass_bins) - 1) + n_dark_oI = np.zeros(len(mass_bins) - 1) + n_lum_oI = np.zeros(len(mass_bins) - 1) + + n_no_mass = np.zeros(len(mass_bins) - 1) + n_dark = np.zeros(len(mass_bins) - 1) + n_lum = np.zeros(len(mass_bins) - 1) + + mass_bin_centers = (mass_bins[:-1] + mass_bins[1:])/2 + bin_width = np.diff(mass_bins) + + # mass_bins = mass_bins_plot[target] + # mass_bin_centers = mass_bins[0:-1] + np.diff(mass_bins) / 2.0 + # bin_width = mass_bins[1] - mass_bins[0] + + for ii in np.arange(len(mass_bins) - 1): + # Classify based on Kp only + no_mass_idx_kp = np.where((mL_fit < mass_bins[ii+1]) & + (mL_fit > mass_bins[ii]) & + (np.isnan(kpL_mod)))[0] + + dark_idx_kp = np.where((mL_fit < mass_bins[ii+1]) & + (mL_fit > mass_bins[ii]) & + (kpL_fit > kpL_mod))[0] + + lum_idx_kp = np.where((mL_fit < mass_bins[ii+1]) & + (mL_fit > mass_bins[ii]) & + (kpL_fit < kpL_mod))[0] + + # Classify based on ogle I only + no_mass_idx_oI = np.where((mL_fit < mass_bins[ii+1]) & + (mL_fit > mass_bins[ii]) & + (np.isnan(oIL_mod)))[0] + + dark_idx_oI = np.where((mL_fit < mass_bins[ii+1]) & + (mL_fit > mass_bins[ii]) & + (oIL_fit > oIL_mod))[0] + + lum_idx_oI = np.where((mL_fit < mass_bins[ii+1]) & + (mL_fit > mass_bins[ii]) & + (oIL_fit < oIL_mod))[0] + + # Classify based on joint Kp and ogleI + no_mass_idx = np.where((mL_fit < mass_bins[ii+1]) & + (mL_fit > mass_bins[ii]) & + (np.isnan(kpL_mod) | + np.isnan(oIL_mod)))[0] + + dark_idx = np.where((mL_fit < mass_bins[ii+1]) & + (mL_fit > mass_bins[ii]) & + ((kpL_fit > kpL_mod) | + (oIL_fit > oIL_mod)))[0] + + lum_idx = np.where((mL_fit < mass_bins[ii+1]) & + (mL_fit > mass_bins[ii]) & + ((kpL_fit < kpL_mod) & + (oIL_fit < oIL_mod)))[0] + + n_no_mass_kp[ii] = len(no_mass_idx_kp)/len(mL_fit) + n_dark_kp[ii] = len(dark_idx_kp)/len(mL_fit) + n_lum_kp[ii] = len(lum_idx_kp)/len(mL_fit) + + n_no_mass_oI[ii] = len(no_mass_idx_oI)/len(mL_fit) + n_dark_oI[ii] = len(dark_idx_oI)/len(mL_fit) + n_lum_oI[ii] = len(lum_idx_oI)/len(mL_fit) + + n_no_mass[ii] = len(no_mass_idx)/len(mL_fit) + n_dark[ii] = len(dark_idx)/len(mL_fit) + n_lum[ii] = len(lum_idx)/len(mL_fit) + + if plot: + # Individual filters + fig, ax = plt.subplots(2, 1, num=1, figsize=(6, 6), sharex='col') + plt.clf() + fig, ax = plt.subplots(2, 1, num=1, figsize=(6, 6), sharex='col') + plt.subplots_adjust(hspace=0.05) + ax[0].bar(mass_bin_centers, n_no_mass_kp, bin_width, + label='Dark$_A$ ({0:.0f}%)'.format(100*p_no_mass_match_kp), color='gray', + hatch='++', edgecolor='k') + ax[0].bar(mass_bin_centers, n_dark_kp, bin_width, bottom=n_no_mass_kp, + label='Dark$_B$ ({0:.0f}%)'.format(100*p_dark_kp), color='gray', + hatch='xx', edgecolor='k') + ax[0].bar(mass_bin_centers, n_lum_kp, bin_width, bottom=n_no_mass_kp+n_dark_kp, + label='Lum. ({0:.0f}%)'.format(100*p_lum_kp), color='red', edgecolor='k') + #ax[0].legend(loc='upper right') + ax[0].legend() + ax[0].set_ylabel('Prob. (Kp)') + ax[0].set_title(target.upper() + ' - ' + mode) + plt.show() + + ax[1].bar(mass_bin_centers, n_no_mass_oI, bin_width, + label='Dark$_A$ ({0:.0f}%)'.format(100*p_no_mass_match_oI), color='gray', + hatch='++', edgecolor='k') + ax[1].bar(mass_bin_centers, n_dark_oI, bin_width, bottom=n_no_mass_oI, + label='Dark$_B$ ({0:.0f}%)'.format(100*p_dark_oI), color='gray', + hatch='xx', edgecolor='k') + ax[1].bar(mass_bin_centers, n_lum_oI, bin_width, bottom=n_no_mass_oI+n_dark_oI, + label='Lum. ({0:.0f}%)'.format(100*p_lum_oI), color='red', edgecolor='k') + #ax[1].legend(loc='upper right') + ax[1].legend() + ax[1].set_ylabel('Prob. (I)') + ax[1].set_xlabel('Lens mass ($M_\odot$)') + + ax[0].set_xscale('log') + ax[1].set_xscale('log') + + plt.savefig(paper_dir + target + '_dark_lens_prob_' + str(mode) + '.png') + plt.show() + + # Joint (2 filters) + plt.figure(3) + plt.clf() + plt.bar(mass_bin_centers, n_no_mass, bin_width, + label='Dark$_A$ ({0:.0f}%)'.format(100*p_no_mass_match), color='gray', + hatch='++', edgecolor='k') + plt.bar(mass_bin_centers, n_dark, bin_width, bottom=n_no_mass, + label='Dark$_B$ ({0:.0f}%)'.format(100*p_dark), color='gray', + hatch='xx', edgecolor='k') + plt.bar(mass_bin_centers, n_lum, bin_width, bottom=n_no_mass+n_dark, + label='Lum. ({0:.0f}%)'.format(100*p_lum), color='red', edgecolor='k') + plt.legend() + plt.ylabel('Prob.') + plt.xlabel('Lens mass ($M_\odot$)') + plt.title(target.upper() + ' - ' + mode) + + # if target == 'ob150211': + plt.gca().set_xscale('log') + + plt.savefig(paper_dir + target + '_dark_lens_prob_joint_' + str(mode) + '.png') + plt.show() + + + # Age histogram + plt.figure(2) + plt.clf() + plt.hist(age_mod, bins=np.arange(6, 10.51, 0.5)) + plt.yscale('log') + plt.xlabel('logage') + plt.ylabel('number') + plt.title(target + ' star age distribution') + plt.savefig(paper_dir + target + '_star_age_distribution_' + str(mode) + '.png') + + ########## + # Calculate probabilites + ########## + print(f'*** MODE = {mode} ***') + + # Kp + star_idx_kp = np.where(kpL_fit <= kpL_mod)[0] + + bd_mass1_idx_kp = np.where((mL_fit <= 0.1) & + (mL_fit > 0) & + (np.isnan(kpL_mod)))[0] + + bd_mass2_idx_kp = np.where((mL_fit <= 0.1) & + (mL_fit > 0) & + (kpL_fit > kpL_mod))[0] + + wd_mass1_idx_kp = np.where((mL_fit <= 1.2) & + (mL_fit > 0.1) & + (np.isnan(kpL_mod)))[0] + + wd_mass2_idx_kp = np.where((mL_fit <= 1.2) & + (mL_fit > 0.1) & + (kpL_fit > kpL_mod))[0] + + ns_mass1_idx_kp = np.where((mL_fit <= 2.2) & + (mL_fit > 1.2) & + (np.isnan(kpL_mod)))[0] + + ns_mass2_idx_kp = np.where((mL_fit <= 2.2) & + (mL_fit > 1.2) & + (kpL_fit > kpL_mod))[0] + + bh_mass1_idx_kp = np.where((mL_fit > 2.2) & + (np.isnan(kpL_mod)))[0] + + bh_mass2_idx_kp = np.where((mL_fit > 2.2) & + (kpL_fit > kpL_mod))[0] + + p_st_kp = 100*len(star_idx_kp)/len(mL_fit) + p_bd_kp = 100*(len(bd_mass1_idx_kp) + len(bd_mass2_idx_kp))/len(mL_fit) + p_wd_kp = 100*(len(wd_mass1_idx_kp) + len(wd_mass2_idx_kp))/len(mL_fit) + p_ns_kp = 100*(len(ns_mass1_idx_kp) + len(ns_mass2_idx_kp))/len(mL_fit) + p_bh_kp = 100*(len(bh_mass1_idx_kp) + len(bh_mass2_idx_kp))/len(mL_fit) + + print('') + print('** Kp Probabilities **') + print('Kp P_total = {0:.0f}'.format(p_st_kp + p_bd_kp + p_wd_kp + p_ns_kp + p_bh_kp)) + print('Kp P(Star) = {0:.0f}'.format(p_st_kp)) + print('Kp P(BD) = {0:.0f}'.format(p_bd_kp)) + print('Kp P(WD) = {0:.0f}'.format(p_wd_kp)) + print('Kp P(NS) = {0:.0f}'.format(p_ns_kp)) + print('Kp P(BH) = {0:.0f}'.format(p_bh_kp)) + + # OGLE I + star_idx_oI = np.where(oIL_fit <= oIL_mod)[0] + + bd_mass1_idx_oI = np.where((mL_fit > 0) & + (mL_fit <= 0.2) & + (np.isnan(oIL_mod)))[0] + + bd_mass2_idx_oI = np.where((mL_fit > 0) & + (mL_fit <= 0.2) & + (oIL_fit > oIL_mod))[0] + + wd_mass1_idx_oI = np.where((mL_fit > 0.2) & + (mL_fit <= 1.2) & + (np.isnan(oIL_mod)))[0] + + wd_mass2_idx_oI = np.where((mL_fit > 0.2) & + (mL_fit <= 1.2) & + (oIL_fit > oIL_mod))[0] + + ns_mass1_idx_oI = np.where((mL_fit <= 2.2) & + (mL_fit > 1.2) & + (np.isnan(oIL_mod)))[0] + + ns_mass2_idx_oI = np.where((mL_fit <= 2.2) & + (mL_fit >= 1.2) & + (oIL_fit > oIL_mod))[0] + + bh_mass1_idx_oI = np.where((mL_fit > 2.2) & + (np.isnan(oIL_mod)))[0] + + bh_mass2_idx_oI = np.where((mL_fit > 2.2) & + (oIL_fit > oIL_mod))[0] + + p_st_oI = 100*len(star_idx_oI)/len(mL_fit) + p_bd_oI = 100*(len(bd_mass1_idx_oI) + len(bd_mass2_idx_oI))/len(mL_fit) + p_wd_oI = 100*(len(wd_mass1_idx_oI) + len(wd_mass2_idx_oI))/len(mL_fit) + p_ns_oI = 100*(len(ns_mass1_idx_oI) + len(ns_mass2_idx_oI))/len(mL_fit) + p_bh_oI = 100*(len(bh_mass1_idx_oI) + len(bh_mass2_idx_oI))/len(mL_fit) + + print('') + print('** I Probabilities **') + print('I P_total = {0:.0f}'.format(p_st_oI + p_bd_oI + p_wd_oI + p_ns_oI + p_bh_oI)) + print('I P(Star) = {0:.0f}'.format(p_st_oI)) + print('I P(BD) = {0:.0f}'.format(p_bd_oI)) + print('I P(WD) = {0:.0f}'.format(p_wd_oI)) + print('I P(NS) = {0:.0f}'.format(p_ns_oI)) + print('I P(BH) = {0:.0f}'.format(p_bh_oI)) + + # Joint filter analysis. + star_idx = np.where((kpL_fit <= kpL_mod) & (oIL_fit <= oIL_mod))[0] + + bd_mass1_idx = np.where((mL_fit <= 0.2) & + (mL_fit > 0) & + (np.isnan(kpL_mod) | + np.isnan(oIL_mod)))[0] + + bd_mass2_idx = np.where((mL_fit <= 0.2) & + (mL_fit > 0) & + ((kpL_fit > kpL_mod) | + (oIL_fit > oIL_mod)))[0] + + wd_mass1_idx = np.where((mL_fit <= 1.2) & + (mL_fit > 0.2) & + (np.isnan(kpL_mod) | + np.isnan(oIL_mod)))[0] + + wd_mass2_idx = np.where((mL_fit <= 1.2) & + (mL_fit > 0.2) & + ((kpL_fit > kpL_mod) | + (oIL_fit > oIL_mod)))[0] + + ns_mass1_idx = np.where((mL_fit <= 2.2) & + (mL_fit > 1.2) & + (np.isnan(kpL_mod) | + np.isnan(oIL_mod)))[0] + + ns_mass2_idx = np.where((mL_fit <= 2.2) & + (mL_fit > 1.2) & + ((kpL_fit > kpL_mod) | + (oIL_fit > oIL_mod)))[0] + + bh_mass1_idx = np.where((mL_fit > 2.2) & + (np.isnan(kpL_mod) | + np.isnan(oIL_mod)))[0] + + bh_mass2_idx = np.where((mL_fit > 2.2) & + ((kpL_fit > kpL_mod) | + (oIL_fit > oIL_mod)))[0] + + p_st = 100*len(star_idx)/len(mL_fit) + p_bd = 100*(len(bd_mass1_idx) + len(bd_mass2_idx))/len(mL_fit) + p_wd = 100*(len(wd_mass1_idx) + len(wd_mass2_idx))/len(mL_fit) + p_ns = 100*(len(ns_mass1_idx) + len(ns_mass2_idx))/len(mL_fit) + p_bh = 100*(len(bh_mass1_idx) + len(bh_mass2_idx))/len(mL_fit) + + print('') + print('** Kp and I Probabilities **') + print('Kp and oI P_total = {0:.0f}'.format(p_st + p_bd + p_wd + p_ns + p_bh)) + print('Kp and oI P(Star) = {0:.0f}'.format(p_st)) + print('Kp and oI P(BD) = {0:.0f}'.format(p_bd)) + print('Kp and oI P(WD) = {0:.0f}'.format(p_wd)) + print('Kp and oI P(NS) = {0:.0f}'.format(p_ns)) + print('Kp and oI P(BH) = {0:.0f}'.format(p_bh)) + + + n_age10 = len(np.where(age_mod == 10)[0]) + p_age10 = 100 * n_age10/len(age_mod) + + n_age95 = len(np.where(age_mod == 9.5)[0]) + p_age95 = 100 * n_age95/len(age_mod) + + n_age9 = len(np.where(age_mod == 9)[0]) + p_age9 = 100 * n_age9/len(age_mod) + + n_age85 = len(np.where(age_mod == 8.5)[0]) + p_age85 = 100 * n_age85/len(age_mod) + + n_age8 = len(np.where(age_mod == 8)[0]) + p_age8 = 100 * n_age8/len(age_mod) + + print('Percent with logage 10 : ', p_age10) + print('Percent with logage 9.5 : ', p_age95) + print('Percent with logage 9 : ', p_age9) + print('Percent with logage 8.5 : ', p_age85) + print('Percent with logage 8 : ', p_age8) + + return (p_st_kp, p_st_oI, p_st, + p_bd_kp, p_bd_kp, p_bd, + p_wd_kp, p_wd_kp, p_wd, + p_ns_oI, p_ns_oI, p_ns, + p_bh_oI, p_bh_oI, p_bh) + + +def make_lens_probability_table(): + # Delete old file if exists + table_file = paper_dir + 'lens_type_prob.txt' + if os.path.exists(table_file): + os.remove(table_file) + + with open(table_file, 'a+') as tb: + # for targ in targets: + for targ in ['ob120169', 'ob140613', 'ob150029', 'ob150211']: + foo = dark_lens_prob(targ, plot=False) + p_st_kp = foo[0] + p_st_oI = foo[1] + p_st = foo[2] + p_bd_kp = foo[3] + p_bd_oI = foo[4] + p_bd = foo[5] + p_wd_kp = foo[6] + p_wd_oI = foo[7] + p_wd = foo[8] + p_ns_kp = foo[9] + p_ns_oI = foo[10] + p_ns = foo[11] + p_bh_kp = foo[12] + p_bh_oI = foo[13] + p_bh = foo[14] + + tb.write('{0} & {1:.0f} & {2:.0f} & {3:.0f} & {4:.0f} & {5:.0f} & {6:.0f} & {7:.0f} & ' \ + '{8:.0f} & {9:.0f} & {10:.0f} \\\ \n'.format(targ, p_st_kp, p_st_oI, + p_bd_kp, p_bd_oI, + p_wd_kp, p_wd_oI, + p_ns_kp, p_ns_oI, + p_bh_kp, p_bh_oI)) + + # Delete old file if exists + table_file = paper_dir + 'lens_type_prob_avg.txt' + if os.path.exists(table_file): + os.remove(table_file) + + with open(table_file, 'a+') as tb: + # for targ in targets: + for targ in ['ob120169', 'ob140613', 'ob150029', 'ob150211']: + foo = dark_lens_prob(targ, plot=False) + p_st_kp = foo[0] + p_st_oI = foo[1] + p_bd_kp = foo[2] + p_wd_kp = foo[3] + p_ns_kp = foo[4] + p_bh_kp = foo[5] + p_bd_oI = foo[6] + p_wd_oI = foo[7] + p_ns_oI = foo[8] + p_bh_oI = foo[9] + + tb.write('{0} & {1:.0f} & {2:.0f} & {3:.0f} & ' \ + '{4:.0f} & {5:.0f} \\\ \n'.format(targ, (p_st_kp + p_st_oI)/2.0, + (p_bd_kp + p_bd_oI)/2.0, + (p_wd_kp + p_wd_oI)/2.0, + (p_ns_kp + p_ns_oI)/2.0, + (p_bh_kp + p_bh_oI)/2.0)) + + return + +# def elppd(target): +# targets = ['ob120169', 'ob140613', 'ob150029', 'ob150211'] + +# for targ in targets: +# import warnings +# warnings.simplefilter(action='ignore', category=FutureWarning) + +# fitter, data = get_data_and_fitter(pspl_ast_multiphot[target]) +# stats = calc_summary_statistics(fitter) +# tab = fitter.load_mnest_modes() + +# # Loop through each of the modes for this target +# # and calculate the ELPPD. +# for mode in range(len(stats)): +# # Make an EQUAL WEIGHT POSTERIOR sample +# sampls = tab[mode] +# samp_idx = np.random.choice(np.arange(len(sampls['weights'])), +# size=5000, replace=False, p=sampls['weights']) +# resamp = sampls[samp_idx] + +# # Number of samples. +# nsamp = len(resamp) + +# # Get RA and Dec of target. +# raL, decL = data['raL'], data['decL'] + +# # Initialize an array to store the pointwise LOG likelihood samples. +# # Each row corresponds to a posterior sample, and so +# # pw_logL_arr[s].sum() gives the total logL for the s-th posterior sample. +# # The number of rows equals the number of posterior samples. +# # Each column corresponds to a data point (i.e. time), and so the length +# # of each row equals the number of data points. +# pw_logL_arr = np.zeros((len(ramp), len(data['t_phot1']))) + +# # Fill out the table by looping over posterior samples. +# for sdx, samp in enumerate(t): +# print('Sample number ', sdx) +# params = t[t.colnames[:21]][sdx] +# params_dict = model_fitter.generate_params_dict(params, fit.fitter_param_names) +# mod = fit.model_class(*params_dict.values(), +# raL=raL, +# decL=decL) +# pw_logL = model_fitter.pointwise_likelihood(fit.data, mod, filt_idx=0) +# pw_logL_arr[sdx] = pw_logL + +# np.savetxt(targ + '.txt', pw_logL_arr) +# pdb.set_trace() +# # Calculate the LIKELIHOOD (not log) by exponentiating. +# pw_L_arr = np.exp(pw_logL_arr) + +# # Sum over the pointwise likelihood estimates. +# # pw_logL_arr.sum(axis=0).shape = number of data points (since summed over samples) +# pw_L_arr_sampsum = pw_L_arr.sum(axis=0) +# pw_logL_arr_sampsum = pw_logL_arr.sum(axis=0) + +# elppd = 2 * pw_logL_arr_sampsum.sum()/nsamp - np.log(pw_L_arr_sampsum/nsamp).sum() + +# print(targ) +# print('elppd = ', elppd) + +# return + + +def dark_lens_prob_bad_age(target): + """ + Use a Galaxia EBF file to estimate an age distribution. Then + sample from that age distribution, make synthetic stellar populations + using SPISEA, and check which ones hold up against our light-curve + fitting results. + """ + # Load up microlensing fits (joint phot + astrom). + # Also fetch our best fit and figure out the source and lens/neighbor + # brightness. + foo = get_data_fitter_params_models_samples('ob150211', return_mode = 'best') + fitter = foo[0] + data = foo[1] + stats = foo[2] + params = foo[3] + models = foo[4] + sampls = foo[5] + + sampls['weights'] /= sampls['weights'].sum() + + # Get rid of negative blending which leads to nan + # for lens magnitude and replace them with 0.9999 (i.e. super close to 1). + bsff2_idx = np.where(sampls['b_sff2'] > 1)[0] + sampls['b_sff2'][bsff2_idx] = 0.999999 + + # Lens fit values + dL_fit = 1 / sampls['piL'] + mL_fit = sampls['mL'] + kpL_fit = sampls['mag_base2'] + 2.5*np.log10(1/(1 - sampls['b_sff2'])) + ogleL_fit = sampls['mag_base1'] + 2.5*np.log10(1/(1 - sampls['b_sff1'])) + + # Setup some target-specific details + dL_arr_list = {'ob120169': np.arange(4.0, 12.01, 0.5), + 'ob140613': np.arange(4.0, 12.01, 0.5), + 'ob150029': np.arange(4.0, 12.01, 0.5), + 'ob150211': np.arange(4.0, 12.01, 0.5) + } + right_list = {'ob120169': None, + 'ob140613': None, + 'ob150029': None, + 'ob150211': None + } + top_list = {'ob120169': None, + 'ob140613': None, + 'ob150029': None, + 'ob150211': None + } + bottom_list = {'ob120169': None, + 'ob140613': None, + 'ob150029': None, + 'ob150211': None + } + ebf_list = {'ob120169': None, + 'ob140613': None, + 'ob150029': None, + 'ob150211': '/u/jlu/work/microlens/OB150211/current/notes/ob150211.ebf' + } + + ########## + # Define isochrone parameters. Use the age distribution from the EBF file. + ########## + sim = ebf.read(ebf_list[target], '/') + + # We will step through this list of distances. + dL_arr_edge = dL_arr_list[target] + dL_arr = dL_arr_edge[:-1] + (np.diff(dL_arr_edge) / 2.0) + + coords_arr = SkyCoord(data['raL'] * u.deg, + data['decL'] * u.deg, + distance = dL_arr * u.kpc, frame='icrs') + + import dustmaps.marshall + from dustmaps.marshall import MarshallQuery + from spisea import synthetic, evolution, atmospheres, reddening #, ifmr + from spisea.imf import imf #, multiplicity + + # Fetch the extinction at each distance. + dustmaps.marshall.fetch() + q = MarshallQuery() + AKs_arr = q(coords_arr) + + # Define evolution/atmosphere models and extinction law + evo_model = evolution.MISTv1() + atm_func = atmospheres.get_merged_atmosphere + red_law = reddening.RedLawDamineli16() + # IMF power law boundaries. changed start from 0.08 to 0.1 because of MIST. + mass_limits = np.array([0.1, 0.5, 120]) + # IMF powers + powers = np.array([-1.3, -2.3]) + # Cluster mass + cluster_mass = 1E4 + + # Take a random sample of the lens fits (weighted) + samp_idx = np.random.choice(np.arange(len(sampls['weights'])), + size=1000, replace=False, p=sampls['weights']) + + dL_fit = dL_fit[samp_idx] + mL_fit = mL_fit[samp_idx] + kpL_fit = kpL_fit[samp_idx] + ogleL_fit = ogleL_fit[samp_idx] + + # Only keep things within dL bin + # FIXME: Change this ST we won't need this line. + keep_idx = np.where((dL_fit > dL_arr[0]) & + (dL_fit < dL_arr[-1]))[0] + + print('len(keep_idx) = ', len(keep_idx)) + dL_fit = dL_fit[keep_idx] + mL_fit = mL_fit[keep_idx] + kpL_fit = kpL_fit[keep_idx] + kpL_mod = np.zeros(len(keep_idx)) + ogleL_fit = ogleL_fit[keep_idx] + ogleL_mod = np.zeros(len(keep_idx)) + log_age_mod = np.zeros(len(keep_idx)) + + # We will simulate a population over a grid of fit points and age. + # For each fit point, we will try all the age bins. + # Here are the age bins. + age_bin_delta = 0.5 + age_bin_cents = np.arange(7, 10.01, age_bin_delta) + age_bin_edges = age_bin_cents + (age_bin_delta / 2.0) + age_bin_edges = np.insert(age_bin_edges, 0, age_bin_cents[0] - (age_bin_delta / 2.0)) + print(f'age_bin_edges = {age_bin_edges}') + + # Now expand the arrays to have 2D = [N_fit_points, N_age_bins] + + # Sort the dL into the defined distance bins + bin_idx = np.digitize(dL_fit, dL_arr_edge) + + # Loop through each distance bin. + for ii in np.arange(len(dL_arr)): + + # Select PopSyCLE stars in this radius bin. + sdx = np.where((sim['rad'] >= dL_arr_edge[ii]) & (sim['rad'] < dL_arr_edge[ii+1]))[0] + + age_hist, age_be = np.histogram(sim['age'], bins=age_bin_edges) + age_hist /= age_hist.sum() # normalize + age_idx = np.random.choice(np.arange(len(age_bin_cents)), + size=100, replace=False, p=age_hist) + + # Draw the logAge from PopSyCLE, round to the nearest delta-logAge=0.5 so we don't + # make too many isochrones (expensive). + logAge = np.random.choice(sim['age'][sdx]) + logAge = round(logAge * 2) / 2 # Rounds to the nearest 0.5 or 1.0 + + bin_ii_idx = np.where(bin_idx == ii+1)[0] + dL = dL_arr[ii] + AKs = AKs_arr[ii] + + # Make Isochrone object. Note that is calculation will take a few minutes, unless the + # isochrone has been generated previously. + print(f'Making isochrone: dist={dL:.2f} kpc, logAge={logAge:.2f}, AKs={AKs:.2f}') + my_iso = synthetic.IsochronePhot(logAge, AKs, dL*1000, metallicity=0, + evo_model=evo_model, atm_func=atm_func, + red_law=red_law, filters=['ubv,I', 'nirc2,Kp'], + recomp=True, + iso_dir=paper_dir + 'iso/') + + # define IMF + trunc_kroupa = imf.IMF_broken_powerlaw(mass_limits, powers) + + # make cluster + cluster = synthetic.ResolvedCluster(my_iso, trunc_kroupa, cluster_mass, seed=1) + output = cluster.star_systems + print('max mass = ', output['mass'].max()) + if np.isnan(output['m_nirc2_Kp']).sum() > 0: + pdb.set_trace() + + # plt.figure(3) + # plt.clf() + # plt.plot(output['mass'], output['m_nirc2_Kp'], 'k.', label='model,Kp') + # plt.plot(output['mass'], output['m_ubv_I'], 'b.', label='model,I') + + # For each star in this particular distance bin... + # Figure out which mass bins + for jj in bin_ii_idx: + idx = np.where((output['mass'] < mL_fit[jj] + 0.1) & + (output['mass'] > mL_fit[jj] - 0.1))[0] + + if len(idx) == 0: + kpL_mod[jj] = np.nan + ogleL_mod[jj] = np.nan + log_age_mod[jj] = np.nan + else: + kpL_mod[jj] = output['m_nirc2_Kp'][idx].min() + ogleL_mod[jj] = output['m_ubv_I'][idx].min() + log_age_mod[jj] = logAge + + # plt.plot(mL_fit[bin_ii_idx], kpL_mod[bin_ii_idx], 'rs', label='fit, Kp') + # plt.plot(mL_fit[bin_ii_idx], ogleL_mod[bin_ii_idx], 'cs', label='fit, I') + # plt.xscale('log') + # plt.legend() + # plt.xlabel('mass') + # plt.ylabel('Kp or I (mag)') + # plt.show() + + + plt.close(1) + fig, ax = plt.subplots(1, 3, num=1, figsize=(18, 6)) + # plt.clf() + plt.subplots_adjust(wspace=0.27, left=0.08, right=0.98, top=0.93) + ax[0].scatter(dL_fit, mL_fit, c=mL_fit, alpha=0.5, cmap='viridis') + model_fitter.contour2d_alpha(1/sampls['piL'], sampls['mL'], weights=sampls['weights'], + ax=ax[0], color='k', + plot_density=False, sigma_levels=[1, 2, 3]) + ax[0].set_xlabel('$d_L$ [kpc]') + ax[0].set_ylabel('$M_L [M_\odot]$') + ax[0].set_title(target.upper()) + if right_list[target] is not None: + ax[0].set_xlim(right=right_list[target]) + if top_list[target] is not None: + ax[0].set_ylim(top=top_list[target]) + if bottom_list[target] is not None: + ax[0].set_ylim(bottom=bottom_list[target]) + + max1 = np.nanmax(kpL_mod) + max2 = np.nanmax(kpL_fit) + min1 = np.nanmin(kpL_mod) + min2 = np.nanmin(kpL_fit) + max = np.max([max1, max2]) + min = np.min([min1, min2]) + ax[1].set_xlabel('$Kp_L$ ($d_L$, $M_L$, $\\bigstar$) [mag]') + ax[1].set_ylabel('$Kp_L$ ($b_{SFF}$, $m_{base}$) [mag]') + ax[1].set_title('Kp') + ax[1].plot([min, max], [min, max], color='gray') + ax[1].fill_between(x=[min, max], y1=[max, max], y2=[min, max], color='gray', alpha=0.3) + ax[1].scatter(kpL_mod, kpL_fit, c=mL_fit, alpha=0.5, cmap='viridis') + ax[1].invert_yaxis() + plt.text(0.6, 0.1, + 'Dark Lens', + transform=ax[1].transAxes) + plt.text(0.5, 0.9, 'P(dark lens) = {0:.0f}%'.format(100*len(np.where(kpL_fit > kpL_mod)[0])/len(kpL_fit)), + transform=ax[1].transAxes, + ha='center') + ax[1].axis('equal') + + + max1 = np.nanmax(ogleL_mod) + max2 = np.nanmax(ogleL_fit) + min1 = np.nanmin(ogleL_mod) + min2 = np.nanmin(ogleL_fit) + max = np.max([max1, max2]) + min = np.min([min1, min2]) + ax[2].set_xlabel('$I_L$ ($d_L$, $M_L$, $\\bigstar$) [mag]') + ax[2].set_ylabel('$I_L$ ($b_{SFF}$, $m_{base}$) [mag]') + ax[2].set_title('OGLE I') + ax[2].plot([min, max], [min, max], color='gray') + ax[2].fill_between(x=[min, max], y1=[max, max], y2=[min, max], color='gray', alpha=0.3) + ax[2].scatter(ogleL_mod, ogleL_fit, c=mL_fit, alpha=0.5, cmap='viridis') + ax[2].invert_yaxis() + plt.text(0.6, 0.1, + 'Dark Lens', + transform=ax[2].transAxes) + plt.text(0.5, 0.9, 'P(dark lens) = {0:.0f}%'.format(100*len(np.where(ogleL_fit > ogleL_mod)[0])/len(ogleL_fit)), + transform=ax[2].transAxes, + ha='center') + ax[2].axis('equal') + + plt.savefig(paper_dir + target + '_dark_lens_prob.png') + + print(len(np.where(kpL_fit > kpL_mod)[0])) + print(len(kpL_fit)) + print('Probability of dark lens (KP): {0:.0f}%'.format(100*len(np.where(kpL_fit > kpL_mod)[0])/len(kpL_fit))) + + print(len(np.where(ogleL_fit > ogleL_mod)[0])) + print(len(ogleL_fit)) + print('Probability of dark lens (I): {0:.0f}%'.format(100*len(np.where(ogleL_fit > ogleL_mod)[0])/len(ogleL_fit))) + + return + + +def calc_blending_kp(): + """ + Read in a NIRC2 catalog and add up the flux + from all the sources that are within 1.3" from + the target. This should match the b_sff derived + from the fits. + """ + scale = 0.00995 # arcsec / pixel + + # Read in a NIRC2 starlist (high-ish quality) + nirc2_lis = '/g/lu/data/microlens/17jun05/combo/starfinder/' + nirc2_lis += 'mag17jun05_ob150211_kp_rms_named.lis' + + foo = starlists.read_starlist(nirc2_lis, error=True) + + # Find the target + tdx = np.where(foo['name'] == 'ob150211')[0][0] + + # Calculate the distance from the target for each star + r2d = np.hypot(foo['x'] - foo['x'][tdx], + foo['y'] - foo['y'][tdx]) + r2d *= scale + + foo['r2d'] = r2d + + # Find those targets within the OGLE aperture + rdx = np.where(r2d < 1.5)[0] + print(foo[rdx]) + + # Calculate the source flux fraction assuming + # that the lens is dark. + f_src_lens = foo['flux'][tdx] + f_neighbors = foo['flux'][rdx[1:]].sum() + f_total = f_src_lens + f_neighbors + + print('f_src_lens = ', f_src_lens) + print('f_neighbors = ', f_neighbors) + print('f_total = ', f_total) + print('') + print('f_N / f_tot = {0:.2f}'.format( f_neighbors / f_total)) + print('(f_S + f_L) / f_tot = {0:.2f}'.format( f_src_lens / f_total)) + + b_sff = foo['flux'][tdx] / (foo['flux'][rdx].sum()) + print('b_sff = {0:.2f}'.format( b_sff )) + + fit_b_sff = 0.90 + + f_lens = f_src_lens - (fit_b_sff * f_total) + print('f_lens = ', f_lens) + f_src = f_src_lens - f_lens + print('f_src = ', f_src) + + print('f_S / (f_S + f_L) = {0:.2f}'.format(f_src / f_src_lens)) + + + return + + +def plot_lens_geometry(target, axis_lim_scale=3, vel_scale=0.05): + """ + target : str + Target name (lower case). + axis_lim_scale : float + Axis limits in units of thetaE + vel_scale : float + Scale factor for the velocity arrows. + """ + + + fitter, data = get_data_and_fitter(pspl_ast_multiphot[target]) + mod_all = fitter.get_best_fit_modes_model(def_best = 'median') + mode = pspl_ast_multiphot_mode[target] + mod = mod_all[mode] + + print('tE = {0:5.2f} days'.format(mod.tE)) + print('piE = {0:5.2f} = {1:5.2f}'.format(mod.piRel / mod.thetaE_amp, mod.piE_amp)) + print('vec_piE = [{0:5.2f}, {1:5.2f}]'.format(mod.piE[0], mod.piE[1])) + print('xL0 = [{0:7.4f}, {1:7.4f}] asec'.format(mod.xL0[0], mod.xL0[1])) + print('xS0 = [{0:7.4f}, {1:7.4f}] asec'.format(mod.xS0[0], mod.xS0[1])) + print('muL = [{0:7.4f}, {1:7.4f}] mas/yr'.format(mod.muL[0], mod.muL[1])) + print('muS = [{0:7.4f}, {1:7.4f}] mas/yr'.format(mod.muS[0], mod.muS[1])) + print('thetaE = |{1:6.3f}, {2:6.3f}| mas = {0:6.3f} mas'.format(mod.thetaE_amp, + mod.thetaE[0], + mod.thetaE[1])) + print('thetaS0 = |{0:7.4f}, {1:7.4f}| mas = {2:7.4f} mas'.format(mod.thetaS0[0], + mod.thetaS0[1], + mod.beta)) + print('muRel = |{0:7.4f}, {1:7.4f}| mas/yr = {2:7.4f} mas/yr'.format(mod.muRel[0], + mod.muRel[1], + mod.muRel_amp)) + print('u0 = {0:6.2f}'.format(mod.u0_amp)) + print('piRel = {0:7.4f} mas'.format(mod.piRel)) + print('dL = {0:7.1f} pc'.format(mod.dL)) + print('dS = {0:7.1f} pc'.format(mod.dS)) + + # Time samples for all curves. + t_obs = np.arange(mod.t0 - 1000, mod.t0 + 1000, 10) + + # Parallax vector (normalized to 1). + parallax_vec = parallax.parallax_in_direction(mod.raL, mod.decL, t_obs) + + # Astrometry of the unlensed source in (1) geo, (2) helio system + xS_unlens_geo = mod.get_astrometry_unlensed(t_obs) + xS_unlens_sun = xS_unlens_geo - (mod.piS * parallax_vec) * 1e-3 # arcsec + + # Astrometry of the lens in (1) geo, (2) helio system + xL_unlens_geo = mod.get_lens_astrometry(t_obs) + xL_unlens_sun = xL_unlens_geo - (mod.piL * parallax_vec) * 1e-3 + + # Astrometry of the source in the heliocentric lens rest frame as seen from (1) geo, (2) helio + xS_restL0_geo = xS_unlens_geo - mod.xL0 + xS_restL0_sun = xS_unlens_sun - mod.xL0 + + tidx = np.argmin(np.abs(t_obs - mod.t0)) + + # Fix up all positions to be relative to the source location (no parallax) + # at time t0. + xL_ref = xL_unlens_sun[tidx, :] + + xS_unlens_geo -= xL_ref + xS_unlens_sun -= xL_ref + xL_unlens_geo -= xL_ref + xL_unlens_sun -= xL_ref + + # Plot params + arr_head_len = 0.1 + arr_head_wid = 0.1 + arrow_width = 0.02 + + + ########## + # Geocentric plot + ########## + plt.close(1) + plt.figure(1) + plt.clf() + cir = plt.Circle((xL_unlens_geo[tidx, 0]*1e3, + xL_unlens_geo[tidx, 1]*1e3), + mod.thetaE_amp, + color='grey', fill=False) + plt.gca().add_artist(cir) + plt.plot([xL_unlens_geo[tidx, 0]*1e3], [xL_unlens_geo[tidx, 1]*1e3], 'ko') + plt.plot([xS_unlens_geo[tidx, 0]*1e3], [xS_unlens_geo[tidx, 1]*1e3], 'r*') + plt.arrow(xL_unlens_geo[tidx, 0]*1e3, xL_unlens_geo[tidx, 1]*1e3, + mod.muL[0]*vel_scale, mod.muL[1]*vel_scale, + width=arrow_width, head_width=arr_head_wid, head_length=arr_head_len, fc='k', ec='k') + plt.arrow(xS_unlens_geo[tidx, 0]*1e3, xS_unlens_geo[tidx, 1]*1e3, + mod.muS[0]*vel_scale, mod.muS[1]*vel_scale, + width=arrow_width, head_width=arr_head_wid, head_length=arr_head_len, fc='r', ec='r') + plt.plot(xS_unlens_geo[:,0]*1e3, xS_unlens_geo[:,1]*1e3, 'r--', label='Src, unlensed') + plt.plot(xL_unlens_geo[:,0]*1e3, xL_unlens_geo[:,1]*1e3, 'k--', label='Lens') + plt.xlabel(r'$\Delta\alpha^*$ (mas)') + plt.ylabel(r'$\Delta\delta$ (mas)') + plt.axis('equal') + plt.gca().invert_xaxis() + # xlim_lo = xL_unlens_geo[tidx, 0]*1e3 + mod.thetaE_amp * axis_lim_scale + # xlim_hi = xL_unlens_geo[tidx, 0]*1e3 - mod.thetaE_amp * axis_lim_scale + # ylim_lo = xL_unlens_geo[tidx, 1]*1e3 - mod.thetaE_amp * axis_lim_scale + # ylim_hi = xL_unlens_geo[tidx, 1]*1e3 + mod.thetaE_amp * axis_lim_scale + half_lim = 5 # mas + xlim_lo = xL_unlens_geo[tidx, 0]*1e3 + half_lim * axis_lim_scale + xlim_hi = xL_unlens_geo[tidx, 0]*1e3 - half_lim * axis_lim_scale + ylim_lo = xL_unlens_geo[tidx, 1]*1e3 - half_lim * axis_lim_scale + ylim_hi = xL_unlens_geo[tidx, 1]*1e3 + half_lim * axis_lim_scale + plt.xlim(xlim_lo, xlim_hi) + plt.ylim(ylim_lo, ylim_hi) + plt.gca().xaxis.set_major_locator(plt.MultipleLocator(1)) + plt.gca().yaxis.set_major_locator(plt.MultipleLocator(1)) + plt.legend() + plt.title(target.upper()) + plt.savefig(paper_dir + 'geometry_geo_' + target + '.png') + + ########## + # Geocentric plot + ########## + plt.close(2) + plt.figure(2) + plt.clf() + cir = plt.Circle((xL_unlens_sun[tidx, 0]*1e3, + xL_unlens_sun[tidx, 1]*1e3), + mod.thetaE_amp, + color='grey', fill=False) + plt.gca().add_artist(cir) + plt.plot([xL_unlens_sun[tidx, 0]*1e3], [xL_unlens_sun[tidx, 1]*1e3], 'ko') + plt.plot([xS_unlens_sun[tidx, 0]*1e3], [xS_unlens_sun[tidx, 1]*1e3], 'r*') + plt.arrow(xL_unlens_sun[tidx, 0]*1e3, xL_unlens_sun[tidx, 1]*1e3, + mod.muL[0]*vel_scale, mod.muL[1]*vel_scale, + width=arrow_width, head_width=arr_head_wid, head_length=arr_head_len, fc='k', ec='k') + plt.arrow(xS_unlens_sun[tidx, 0]*1e3, xS_unlens_sun[tidx, 1]*1e3, + mod.muS[0]*vel_scale, mod.muS[1]*vel_scale, + width=arrow_width, head_width=arr_head_wid, head_length=arr_head_len, fc='r', ec='r') + plt.plot(xS_unlens_sun[:,0]*1e3, xS_unlens_sun[:,1]*1e3, 'r--', label='Src, unlensed') + plt.plot(xL_unlens_sun[:,0]*1e3, xL_unlens_sun[:,1]*1e3, 'k--', label='Lens') + plt.xlabel(r'$\Delta\alpha^*$ (mas)') + plt.ylabel(r'$\Delta\delta$ (mas)') + plt.axis('equal') + plt.gca().invert_xaxis() + # xlim_lo = xL_unlens_sun[tidx, 0]*1e3 + mod.thetaE_amp * axis_lim_scale + # xlim_hi = xL_unlens_sun[tidx, 0]*1e3 - mod.thetaE_amp * axis_lim_scale + # ylim_lo = xL_unlens_sun[tidx, 1]*1e3 - mod.thetaE_amp * axis_lim_scale + # ylim_hi = xL_unlens_sun[tidx, 1]*1e3 + mod.thetaE_amp * axis_lim_scale + xlim_lo = xL_unlens_sun[tidx, 0]*1e3 + half_lim * axis_lim_scale + xlim_hi = xL_unlens_sun[tidx, 0]*1e3 - half_lim * axis_lim_scale + ylim_lo = xL_unlens_sun[tidx, 1]*1e3 - half_lim * axis_lim_scale + ylim_hi = xL_unlens_sun[tidx, 1]*1e3 + half_lim * axis_lim_scale + plt.xlim(xlim_lo, xlim_hi) + plt.ylim(ylim_lo, ylim_hi) + plt.gca().xaxis.set_major_locator(plt.MultipleLocator(1)) + plt.gca().yaxis.set_major_locator(plt.MultipleLocator(1)) + plt.legend() + plt.title(target.upper()) + plt.savefig(paper_dir + 'geometry_sun_' + target + '.png') + + return + +def compare_all_linear_motions(save_all=False): + """ + Plot and calculate the significance of the astrometric signal for each target. + See fit_velocities.py in jlu/microlens for more info. + Saves the calculations in a table. + + Parameters + ---------- + save_all : bool, optional + If True, all plots are saved. If False, only the figure of the off-peak + linear fit of the target is saved. + Default is False. + """ + from jlu.microlens import fit_velocities + + # Make directory to hold table and figures + out_dir = paper_dir+ 'compare_linear_motion' + if not os.path.exists(out_dir): + os.mkdir(out_dir) + + ret_dir = os.getcwd() + os.chdir(out_dir) + + targets = list(epochs.keys()) + objects = [] + signal = [] + average_deviation = np.zeros(len(targets)) + average_deviation_error = np.zeros(len(targets)) + all_chi2 = np.zeros(len(targets)) + all_chi2_red = np.zeros(len(targets)) + cut_chi2 = np.zeros(len(targets)) + cut_chi2_red = np.zeros(len(targets)) + + n = 1 + for t, target in enumerate(targets): + tab = fit_velocities.StarTable(target) + + average, var, all_chi2s, cut_chi2s = tab.compare_linear_motion(fign_start=n, + return_results=True, + save_all=save_all) + average_deviation[t] = average + average_deviation_error[t] = np.sqrt(var) + sig = np.abs(average_deviation[t] / average_deviation_error[t]) + signal.append("${:.1f}\sigma$ \\\\".format(sig)) + + all_chi2[t] = all_chi2s[0] + all_chi2_red[t] = all_chi2s[1] + cut_chi2[t] = cut_chi2s[0] + cut_chi2_red[t] = cut_chi2s[1] + + objects.append(target.upper()) + n += 3 + + av_dev = Column(data=average_deviation, name='$\overline{\Delta r}$', + format='{:.3f}', unit='mas') + av_deve = Column(data=average_deviation_error, name='$\sigma_{\overline{\Delta r}}$', + format='{:.3f}', unit='mas') + signal = Column(data=signal, name='significance') + all_chi2 = Column(data=all_chi2, name='$\chi^2$a', format='{:.2f}') + all_chi2_red = Column(data=all_chi2_red, name='$\tilde{\chi}^2$a', format='{:.2f}') + cut_chi2 = Column(data=cut_chi2, name='$\chi^2$', format='{:.2f}') + cut_chi2_red = Column(data=cut_chi2_red, name='$\tilde{\chi}^2$', format='{:.2f}') + + tab = Table((Column(data=objects, name='Object'), all_chi2, all_chi2_red, cut_chi2, cut_chi2_red,\ + av_dev, av_deve, signal)) + + # Header details are hard-coded in the paper. + # tab.write('astrom_significance.tex', format='aastex', overwrite=True) + tab.write('astrom_significance.tex', format='ascii.fixed_width_no_header', delimiter='&', overwrite=True, delimiter_pad=' ', bookend=False) + + print(tab) + + os.chdir(ret_dir) + +def plot_linear_motion(target, fig_num = 1): + """ + Plot the linear motion of the target + with a proper motion fit that excludes the peak year. + """ + from jlu.microlens import fit_velocities + + out_dir = paper_dir + 'compare_linear_motion/' + + def plot_target(fitob, fig_num): + ''' + Plots the linear fit for the target only. The figure is saved. + + Parameters + ---------- + figob : StarTable from fit_velocities + ''' + res_rng = fit_velocities.res_dict[fitob.target] + + stars = np.append([fitob.target], comp_stars[fitob.target]) + + # Figure out the min/max of the times for these sources. + tdx = np.where(fitob['name'] == fitob.target)[0][0] + tmin = fitob['t'][tdx].min() - 0.5 # in days + tmax = fitob['t'][tdx].max() + 0.5 # in days + + # Setup figure and color scales + figsize = (6, 9.5) + plt.close(fig_num) + fig = plt.figure(fig_num, figsize=figsize) + plt.clf() + + # st = fig.suptitle(fitob.target + " astrometry", fontsize = 20) + + grid_t = plt.GridSpec(1, 1, bottom=0.60, top=0.95, left=0.25, right=0.79) + grid_b = plt.GridSpec(2, 1, hspace=0.1, wspace=0.5, bottom=0.10, top=0.5, left=0.25, right=0.79) + + cmap = plt.cm.plasma + norm = plt.Normalize(vmin=tmin, vmax=tmax) + smap = plt.cm.ScalarMappable(cmap=cmap, norm=norm) + smap.set_array([]) + + ax_sky = fig.add_subplot(grid_t[0, 0]) + ax_resX = fig.add_subplot(grid_b[1, 0]) + ax_resY = fig.add_subplot(grid_b[0, 0]) + + # Fetch the data + tdx = np.where(fitob['name'] == fitob.target)[0][0] + star = fitob[tdx] + + # Change signs of the East + x = star['x']*-1.0 + y = star['y'] + x0 = star['x0']*-1.0 + y0 = star['y0'] + vx = star['vx']*-1.0 + vy = star['vy'] + + # Make the model curves + tmod = np.arange(tmin, tmax, 0.1) + xmod = x0 + vx * (tmod - star['t0']) + ymod = y0 + vy * (tmod - star['t0']) + xmode = np.hypot(star['x0e'], star['vxe'] * (tmod - star['t0'])) + ymode = np.hypot(star['y0e'], star['vye'] * (tmod - star['t0'])) + + xmod_at_t = x0 + vx * (star['t'] - star['t0']) + ymod_at_t = y0 + vy * (star['t'] - star['t0']) + + # Plot Positions on Sky + ax_sky.plot(xmod, ymod, '-', color='grey', zorder=1) + ax_sky.plot(xmod + xmode, ymod + ymode, '--', color='grey', zorder=1) + ax_sky.plot(xmod - xmode, ymod - ymode, '--', color='grey', zorder=1) + sc = ax_sky.scatter(x, y, c=star['t'], cmap=cmap, norm=norm, s=20, zorder=2) + ax_sky.errorbar(x, y, xerr=star['xe'], yerr=star['ye'], + ecolor=smap.to_rgba(star['t']), fmt='none', elinewidth=2, zorder=2) + ax_sky.set_aspect('equal', adjustable='datalim') + + # Figure out which axis has the bigger data range. + xy_rng = 0.020 # this is the same range for all the stars. + xmin = x0 - (xy_rng / 2.0) + xmax = x0 + (xy_rng / 2.0) + ymin = y0 - (xy_rng / 2.0) + ymax = y0 + (xy_rng / 2.0) + ax_sky.set_xlim(xmin, xmax) + ax_sky.set_ylim(ymin, ymax) + + # Set labels + ax_sky.invert_xaxis() + ax_sky.set_title(fitob.target.upper()) + ax_sky.set_xlabel(r'$\Delta\alpha*$ (")') + ax_sky.set_ylabel(r'$\Delta\delta$ (")') + + # Plot Residuals vs. Time + xres = (x - xmod_at_t) * 1e3 + yres = (y - ymod_at_t) * 1e3 + xrese = star['xe'] * 1e3 + yrese = star['ye'] * 1e3 + ax_resX.errorbar(star['t'], xres, yerr=xrese, fmt='r.', label=r'$\alpha*$', elinewidth=2) + ax_resY.errorbar(star['t'], yres, yerr=yrese, fmt='b.', label=r'$\delta$', elinewidth=2) + ax_resX.plot(tmod, xmod - xmod, 'r-') + ax_resX.plot(tmod, xmode*1e3, 'r--') + ax_resX.plot(tmod, -xmode*1e3, 'r--') + ax_resY.plot(tmod, ymod - ymod, 'b-') + ax_resY.plot(tmod, ymode*1e3, 'b--') + ax_resY.plot(tmod, -ymode*1e3, 'b--') + ax_resX.set_xlabel('Date (yr)') + + xresrng = xres + np.sign(xres)*(xrese + 0.1) + yresrng = yres + np.sign(yres)*(yrese + 0.1) + # ax_resX.set_ylim(xresrng.min(), xresrng.max()) + # ax_resY.set_ylim(yresrng.min(), yresrng.max()) + ax_resX.set_ylim(-0.95, 0.95) + ax_resY.set_ylim(-0.95, 0.95) + ax_resY.get_xaxis().set_visible(False) + ax_resX.set_ylabel(r'$\alpha^*$') + ax_resY.set_ylabel(r'$\delta$') + plt.gcf().text(0.04, 0.3, 'Residuals (mas)', rotation=90, fontsize=18, + ha='center', va='center') + + cb_ax = fig.add_axes([0.8, 0.60, 0.02, 0.35]) + plt.colorbar(sc, cax=cb_ax, label='Year') + + plt.savefig(f"{out_dir}/{fitob.target}_linear_fit.png") + + return + + fitob = fit_velocities.StarTable(target) + fitob.fit(time_cut=fitob.time_cut) # Fit without the peak year + + plot_target(fitob, fig_num) + + return + + +def plot_linear_motion_all(): + """ + Plot the linear motion of the target + with a proper motion fit that excludes the peak year. + """ + from flystar import startables, motion_model + + out_dir = paper_dir + 'compare_linear_motion/' + + # Setup figure and color scales + plt.close(1) + fig = plt.figure(1, figsize=(12, 6)) + + grid_t = plt.GridSpec(1, 4, bottom=0.60, top=0.95, left=0.13, right=0.87, wspace=0.05) + grid_b = plt.GridSpec(2, 4, bottom=0.15, top=0.45, left=0.13, right=0.87, hspace=0.15, wspace=0.05) + cb_ax = fig.add_axes([0.88, 0.15, 0.02, 0.8]) + + targets = ['ob120169', 'ob140613', 'ob150029', 'ob150211'] + + # Set up a time scale across all of the targets. + tmin = 2012.0 + tmax = 2021.0 + + cmap = plt.cm.plasma_r + norm = plt.Normalize(vmin=tmin, vmax=tmax) + smap = plt.cm.ScalarMappable(cmap=cmap, norm=norm) + smap.set_array([]) + + plt.gcf().text(0.02, 0.3, 'Residuals (mas)', rotation=90, fontsize=18, + ha='center', va='center') + time_cut = {'ob120169': 2013, 'ob140613':2016, 'ob150029':2016, 'ob150211':2016} + + + for tt in range(len(targets)): + target = targets[tt] + + fitob = startables.StarTable(Table.read(astrom_data[target])) + coord = SkyCoord(ra=munge.ra[target], dec=munge.dec[target], unit=(u.hourangle, u.degree)) + motmod = motion_model.Parallax(RA=coord.ra.degree,Dec=coord.dec.degree,PA=0) + tdx = np.where(fitob['name'] == target)[0][0] + idx = fitob[tdx]['t']>time_cut[target] + params, param_errs = motmod.run_fit(fitob[tdx]['t'][idx], fitob[tdx]['x'][idx], + fitob[tdx]['y'][idx], fitob[tdx]['xe'][idx], fitob[tdx]['ye'][idx], fitob[tdx]['t0']) + + #res_rng = fit_velocities.res_dict[fitob.target] + + #stars = np.append([fitob.target], comp_stars[fitob.target]) + + if tt == 0: + ax_sky_0 = fig.add_subplot(grid_t[0, tt]) + ax_resX_0 = fig.add_subplot(grid_b[1, tt]) + ax_resY_0 = fig.add_subplot(grid_b[0, tt]) + ax_sky = ax_sky_0 + ax_resX = ax_resX_0 + ax_resY = ax_resY_0 + else: + ax_sky = fig.add_subplot(grid_t[0, tt], sharex=ax_sky_0, sharey=ax_sky_0) + ax_resX = fig.add_subplot(grid_b[1, tt], sharey=ax_resX_0) + ax_resY = fig.add_subplot(grid_b[0, tt], sharey=ax_resY_0) + + # Fetch the data + star = fitob[tdx] + + # Define local min/max times for this target. + tmin_tt = star['t'].min() - 0.5 # in year + tmax_tt = star['t'].max() + 0.5 # in year + + # Change signs of the East + x = star['x']*-1.0 + y = star['y'] + x0 = params[0]*-1.0 + y0 = params[2] + vx = params[1]*-1.0 + vy = params[3] + pi = params[4] + x0_err, vx_err, y0_err, vy_err, pi_err = param_errs + #pdb.set_trace() + + # Put everything into relative coordinates w.r.t. x0/y0 + x -= x0 + y -= y0 + + # Convert to milli-arcsec + x *= 1000.0 + y *= 1000.0 + vx *= 1000.0 + vy *= 1000.0 + pi *= 1000.0 + + # Make the model curves + tmod = np.arange(tmin_tt, tmax_tt, 0.1) + # xmod = x0 + vx * (tmod - star['t0']) + # ymod = y0 + vy * (tmod - star['t0']) + t_mjd = Time(tmod, format='decimalyear', scale='utc').mjd + pvec = motmod.get_parallax_vector(t_mjd) + xmod = vx * (tmod - star['t0']) - pi*pvec[0] + ymod = vy * (tmod - star['t0']) + pi*pvec[1] + xmode = np.sqrt(x0_err**2 + (vx_err * (tmod - star['t0']))**2 + (pi_err*pvec[0])**2) * 1e3 + ymode = np.sqrt(y0_err**2 + (vy_err * (tmod - star['t0']))**2 + (pi_err*pvec[1])**2) * 1e3 + #print(xmode) + #print(np.sqrt(x0_err**2 + (vx_err * (tmod - star['t0']))**2) * 1e3) + #print(pi_err*pvec[0]*1e3) + + # xmod_at_t = x0 + vx * (star['t'] - star['t0']) + # ymod_at_t = y0 + vy * (star['t'] - star['t0']) + t_mjd = Time(star['t'], format='decimalyear', scale='utc').mjd + pvec2 = motmod.get_parallax_vector(t_mjd) + xmod_at_t = vx * (star['t'] - star['t0']) - pi*pvec2[0] + ymod_at_t = vy * (star['t'] - star['t0']) + pi*pvec2[1] + + # Plot Positions on Sky + ax_sky.plot(xmod, ymod, '-', color='grey', zorder=1) + ax_sky.plot(xmod + xmode, ymod + ymode, '--', color='grey', zorder=1) + ax_sky.plot(xmod - xmode, ymod - ymode, '--', color='grey', zorder=1) + sc = ax_sky.scatter(x, y, c=star['t'], cmap=cmap, norm=norm, s=20, zorder=2) + ax_sky.errorbar(x, y, xerr=star['xe'], yerr=star['ye'], + ecolor=smap.to_rgba(star['t']), fmt='none', elinewidth=2, zorder=2) + ax_sky.set_aspect('equal')#, adjustable='datalim') + + # Figure out which axis has the bigger data range. + xy_rng = 60.0 # mas, this is the same range for all the stars. + xmin = -(xy_rng / 2.0) + xmax = +(xy_rng / 2.0) + ymin = -(xy_rng / 2.0) + ymax = +(xy_rng / 2.0) + if tt == 0: + ax_sky_0.set_xlim(xmax, xmin) + ax_sky_0.set_ylim(ymin, ymax) + + # Set labels + # ax_sky.invert_xaxis() + ax_sky.set_title(target.upper()) + + ax_sky.set_xlabel(r'$\Delta\alpha*$ (mas)') + if tt == 0: + ax_sky.set_ylabel(r'$\Delta\delta$ (mas)') + else: + ax_sky.yaxis.set_visible(False) + + # Plot Residuals vs. Time + xres = (x - xmod_at_t) + yres = (y - ymod_at_t) + xrese = star['xe'] * 1e3 + yrese = star['ye'] * 1e3 + ax_resX.scatter(star['t'], xres, c=star['t'], cmap=cmap, norm=norm, s=20, zorder=2) + ax_resY.scatter(star['t'], yres, c=star['t'], cmap=cmap, norm=norm, s=20, zorder=2) + ax_resX.errorbar(star['t'], xres, yerr=xrese, + ecolor=smap.to_rgba(star['t']), + fmt='none', elinewidth=2, zorder=2) + ax_resY.errorbar(star['t'], yres, yerr=yrese, + ecolor=smap.to_rgba(star['t']), + fmt='none', elinewidth=2, zorder=2) + ax_resX.plot(tmod, xmod - xmod, '-', color='grey', zorder=1) + ax_resX.plot(tmod, xmode, '--', color='grey', zorder=1) + ax_resX.plot(tmod, -xmode, '--', color='grey', zorder=1) + ax_resY.plot(tmod, ymod - ymod, '-', color='grey', zorder=1) + ax_resY.plot(tmod, ymode, '--', color='grey', zorder=1) + ax_resY.plot(tmod, -ymode, '--', color='grey', zorder=1) + ax_resX.set_xlabel('Date (yr)') + + xresrng = xres + np.sign(xres)*(xrese + 0.1) + yresrng = yres + np.sign(yres)*(yrese + 0.1) + + if tt == 0: + ax_resX.set_ylim(-0.90, 0.90) + ax_resY.set_ylim(-0.90, 0.90) + else: + ax_resX.yaxis.set_visible(False) + ax_resY.yaxis.set_visible(False) + + ax_resY.get_xaxis().set_visible(False) + ax_resX.set_ylabel(r'$\alpha^*$') + ax_resY.set_ylabel(r'$\delta$') + + plt.colorbar(sc, cax=cb_ax, label='Year') + + plt.savefig(f"{paper_dir}/linear_fit_all.png") + + return + +def org_solutions_for_table(): + targets = ['ob120169', 'ob140613', 'ob150029', 'ob150211'] + + for targ in targets: + import warnings + warnings.simplefilter(action='ignore', category=FutureWarning) + + stats_pho, data_pho, mod_pho = load_summary_statistics(pspl_phot[targ]) + stats_ast, data_ast, mod_ast = load_summary_statistics(pspl_ast_multiphot[targ]) + + for col in stats_pho.itercols(): + if col.info.dtype.kind == 'f': + col.info.format = '.3f' + for col in stats_ast.itercols(): + if col.info.dtype.kind == 'f': + col.info.format = '.3f' + + print('') + print('******************') + print(f'*** {targ:s} ***') + print('******************') + print('') + print('Photometry Solutions') + print(stats_pho['MaxLike_logL', 'MaxLike_u0_amp', 'MaxLike_piE_E', 'MaxLike_piE_N', 'Med_logL', 'Med_u0_amp', 'Med_piE_E', 'Med_piE_N']) + + print('') + print('Astrometry Solutions') + print(stats_ast['MaxLike_logL', 'MaxLike_u0_amp', 'MaxLike_piE_E', 'MaxLike_piE_N', 'Med_logL', 'Med_u0_amp', 'Med_piE_E', 'Med_piE_N']) + + print('') + print('Astrometry Solutions Mass Info') + print(stats_ast['logZ', 'Mean_mL', 'MaxLike_mL', 'MAP_mL', 'Mean_thetaE', 'MaxLike_thetaE', 'MAP_thetaE', 'Mean_logL', 'MaxLike_logL', 'MAP_logL']) + + return + +def table_ob120169_phot_astrom(): + # Load up the params file so we know what kind of + # data and model we are working with. Note that we + # are assuming that all the Nruns are using the same + # parameters. + target = 'ob120169' + + stats_pho, data_pho, mod_pho = load_summary_statistics(pspl_phot[target]) + stats_ast, data_ast, mod_ast = load_summary_statistics(pspl_ast_multiphot[target]) + + # No longer using + # 'add_err1': '$\\varepsilon_{a,I}$ (mmag)', + # 'add_err2': '$\\varepsilon_{a,Kp}$ (mmag)', + + labels = {'t0': '$t_0$ (MJD)', + 'u0_amp': '$u_0$', + 'tE': '$t_E$ (days)', + 'piE_E': '$\pi_{E,E}$', + 'piE_N': '$\pi_{E,N}$', + 'b_sff1': '$b_{SFF,I}$', + 'mag_base1': '$I_{base}$ (mag)', + 'b_sff2': '$b_{SFF,Kp}$', + 'mag_base2': '$Kp_{base}$ (mag)', + 'thetaE': '$\\theta_E$ (mas)', + 'piS': '$\pi_S$ (mas)', + 'muS_E': '$\mu_{S,\\alpha*}$ (mas/yr)', + 'muS_N': '$\mu_{S,\delta}$ (mas/yr)', + 'xS0_E': '$x_{S0,\\alpha*}$ (mas)', + 'xS0_N': '$x_{S0,\delta}$ (mas)', + 'break1': '', + 'mL': '$M_L$ ($\msun$)', + 'piL': '$\pi_L$ (mas)', + 'piRel': '$\pi_{rel}$ (mas)', + 'muL_E': '$\mu_{L,\\alpha*}$ (mas/yr)', + 'muL_N': '$\mu_{L,\delta}$ (mas/yr)', + 'muRel_E': '$\mu_{rel,\\alpha*}$ (mas/yr)', + 'muRel_N': '$\mu_{rel,\delta}$ (mas/yr)', + 'mag_src1': '$I_{src}$ (mag)', + 'mag_src2': '$Kp_{src}$ (mag)' + } + # 'break2': '', + # 'gp_log_sigma1': '$\log \sigma_{GP, I} (mag)$', + # 'gp_rho1': '$\\rho_{GP, I}$ (days)', + # 'gp_log_omega04_S01': '$\log S_{0, GP, I} \omega_{0, GP, I}^4$ (mag$^2$ days$^{-2}$)', + # 'gp_log_omega01': '$\log \omega_{0, GP, I}$ (days$^{-1}$)' + # } + + scale = {'t0': 1.0, + 'u0_amp': 1.0, + 'tE': 1.0, + 'piE_E': 1.0, + 'piE_N': 1.0, + 'b_sff1': 1.0, + 'mag_src1':1.0, + 'mag_base1':1.0, + 'add_err1':1e3, + 'b_sff2': 1.0, + 'mag_src2':1.0, + 'mag_base2':1.0, + 'add_err2':1e3, + 'thetaE': 1.0, + 'piS': 1.0, + 'muS_E': 1.0, + 'muS_N': 1.0, + 'xS0_E': 1e3, + 'xS0_N': 1e3, + 'mL': 1.0, + 'piL': 1.0, + 'piRel': 1.0, + 'muL_E': 1.0, + 'muL_N': 1.0, + 'muRel_E': 1.0, + 'muRel_N': 1.0, + 'gp_log_sigma1': 1.0, + 'gp_rho1': 1.0, + 'gp_log_omega04_S01': 1.0, + 'gp_log_omega01': 1.0 + } + + sig_digits = {'t0': '0.2f', + 'u0_amp': '0.2f', + 'tE': '0.1f', + 'piE_E': '0.3f', + 'piE_N': '0.3f', + 'b_sff1': '0.3f', + 'mag_src1': '0.3f', + 'mag_base1': '0.3f', + 'add_err1': '0.1f', + 'thetaE': '0.2f', + 'piS': '0.3f', + 'muS_E': '0.2f', + 'muS_N': '0.2f', + 'xS0_E': '0.2f', + 'xS0_N': '0.2f', + 'b_sff2': '0.2f', + 'mag_src2': '0.2f', + 'mag_base2': '0.2f', + 'add_err2': '0.1f', + 'mL': '0.2f', + 'piL': '0.3f', + 'piRel': '0.3f', + 'muL_E': '0.2f', + 'muL_N': '0.2f', + 'muRel_E': '0.2f', + 'muRel_N': '0.2f', + 'gp_log_sigma1': '0.1f', + 'gp_rho1': '0.1f', + 'gp_log_omega04_S01': '0.1f', + 'gp_log_omega01': '0.1f' + } + + pho_u0p = 0 + pho_u0m = 1 # doesn't exist + ast_u0p = 0 + ast_u0m = 1 # doesn't exist + + tab_file = open(paper_dir + target + '_OGLE_phot_ast.txt', 'w') + tab_file.write('log$\mathcal{L}$ ' + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_pho['MaxLike_logL'][pho_u0p], + stats_pho['MAP_logL'][pho_u0p], + stats_pho['Med_logL'][pho_u0p]) + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_ast['MaxLike_logL'][ast_u0p], + stats_ast['MAP_logL'][ast_u0p], + stats_ast['Med_logL'][ast_u0p]) + + '\\\ \n') + tab_file.write('$\tilde{\chi}^2$ ' + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_pho['MaxLike_rchi2'][pho_u0p], + stats_pho['MAP_rchi2'][pho_u0p], + stats_pho['Med_rchi2'][pho_u0p]) + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_ast['MaxLike_rchi2'][ast_u0p], + stats_ast['MAP_rchi2'][ast_u0p], + stats_ast['Med_rchi2'][ast_u0p]) + + ' \\\ \n') + tab_file.write('log$\mathcal{Z}$ ' + + '& & & {0:.1f} & '.format(stats_pho['logZ'][pho_u0p]) + + '& & & {0:.1f} & '.format(stats_ast['logZ'][ast_u0p]) + + ' \\\ \n') + tab_file.write('$N_{dof}$ ' + + '& & & {0:.0f} & '.format(stats_pho['N_dof'][pho_u0p]) + + '& & & {0:.0f} & '.format(stats_ast['N_dof'][ast_u0p]) + + ' \\\ \n' + + r'\hline ' + '\n') + + # Keep track of when we finish off the fitted parameters (vs. additional parameters). + start_extra_params = False + start_gp_params = False + + for key, label in labels.items(): + # We will have 4 solutions... each has a value and error bar. + # Setup an easy way to walk through them (and rescale) as necessary. + # val_dict = [stats_pho, stats_pho, stats_ast] + # val_mode = [ pho_u0p, pho_u0m, ast_u0m] + val_dict = [stats_pho, stats_ast] + val_mode = [ pho_u0p, ast_u0p] + + if (key in mod_ast.additional_param_names) and not start_extra_params: + tab_file.write('\\tableline\n') + start_extra_params = True + + if ('gp' in key) and not start_gp_params: + tab_file.write('\\tableline\n') + start_gp_params = True + + tab_file.write(label) + + for ss in range(len(val_dict)): + stats = val_dict[ss] + + if ('MaxLike_' + key in stats.colnames) and (val_mode[ss] < len(stats)): + fmt = ' & {0:' + sig_digits[key] + '} & {1:' + sig_digits[key] + '} & ' + fmt += '{2:' + sig_digits[key] + '} & [{3:' + sig_digits[key] + '}, {4:' + sig_digits[key] + '}] ' + + val_mli = stats['MaxLike_' + key][val_mode[ss]] + val_map = stats['MAP_' + key][val_mode[ss]] + val_med = stats['Med_' + key][val_mode[ss]] + elo = stats['lo68_' + key][val_mode[ss]] - stats['Med_' + key][val_mode[ss]] + ehi = stats['hi68_' + key][val_mode[ss]] - stats['Med_' + key][val_mode[ss]] + + val_mli *= scale[key] + val_map *= scale[key] + val_med *= scale[key] + elo *= scale[key] + ehi *= scale[key] + + tab_file.write(fmt.format(val_mli, val_map, val_med, elo, ehi)) + else: + fmt = ' & & & & ' + tab_file.write(fmt) + + tab_file.write(' \\\ \n') + + return + +def table_ob140613_phot_astrom(): + # Load up the params file so we know what kind of + # data and model we are working with. Note that we + # are assuming that all the Nruns are using the same + # parameters. + target = 'ob140613' + + stats_pho, data_pho, mod_pho = load_summary_statistics(pspl_phot[target]) + stats_ast, data_ast, mod_ast = load_summary_statistics(pspl_ast_multiphot[target]) + + labels = {'t0': '$t_0$ (MJD)', + 'u0_amp': '$u_0$', + 'tE': '$t_E$ (days)', + 'piE_E': '$\pi_{E,E}$', + 'piE_N': '$\pi_{E,N}$', + 'b_sff1': '$b_{SFF,I}$', + 'mag_src1': '$I_{src}$ (mag)', + 'mult_err1': '$\\varepsilon_{m,I}$', + 'thetaE': '$\\theta_E$ (mas)', + 'piS': '$\pi_S$ (mas)', + 'muS_E': '$\mu_{S,\\alpha*}$ (mas/yr)', + 'muS_N': '$\mu_{S,\delta}$ (mas/yr)', + 'xS0_E': '$x_{S0,\\alpha*}$ (mas)', + 'xS0_N': '$x_{S0,\delta}$ (mas)', + 'b_sff2': '$b_{SFF,Kp}$', + 'mag_src2': '$Kp_{src}$ (mag)', + 'mult_err2': '$\\varepsilon_{m,Kp}$', + 'mL': '$M_L$ ($\msun$)', + 'piL': '$\pi_L$ (mas)', + 'piRel': '$\pi_{rel}$ (mas)', + 'muL_E': '$\mu_{L,\\alpha*}$ (mas/yr)', + 'muL_N': '$\mu_{L,\delta}$ (mas/yr)', + 'muRel_E': '$\mu_{rel,\\alpha*}$ (mas/yr)', + 'muRel_N': '$\mu_{rel,\delta}$ (mas/yr)' + } + scale = {'t0': 1.0, + 'u0_amp': 1.0, + 'tE': 1.0, + 'piE_E': 1.0, + 'piE_N': 1.0, + 'b_sff1': 1.0, + 'mag_src1':1.0, + 'mult_err1':1.0, + 'thetaE': 1.0, + 'piS': 1.0, + 'muS_E': 1.0, + 'muS_N': 1.0, + 'xS0_E': 1e3, + 'xS0_N': 1e3, + 'b_sff2': 1.0, + 'mag_src2':1.0, + 'mult_err2':1.0, + 'mL': 1.0, + 'piL': 1.0, + 'piRel': 1.0, + 'muL_E': 1.0, + 'muL_N': 1.0, + 'muRel_E': 1.0, + 'muRel_N': 1.0 + } + sig_digits = {'t0': '0.2f', + 'u0_amp': '0.2f', + 'tE': '0.1f', + 'piE_E': '0.3f', + 'piE_N': '0.3f', + 'b_sff1': '0.3f', + 'mag_src1': '0.3f', + 'mult_err1': '0.1f', + 'thetaE': '0.2f', + 'piS': '0.3f', + 'muS_E': '0.2f', + 'muS_N': '0.2f', + 'xS0_E': '0.2f', + 'xS0_N': '0.2f', + 'b_sff2': '0.2f', + 'mag_src2': '0.2f', + 'mult_err2': '0.1f', + 'mL': '0.2f', + 'piL': '0.3f', + 'piRel': '0.3f', + 'muL_E': '0.2f', + 'muL_N': '0.2f', + 'muRel_E': '0.2f', + 'muRel_N': '0.2f' + } + + pho_u0m = 1 # no solution + pho_u0p = 0 # Best of 3 positive solutions + ast_u0m = 1 # no solution + ast_u0p = 0 # best of 3 positive solutions + + tab_file = open(paper_dir + target + '_OGLE_phot_ast.txt', 'w') + tab_file.write('log$\mathcal{L}$ ' + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_pho['MaxLike_logL'][pho_u0p], + stats_pho['MAP_logL'][pho_u0p], + stats_pho['Med_logL'][pho_u0p]) + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_ast['MaxLike_logL'][ast_u0p], + stats_ast['MAP_logL'][ast_u0p], + stats_ast['Med_logL'][ast_u0p]) + + ' \\\ \n') + tab_file.write('$\tilde{\chi}^2$ ' + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_pho['MaxLike_rchi2'][pho_u0p], + stats_pho['MAP_rchi2'][pho_u0p], + stats_pho['Med_rchi2'][pho_u0p]) + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_ast['MaxLike_rchi2'][ast_u0p], + stats_ast['MAP_rchi2'][ast_u0p], + stats_ast['Med_rchi2'][ast_u0p]) + + ' \\\ \n') + tab_file.write('log$\mathcal{Z}$ ' + + '& & & {0:.1f} & '.format(stats_pho['logZ'][pho_u0p]) + + '& & & {0:.1f} & '.format(stats_ast['logZ'][ast_u0p]) + + ' \\\ \n') + tab_file.write('$N_{dof}$ ' + + '& & & {0:.0f} & '.format(stats_pho['N_dof'][pho_u0p]) + + '& & & {0:.0f} & '.format(stats_ast['N_dof'][ast_u0p]) + + ' \\\ \n' + + r'\hline ' + '\n') + + # Keep track of when we finish off the fitted parameters (vs. additional parameters). + start_extra_params = False + + for key, label in labels.items(): + # We will have 4 solutions... each has a value and error bar. + # Setup an easy way to walk through them (and rescale) as necessary. + val_dict = [stats_pho, stats_ast] + val_mode = [pho_u0p, ast_u0p] + + if (key in mod_ast.additional_param_names) and not start_extra_params: + tab_file.write('\\tableline\n') + start_extra_params = True + + tab_file.write(label) + + for ss in range(len(val_dict)): + stats = val_dict[ss] + + if ('MaxLike_' + key in stats.colnames): + fmt = ' & {0:' + sig_digits[key] + '} & {1:' + sig_digits[key] + '} ' + fmt += '& {2:' + sig_digits[key] + '} & [{3:' + sig_digits[key] + '}, {4:' + sig_digits[key] + '}] ' + + val_mli = stats['MaxLike_' + key][val_mode[ss]] + val_map = stats['MAP_' + key][val_mode[ss]] + val_med = stats['Med_' + key][val_mode[ss]] + elo = stats['lo68_' + key][val_mode[ss]] - stats['Med_' + key][val_mode[ss]] + ehi = stats['hi68_' + key][val_mode[ss]] - stats['Med_' + key][val_mode[ss]] + + val_mli *= scale[key] + val_map *= scale[key] + val_med *= scale[key] + elo *= scale[key] + ehi *= scale[key] + + tab_file.write(fmt.format(val_mli, val_map, val_med, elo, ehi)) + else: + fmt = ' & & & & ' + tab_file.write(fmt) + + tab_file.write(' \\\ \n') + + return + +def table_ob150029_phot_astrom(): + # Load up the params file so we know what kind of + # data and model we are working with. Note that we + # are assuming that all the Nruns are using the same + # parameters. + target = 'ob150029' + + stats_pho, data_pho, mod_pho = load_summary_statistics(pspl_phot[target]) + stats_ast, data_ast, mod_ast = load_summary_statistics(pspl_ast_multiphot[target]) + + labels = {'t0': '$t_0$ (MJD)', + 'u0_amp': '$u_0$', + 'tE': '$t_E$ (days)', + 'piE_E': '$\pi_{E,E}$', + 'piE_N': '$\pi_{E,N}$', + 'b_sff1': '$b_{SFF,I}$', + 'mag_src1': '$I_{src}$ (mag)', + 'add_err1': '$\\varepsilon_{a,I}$ (mmag)', + 'thetaE': '$\\theta_E$ (mas)', + 'piS': '$\pi_S$ (mas)', + 'muS_E': '$\mu_{S,\\alpha*}$ (mas/yr)', + 'muS_N': '$\mu_{S,\delta}$ (mas/yr)', + 'xS0_E': '$x_{S0,\\alpha*}$ (mas)', + 'xS0_N': '$x_{S0,\delta}$ (mas)', + 'b_sff2': '$b_{SFF,Kp}$', + 'mag_src2': '$Kp_{src}$ (mag)', + 'add_err2': '$\\varepsilon_{a,Kp}$ (mmag)', + 'mL': '$M_L$ ($\msun$)', + 'piL': '$\pi_L$ (mas)', + 'piRel': '$\pi_{rel}$ (mas)', + 'muL_E': '$\mu_{L,\\alpha*}$ (mas/yr)', + 'muL_N': '$\mu_{L,\delta}$ (mas/yr)', + 'muRel_E': '$\mu_{rel,\\alpha*}$ (mas/yr)', + 'muRel_N': '$\mu_{rel,\delta}$ (mas/yr)' + } + scale = {'t0': 1.0, + 'u0_amp': 1.0, + 'tE': 1.0, + 'piE_E': 1.0, + 'piE_N': 1.0, + 'b_sff1': 1.0, + 'mag_src1':1.0, + 'add_err1':1e3, + 'thetaE': 1.0, + 'piS': 1.0, + 'muS_E': 1.0, + 'muS_N': 1.0, + 'xS0_E': 1e3, + 'xS0_N': 1e3, + 'b_sff2': 1.0, + 'mag_src2':1.0, + 'add_err2':1e3, + 'mL': 1.0, + 'piL': 1.0, + 'piRel': 1.0, + 'muL_E': 1.0, + 'muL_N': 1.0, + 'muRel_E': 1.0, + 'muRel_N': 1.0 + } + sig_digits = {'t0': '0.2f', + 'u0_amp': '0.2f', + 'tE': '0.1f', + 'piE_E': '0.3f', + 'piE_N': '0.3f', + 'b_sff1': '0.3f', + 'mag_src1': '0.3f', + 'add_err1': '0.1f', + 'thetaE': '0.2f', + 'piS': '0.3f', + 'muS_E': '0.2f', + 'muS_N': '0.2f', + 'xS0_E': '0.2f', + 'xS0_N': '0.2f', + 'b_sff2': '0.2f', + 'mag_src2': '0.2f', + 'add_err2': '0.1f', + 'mL': '0.2f', + 'piL': '0.3f', + 'piRel': '0.3f', + 'muL_E': '0.2f', + 'muL_N': '0.2f', + 'muRel_E': '0.2f', + 'muRel_N': '0.2f' + } + + pho_u0m = 1 + pho_u0p = 0 + ast_u0m = 0 + ast_u0p = 1 # No solution + + tab_file = open(paper_dir + target + '_OGLE_phot_ast.txt', 'w') + tab_file.write('log$\mathcal{L}$ ' + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_pho['MaxLike_logL'][pho_u0m], + stats_pho['MAP_logL'][pho_u0m], + stats_pho['Med_logL'][pho_u0m]) + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_ast['MaxLike_logL'][ast_u0m], + stats_ast['MAP_logL'][ast_u0m], + stats_ast['Med_logL'][ast_u0m]) + + ' \\\ \n') + tab_file.write('$\tilde{\chi}^2$ ' + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_pho['MaxLike_rchi2'][pho_u0m], + stats_pho['MAP_rchi2'][pho_u0m], + stats_pho['Med_rchi2'][pho_u0m]) + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_ast['MaxLike_rchi2'][ast_u0m], + stats_ast['MAP_rchi2'][ast_u0m], + stats_ast['Med_rchi2'][ast_u0m]) + + ' \\\ \n') + tab_file.write('log$\mathcal{Z}$ ' + + '& & & {0:.1f} & '.format(stats_pho['logZ'][pho_u0m]) + + '& & & {0:.1f} & '.format(stats_ast['logZ'][ast_u0m]) + + ' \\\ \n') + tab_file.write('$N_{dof}$ ' + + '& {0:.0f} & & & '.format(stats_pho['N_dof'][pho_u0m]) + + '& {0:.0f} & & & '.format(stats_ast['N_dof'][ast_u0m]) + + ' \\\ \n' + + r'\hline ' + '\n') + + # Keep track of when we finish off the fitted parameters (vs. additional parameters). + start_extra_params = False + + for key, label in labels.items(): + # We will have 4 solutions... each has a value and error bar. + # Setup an easy way to walk through them (and rescale) as necessary. + val_dict = [stats_pho, stats_ast] + val_mode = [pho_u0m, ast_u0m] + + if (key in mod_ast.additional_param_names) and not start_extra_params: + tab_file.write('\\tableline\n') + start_extra_params = True + + tab_file.write(label) + + for ss in range(len(val_dict)): + stats = val_dict[ss] + + if ('MaxLike_' + key in stats.colnames): + fmt = ' & {0:' + sig_digits[key] + '} & {1:' + sig_digits[key] + '} ' + fmt += '& {2:' + sig_digits[key] + '} & [{3:' + sig_digits[key] + '}, {4:' + sig_digits[key] + '}] ' + + val_mli = stats['MaxLike_' + key][val_mode[ss]] + val_map = stats['MAP_' + key][val_mode[ss]] + val_med = stats['Med_' + key][val_mode[ss]] + elo = stats['lo68_' + key][val_mode[ss]] - stats['Med_' + key][val_mode[ss]] + ehi = stats['hi68_' + key][val_mode[ss]] - stats['Med_' + key][val_mode[ss]] + + val_mli *= scale[key] + val_map *= scale[key] + val_med *= scale[key] + elo *= scale[key] + ehi *= scale[key] + + tab_file.write(fmt.format(val_mli, val_map, val_med, elo, ehi)) + else: + fmt = ' & & & & ' + tab_file.write(fmt) + + tab_file.write(' \\\ \n') + + return + +def table_ob150211_phot(): + """ + Print the latex table for the photometry-only fit. + """ + target = 'ob150211' + + stats_pho, data_pho, mod_pho = load_summary_statistics(pspl_phot[target]) + + # No longer using + # 'add_err1': '$\\varepsilon_{a,I}$ (mmag)', + # 'add_err2': '$\\varepsilon_{a,Kp}$ (mmag)', + + # This dictionary sets the order of the parameters in the table. + # If I want a horizontal line in between the two, I just add 'break#' where + # the "#" symbol is just any arbitrary number. + labels = {'t0': '$t_0$ (MJD)', + 'u0_amp': '$u_0$', + 'tE': '$t_E$ (days)', + 'piE_E': '$\pi_{E,E}$', + 'piE_N': '$\pi_{E,N}$', + 'b_sff1': '$b_{SFF,I}$', + 'mag_base1': '$I_{base}$ (mag)', + 'break1': '', + 'mag_src1': '$I_{src}$ (mag)', + } + + scale = {'t0': 1.0, + 'u0_amp': 1.0, + 'tE': 1.0, + 'piE_E': 1.0, + 'piE_N': 1.0, + 'b_sff1': 1.0, + 'mag_src1':1.0, + 'mag_base1':1.0, + 'add_err1':1e3, + 'thetaE': 1.0, + 'piS': 1.0, + 'muS_E': 1.0, + 'muS_N': 1.0, + 'xS0_E': 1e3, + 'xS0_N': 1e3, + 'b_sff2': 1.0, + 'mag_src2':1.0, + 'mag_base2':1.0, + 'add_err2':1e3, + 'mL': 1.0, + 'piL': 1.0, + 'piRel': 1.0, + 'muL_E': 1.0, + 'muL_N': 1.0, + 'muRel_E': 1.0, + 'muRel_N': 1.0, + 'gp_log_sigma1': 1.0, + 'gp_rho1': 1.0, + 'gp_log_omega04_S01': 1.0, + 'gp_log_omega01': 1.0 + } + sig_digits = {'t0': '0.2f', + 'u0_amp': '0.2f', + 'tE': '0.1f', + 'piE_E': '0.3f', + 'piE_N': '0.3f', + 'b_sff1': '0.3f', + 'mag_src1': '0.3f', + 'mag_base1': '0.3f', + 'add_err1': '0.1f', + 'thetaE': '0.2f', + 'piS': '0.3f', + 'muS_E': '0.2f', + 'muS_N': '0.2f', + 'xS0_E': '0.2f', + 'xS0_N': '0.2f', + 'b_sff2': '0.2f', + 'mag_src2': '0.2f', + 'mag_base2': '0.2f', + 'add_err2': '0.1f', + 'mL': '0.1f', + 'piL': '0.3f', + 'piRel': '0.3f', + 'muL_E': '0.2f', + 'muL_N': '0.2f', + 'muRel_E': '0.2f', + 'muRel_N': '0.2f', + 'gp_log_sigma1': '0.1f', + 'gp_rho1': '0.1f', + 'gp_log_omega04_S01': '0.1f', + 'gp_log_omega01': '0.1f' + } + + pho_u0m = 0 + pho_u0p = 1 + + tab_file = open(paper_dir + target + '_OGLE_phot.txt', 'w') + tab_file.write('log$\mathcal{L}$ ' + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_pho['MaxLike_logL'][pho_u0p], + stats_pho['MAP_logL'][pho_u0p], + stats_pho['Med_logL'][pho_u0p]) + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_pho['MaxLike_logL'][pho_u0m], + stats_pho['MAP_logL'][pho_u0m], + stats_pho['Med_logL'][pho_u0m]) + + ' \\\ \n') + tab_file.write('$\tilde{\chi}^2$ ' + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_pho['MaxLike_rchi2'][pho_u0p], + stats_pho['MAP_rchi2'][pho_u0p], + stats_pho['Med_rchi2'][pho_u0p]) + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_pho['MaxLike_rchi2'][pho_u0m], + stats_pho['MAP_rchi2'][pho_u0m], + stats_pho['Med_rchi2'][pho_u0m]) + + ' \\\ \n') + tab_file.write('log$\mathcal{Z}$ ' + + '& & & {0:.1f} & '.format(stats_pho['logZ'][pho_u0p]) + + '& & & {0:.1f} & '.format(stats_pho['logZ'][pho_u0m]) + + ' \\\ \n') + tab_file.write('$N_{dof}$ ' + + '& & & {0:.0f} & '.format(stats_pho['N_dof'][pho_u0p]) + + '& & & {0:.0f} & '.format(stats_pho['N_dof'][pho_u0m]) + + ' \\\ \n' + + r'\hline ' + '\n') + + # Keep track of when we finish off the fitted parameters (vs. additional parameters). + start_extra_params = False + + for key, label in labels.items(): + # We will have 4 solutions... each has a value and error bar. + # Setup an easy way to walk through them (and rescale) as necessary. + val_dict = [stats_pho, stats_pho] + val_mode = [pho_u0p, pho_u0m] + + if 'break' in key: + tab_file.write('\\tableline\n') + + tab_file.write(label) + + for ss in range(len(val_dict)): + stats = val_dict[ss] + + if ('MaxLike_' + key in stats.colnames): + fmt = ' & {0:' + sig_digits[key] + '} & {1:' + sig_digits[key] + '} ' + fmt += '& {2:' + sig_digits[key] + '} & [{3:' + sig_digits[key] + '}, {4:' + sig_digits[key] + '}] ' + + val_mli = stats['MaxLike_' + key][val_mode[ss]] + val_map = stats['MAP_' + key][val_mode[ss]] + val_med = stats['Med_' + key][val_mode[ss]] + elo = stats['lo68_' + key][val_mode[ss]] - stats['Med_' + key][val_mode[ss]] + ehi = stats['hi68_' + key][val_mode[ss]] - stats['Med_' + key][val_mode[ss]] + + val_mli *= scale[key] + val_map *= scale[key] + val_med *= scale[key] + elo *= scale[key] + ehi *= scale[key] + + tab_file.write(fmt.format(val_mli, val_map, val_med, elo, ehi)) + else: + fmt = ' & & & & ' + tab_file.write(fmt) + + tab_file.write(' \\\ \n') + + return + + + + +def table_ob150211_phot_astrom(): + # Load up the params file so we know what kind of + # data and model we are working with. Note that we + # are assuming that all the Nruns are using the same + # parameters. + target = 'ob150211' + + stats_ast, data_ast, mod_ast = load_summary_statistics(pspl_ast_multiphot[target]) + + # No longer using + # 'add_err1': '$\\varepsilon_{a,I}$ (mmag)', + # 'add_err2': '$\\varepsilon_{a,Kp}$ (mmag)', + + # This dictionary sets the order of the parameters in the table. + # If I want a horizontal line in between the two, I just add 'break#' where + # the "#" symbol is just any arbitrary number. + labels = {'t0': '$t_0$ (MJD)', + 'u0_amp': '$u_0$', + 'tE': '$t_E$ (days)', + 'piE_E': '$\pi_{E,E}$', + 'piE_N': '$\pi_{E,N}$', + 'b_sff1': '$b_{SFF,I}$', + 'mag_base1': '$I_{base}$ (mag)', + 'b_sff2': '$b_{SFF,Kp}$', + 'mag_base2': '$Kp_{base}$ (mag)', + 'thetaE': '$\\theta_E$ (mas)', + 'piS': '$\pi_S$ (mas)', + 'muS_E': '$\mu_{S,\\alpha*}$ (mas/yr)', + 'muS_N': '$\mu_{S,\delta}$ (mas/yr)', + 'xS0_E': '$x_{S0,\\alpha*}$ (mas)', + 'xS0_N': '$x_{S0,\delta}$ (mas)', + 'break1': '', + 'mL': '$M_L$ ($\msun$)', + 'piL': '$\pi_L$ (mas)', + 'piRel': '$\pi_{rel}$ (mas)', + 'muL_E': '$\mu_{L,\\alpha*}$ (mas/yr)', + 'muL_N': '$\mu_{L,\delta}$ (mas/yr)', + 'muRel_E': '$\mu_{rel,\\alpha*}$ (mas/yr)', + 'muRel_N': '$\mu_{rel,\delta}$ (mas/yr)', + 'mag_src1': '$I_{src}$ (mag)', + 'mag_src2': '$Kp_{src}$ (mag)' + # 'break2': '', + # 'gp_log_sigma1': '$\log \sigma_{GP, I} (mag)$', + # 'gp_rho1': '$\\rho_{GP, I}$ (days)', + # 'gp_log_omega04_S01': '$\log S_{0, GP, I} \omega_{0, GP, I}^4$ (mag$^2$ days$^{-2}$)', + # 'gp_log_omega01': '$\log \omega_{0, GP, I}$ (days$^{-1}$)' + } + + scale = {'t0': 1.0, + 'u0_amp': 1.0, + 'tE': 1.0, + 'piE_E': 1.0, + 'piE_N': 1.0, + 'b_sff1': 1.0, + 'mag_src1':1.0, + 'mag_base1':1.0, + 'add_err1':1e3, + 'thetaE': 1.0, + 'piS': 1.0, + 'muS_E': 1.0, + 'muS_N': 1.0, + 'xS0_E': 1e3, + 'xS0_N': 1e3, + 'b_sff2': 1.0, + 'mag_src2':1.0, + 'mag_base2':1.0, + 'add_err2':1e3, + 'mL': 1.0, + 'piL': 1.0, + 'piRel': 1.0, + 'muL_E': 1.0, + 'muL_N': 1.0, + 'muRel_E': 1.0, + 'muRel_N': 1.0, + 'gp_log_sigma1': 1.0, + 'gp_rho1': 1.0, + 'gp_log_omega04_S01': 1.0, + 'gp_log_omega01': 1.0 + } + sig_digits = {'t0': '0.2f', + 'u0_amp': '0.2f', + 'tE': '0.1f', + 'piE_E': '0.3f', + 'piE_N': '0.3f', + 'b_sff1': '0.3f', + 'mag_src1': '0.3f', + 'mag_base1': '0.3f', + 'add_err1': '0.1f', + 'thetaE': '0.2f', + 'piS': '0.3f', + 'muS_E': '0.2f', + 'muS_N': '0.2f', + 'xS0_E': '0.2f', + 'xS0_N': '0.2f', + 'b_sff2': '0.2f', + 'mag_src2': '0.2f', + 'mag_base2': '0.2f', + 'add_err2': '0.1f', + 'mL': '0.1f', + 'piL': '0.3f', + 'piRel': '0.3f', + 'muL_E': '0.2f', + 'muL_N': '0.2f', + 'muRel_E': '0.2f', + 'muRel_N': '0.2f', + 'gp_log_sigma1': '0.1f', + 'gp_rho1': '0.1f', + 'gp_log_omega04_S01': '0.1f', + 'gp_log_omega01': '0.1f' + } + + ast_u0m = 0 # neg u0 + #ast_u0p_lo = 1 # lo muRel + ast_u0p = 1 # pos u0 + + tab_file = open(paper_dir + target + '_OGLE_phot_ast.txt', 'w') + tab_file.write('log$\mathcal{L}$ ' + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_ast['MaxLike_logL'][ast_u0m], + stats_ast['MAP_logL'][ast_u0m], + stats_ast['Med_logL'][ast_u0m]) + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_ast['MaxLike_logL'][ast_u0p], + stats_ast['MAP_logL'][ast_u0p], + stats_ast['Med_logL'][ast_u0p]) +# + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_ast['MaxLike_logL'][ast_u0m_al], +# stats_ast['MAP_logL'][ast_u0m_al], +# stats_ast['Med_logL'][ast_u0m_al]) + + ' \\\ \n') + tab_file.write('$\tilde{\chi}^2$ ' + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_ast['MaxLike_rchi2'][ast_u0m], + stats_ast['MAP_rchi2'][ast_u0m], + stats_ast['Med_rchi2'][ast_u0m]) + + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_ast['MaxLike_rchi2'][ast_u0p], + stats_ast['MAP_rchi2'][ast_u0p], + stats_ast['Med_rchi2'][ast_u0p]) +# + '& {0:.2f} & {1:.2f} & {2:.2f} & '.format(stats_ast['MaxLike_rchi2'][ast_u0m_al], +# stats_ast['MAP_rchi2'][ast_u0m_al], +# stats_ast['Med_rchi2'][ast_u0m_al]) + + ' \\\ \n') + tab_file.write('log$\mathcal{Z}$ ' + + '& & & {0:.1f} & '.format(stats_ast['logZ'][ast_u0m]) + + '& & & {0:.1f} & '.format(stats_ast['logZ'][ast_u0p]) +# + '& & & {0:.1f} & '.format(stats_ast['logZ'][ast_u0m_al]) + + ' \\\ \n') + tab_file.write('$N_{dof}$ ' + + '& & & {0:.0f} & '.format(stats_ast['N_dof'][ast_u0m]) + + '& & & {0:.0f} & '.format(stats_ast['N_dof'][ast_u0p]) +# + '& & & {0:.0f} & '.format(stats_ast['N_dof'][ast_u0m_al]) + + ' \\\ \n') + prior_vol, logBF = calc_bayes_factor('ob150211') + tab_file.write('$\pi-$volume ' + + '& & & {0:.2f} & '.format(prior_vol[ast_u0m]) + + '& & & {0:.2f} & '.format(prior_vol[ast_u0p]) +# + '& & & {0:.2f} & '.format(prior_vol[ast_u0m_al]) + + ' \\\ \n' + + r'\hline ' + '\n') + + # Keep track of when we finish off the fitted parameters (vs. additional parameters). + start_extra_params = False + + for key, label in labels.items(): + # We will have 4 solutions... each has a value and error bar. + # Setup an easy way to walk through them (and rescale) as necessary. + val_dict = [stats_ast, stats_ast] #, stats_ast] + val_mode = [ast_u0m, ast_u0p] + + if 'break' in key: + tab_file.write('\\tableline\n') + + tab_file.write(label) + + for ss in range(len(val_dict)): + stats = val_dict[ss] + + if ('MaxLike_' + key in stats.colnames): + fmt = ' & {0:' + sig_digits[key] + '} & {1:' + sig_digits[key] + '} ' + fmt += '& {2:' + sig_digits[key] + '} & [{3:' + sig_digits[key] + '}, {4:' + sig_digits[key] + '}] ' + + val_mli = stats['MaxLike_' + key][val_mode[ss]] + val_map = stats['MAP_' + key][val_mode[ss]] + val_med = stats['Med_' + key][val_mode[ss]] + elo = stats['lo68_' + key][val_mode[ss]] - stats['Med_' + key][val_mode[ss]] + ehi = stats['hi68_' + key][val_mode[ss]] - stats['Med_' + key][val_mode[ss]] + + val_mli *= scale[key] + val_map *= scale[key] + val_med *= scale[key] + elo *= scale[key] + ehi *= scale[key] + + tab_file.write(fmt.format(val_mli, val_map, val_med, elo, ehi)) + else: + fmt = ' & & & & ' + tab_file.write(fmt) + + tab_file.write(' \\\ \n') + + return + + +def results_best_params_all(): + targets = ['ob120169', 'ob140613', 'ob150029', 'ob150211'] + + params = ['t0', 'u0_amp', 'tE', 'thetaE', 'mL', + 'piE_E', 'piE_N', + 'muRel_E', 'muRel_N', 'muS_E', 'muS_N', 'muL_E', 'muL_N', + 'piS', 'piL', 'piRel', + 'xS0_E', 'xS0_N', + 'b_sff1', 'mag_src1', + 'b_sff2', 'mag_src2'] + # , 'add_err1', 'add_err2' + + fmt = ' {0:13s} = {1:12.4f} {2:12.4f} {3:12.4f} [{4:12.4f} - {5:12.4f}] [{6:12.4f} - {7:12.4f}]' + + def get_68CI(samples, weights): + sumweights = np.sum(weights) + tmp_weights = weights / sumweights + + sig1 = 0.682689 + sig1_lo = (1. - sig1) / 2. + sig1_hi = 1. - sig1_lo + + tmp = model_fitter.weighted_quantile(samples, [sig1_lo, sig1_hi], + sample_weight = tmp_weights) + + return tmp[0], tmp[1] + + def get_99CI(samples, weights): + sumweights = np.sum(weights) + tmp_weights = weights / sumweights + + sig1 = 0.9973 + sig1_lo = (1. - sig1) / 2. + sig1_hi = 1. - sig1_lo + + tmp = model_fitter.weighted_quantile(samples, [sig1_lo, sig1_hi], + sample_weight = tmp_weights) + + return tmp[0], tmp[1] + + + + for targ in targets: + print('') + print('**********') + print('Best-Fit (Max L, MAP, Median, 68.3% CI, 99.7% CI) Parameters for ', targ) + print('**********') + stats_ast, data_ast, mod_ast = load_summary_statistics(pspl_ast_multiphot[targ]) + + # Find the best-fit solution + mdx = pspl_ast_multiphot_mode[targ] + + print('* NOTE Best solution is idx = ', mdx) + + for par in params: + if targ == 'ob140613' and par.startswith('add'): + par = par.replace('add', 'mult') + + print(fmt.format(par, stats_ast['MaxLike_' + par][mdx], + stats_ast['MAP_' + par][mdx], + stats_ast['Med_' + par][mdx], + stats_ast['lo68_' + par][mdx], + stats_ast['hi68_' + par][mdx], + stats_ast['lo99_' + par][mdx], + stats_ast['hi99_' + par][mdx])) + + # Print a few more summary params + muRel_mli = np.hypot(stats_ast['MaxLike_muRel_E'][mdx], stats_ast['MaxLike_muRel_N'][mdx]) + muRel_map = np.hypot(stats_ast['MAP_muRel_E'][mdx], stats_ast['MAP_muRel_N'][mdx]) + muRel_med = np.hypot(stats_ast['Med_muRel_E'][mdx], stats_ast['Med_muRel_N'][mdx]) + + piE_mli = np.hypot(stats_ast['MaxLike_piE_E'][mdx], stats_ast['MaxLike_piE_N'][mdx]) + piE_map = np.hypot(stats_ast['MAP_piE_E'][mdx], stats_ast['MAP_piE_N'][mdx]) + piE_med = np.hypot(stats_ast['Med_piE_E'][mdx], stats_ast['Med_piE_N'][mdx]) + + u0_mli = stats_ast['MaxLike_u0_amp'][mdx] + u0_map = stats_ast['MAP_u0_amp'][mdx] + u0_med = stats_ast['Med_u0_amp'][mdx] + + thetaE_mli = stats_ast['MaxLike_thetaE'][mdx] + thetaE_map = stats_ast['MAP_thetaE'][mdx] + thetaE_med = stats_ast['Med_thetaE'][mdx] + + Amp_mli = (u0_mli**2 + 2.0) / (np.abs(u0_mli) * np.sqrt(u0_mli**2 + 4.0)) + Amp_map = (u0_map**2 + 2.0) / (np.abs(u0_map) * np.sqrt(u0_map**2 + 4.0)) + Amp_med = (u0_med**2 + 2.0) / (np.abs(u0_med) * np.sqrt(u0_med**2 + 4.0)) + + deltaC_mli = thetaE_mli * 2**0.5 / 4.0 + deltaC_map = thetaE_map * 2**0.5 / 4.0 + deltaC_med = thetaE_med * 2**0.5 / 4.0 + + # Actually fetch the samples to calculate the errors on these. + fitter, data = get_data_and_fitter(pspl_ast_multiphot[targ]) + samps_list = fitter.load_mnest_modes() + samps = samps_list[mdx] + + muRel_samp = np.hypot(samps['muRel_E'], samps['muRel_N']) + piE_samp = np.hypot(samps['piE_E'], samps['piE_N']) + + # Add thetaE (from log thetaE) + if ('log10_thetaE' in samps.colnames) and ('thetaE' not in samps.colnames): + thetaE_samp = 10**samps['log10_thetaE'] + else: + thetaE_samp = samps['thetaE'] + u0 = samps['u0_amp'] + Amp_samp = (u0**2 + 2.0) / (np.abs(u0) * np.sqrt(u0**2 + 4.0)) + deltaC_samp = thetaE_samp * 2**0.5 / 4.0 + + muRel_lo1, muRel_hi1 = get_68CI(muRel_samp, samps['weights']) + piE_lo1, piE_hi1 = get_68CI(piE_samp, samps['weights']) + Amp_lo1, Amp_hi1 = get_68CI(Amp_samp, samps['weights']) + deltaC_lo1, deltaC_hi1 = get_68CI(deltaC_samp, samps['weights']) + + muRel_lo3, muRel_hi3 = get_99CI(muRel_samp, samps['weights']) + piE_lo3, piE_hi3 = get_99CI(piE_samp, samps['weights']) + Amp_lo3, Amp_hi3 = get_99CI(Amp_samp, samps['weights']) + deltaC_lo3, deltaC_hi3 = get_99CI(deltaC_samp, samps['weights']) + + print(fmt.format('muRel', muRel_mli, muRel_map, muRel_med, muRel_lo1, muRel_hi1, muRel_lo3, muRel_hi3)) + print(fmt.format('piE', piE_mli, piE_map, piE_med, piE_lo1, piE_hi1, piE_lo3, piE_hi3)) + print(fmt.format('A', Amp_mli, Amp_map, Amp_med, Amp_lo1, Amp_hi1, Amp_lo3, Amp_hi3)) + print(fmt.format('deltaC_max', deltaC_mli, deltaC_map, deltaC_med, deltaC_lo1, deltaC_hi1, deltaC_lo3, deltaC_hi3)) + + return + +def plot_mass_posterior(target): + fontsize1 = 18 + fontsize2 = 14 + + fitter, data = get_data_and_fitter(pspl_ast_multiphot[target]) + stats = calc_summary_statistics(fitter) + tab = fitter.load_mnest_modes() + + # Find the best-fit solution + mdx = pspl_ast_multiphot_mode[target] + tab = tab[mdx] + stats = stats[mdx] + + plt.figure(1) + plt.clf() + plt.subplots_adjust(bottom = 0.15) + + bins = np.logspace(-3, 2, 100) + + n, b = np.histogram(tab['mL'], bins = bins, + weights = tab['weights'], density = False) + + # n = norm_kde(n, 10.) + b0 = 0.5 * (b[1:] + b[:-1]) + + # n, b, _ = plt.hist(b0, bins = b, weights = n) + plt.plot(b0, n, drawstyle='steps-mid') + + plt.xlabel('Lens Mass $(M_\odot)$', fontsize=fontsize1, labelpad=10) + plt.ylabel('Posterior Probability', fontsize=fontsize1, labelpad=10) + plt.xticks(fontsize=fontsize2) + plt.yticks(fontsize=fontsize2) + + plt.xscale('log') + + plt.axvline(stats['MaxLike_mL'], color='k', linestyle='-', lw = 2) + plt.axvline(stats['lo68_mL'], color='k', linestyle='--', lw = 2) + plt.axvline(stats['hi68_mL'], color='k', linestyle='--', lw = 2) + plt.xlim(0.1, 60) + plt.ylim(0, 1.1*n.max()) + plt.title(target) + + plt.savefig(paper_dir + target + '_mass_posterior.png') + + return + +def get_CIs(samples, weights): + sumweights = np.sum(weights) + tmp_weights = weights / sumweights + + sig1 = 0.682689 + sig2 = 0.9545 + sig3 = 0.9973 + sig1_lo = (1. - sig1) / 2. + sig2_lo = (1. - sig2) / 2. + sig3_lo = (1. - sig3) / 2. + sig1_hi = 1. - sig1_lo + sig2_hi = 1. - sig2_lo + sig3_hi = 1. - sig3_lo + + tmp = model_fitter.weighted_quantile(samples, [sig1_lo, sig1_hi, sig2_lo, sig2_hi, sig3_lo, sig3_hi], + sample_weight = tmp_weights) + + return tmp + + + +def plot_all_mass_posteriors(sol_mode='best'): + fontsize1 = 18 + fontsize2 = 14 + + targets = ['ob120169', 'ob140613', 'ob150029', 'ob150211'] + colors = {'ob120169': 'purple', + 'ob140613': 'red', + 'ob150029': 'darkorange', + 'ob150211': 'black'} + kde_bw = {'ob120169': 0.1, + 'ob140613': 0.2, + 'ob150029': 0.1, + 'ob150211': 0.1} + + plt.close(1) + plt.figure(1) + plt.clf() + plt.subplots_adjust(bottom = 0.15) + + for target in targets: + fitter, data = get_data_and_fitter(pspl_ast_multiphot[target]) + stats = calc_summary_statistics(fitter) + tab = fitter.load_mnest_modes() + + # Select out the best mode. + mode = pspl_ast_multiphot_mode[target] + stats = stats[mode] + + if sol_mode == 'best': + tab = tab[mode] + elif sol_mode == 'global': + tab = fitter.load_mnest_results() + + # KDE + kde = scipy.stats.gaussian_kde(np.log10(tab['mL']), + weights=tab['weights'], + bw_method=kde_bw[target]) + kde_mass = np.linspace(-2, 2, 500) + # kde_mass = np.arange(0.0, 10, 0.01) + kde_prob = kde(kde_mass) + kde_bin_size = np.zeros(len(kde_prob), dtype=float) + kde_bin_size[:-1] = np.diff(kde_mass) + kde_bin_size[-1] = kde_bin_size[-2] + kde_norm = (kde_prob * kde_bin_size).sum() + kde_prob /= kde_norm + + # Normalize kde_prob + # kde_prob /= kde_prob.max() + plt.plot(kde_mass, kde_prob, color=colors[target], linestyle='-', label=target.upper()) + + # Bins for the histogram + bins = np.linspace(-2, 2, 80) + # bins = np.linspace(00, 10, 0.1) + # bins = np.arange(0.0, 10, 0.1) + + n, b = np.histogram(np.log10(tab['mL']), bins = bins, + weights = tab['weights'], density = True) + b0 = 0.5 * (b[1:] + b[:-1]) + # n /= n.max() + + # plt.plot(b[:-1], n, drawstyle='steps-mid', + # color=colors[target], label=target) + + # plt.xscale('log') + + # plt.axvline(stats['MaxLike_mL'], color=colors[target], linestyle='--', lw = 2) + plt.axvline(np.log10(stats['Med_mL']), color=colors[target], linestyle='--', lw = 2) + # plt.axvline(np.log10(stats['MAP_mL']), color=colors[target], linestyle='--', lw = 2) + # plt.axvline(np.log10(stats['MaxLike_mL']), color=colors[target], linestyle='-.', lw = 2) + # plt.axvline(stats['lo68_mL'], color=colors[target], linestyle='--', lw = 2) + # plt.axvline(stats['hi68_mL'], color=colors[target], linestyle='--', lw = 2) + + conf_int = get_CIs(tab['mL'], tab['weights']) + print('Best-Fit Lens Mass MaxLike = {0:.2f} for {1:s}'.format(stats['MaxLike_mL'], target)) + print('Best-Fit Lens Mass MAP = {0:.2f} for {1:s}'.format(stats['MAP_mL'], target)) + print('Best-Fit Lens Mass Median = {0:.2f} for {1:s}'.format(stats['Med_mL'], target)) + print('Best-Fit Lens Mass Mean = {0:.2f} for {1:s}'.format(stats['Mean_mL'], target)) + print(' 68.3% CI = [{0:6.2f} - {1:6.2f}]'.format(conf_int[0], conf_int[1])) + print(' 95.5% CI = [{0:6.2f} - {1:6.2f}]'.format(conf_int[2], conf_int[3])) + print(' 99.7% CI = [{0:6.2f} - {1:6.2f}]'.format(conf_int[4], conf_int[5])) + + plt.xlabel('Lens Mass $(M_\odot)$', fontsize=fontsize1, labelpad=10) + plt.ylabel('Posterior Probability', fontsize=fontsize1, labelpad=10) + plt.xticks(fontsize=fontsize2) + plt.yticks(fontsize=fontsize2) + plt.xlim(-1.1, 2.0) + plt.tick_params(axis='x', which='minor') + # plt.ylim(0, 2) + # plt.xlim(0, 5) + plt.ylim(0, 5) + plt.legend() + + def pow_10(x, pos): + """The two args are the value and tick position. + Label ticks with the product of the exponentiation""" + return '%0.1f' % (10**x) + + formatter = plt.FuncFormatter(pow_10) + plt.gca().xaxis.set_major_formatter(formatter) + + x_minor = matplotlib.ticker.FixedLocator([np.log10(mm) for mm in np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, + 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, + 10, 20, 30, 40, 50, 60, 70, 80, 90, 100])]) + plt.gca().xaxis.set_minor_locator(x_minor) + plt.gca().xaxis.set_minor_formatter(plt.NullFormatter()) + + if sol_mode == 'global': + plt.savefig(paper_dir + 'all_mass_posteriors_' + mode + '.png') + else: + plt.savefig(paper_dir + 'all_mass_posteriors.png') + + return + +def plot_ob150211_mass_posterior_modes(): + fontsize1 = 18 + fontsize2 = 14 + + target = 'ob150211' + colors = ['black', 'orange'] #'purple', + kde_bw = {'ob150211': 0.1} + + plt.close(1) + plt.figure(1) + plt.clf() + plt.subplots_adjust(bottom = 0.15) + + fitter, data = get_data_and_fitter(pspl_ast_multiphot[target]) + stats_list = calc_summary_statistics(fitter) + tab_list = fitter.load_mnest_modes() + + for ii in range(len(stats_list)): + stats = stats_list[ii] + tab = tab_list[ii] + + # KDE + kde = scipy.stats.gaussian_kde(np.log10(tab['mL']), + weights=tab['weights'], + bw_method=kde_bw[target]) + kde_mass = np.linspace(-2, 2, 500) + # kde_mass = np.arange(0.0, 10, 0.01) + kde_prob = kde(kde_mass) + kde_bin_size = np.zeros(len(kde_prob), dtype=float) + kde_bin_size[:-1] = np.diff(kde_mass) + kde_bin_size[-1] = kde_bin_size[-2] + kde_norm = (kde_prob * kde_bin_size).sum() + kde_prob /= kde_norm + + # Normalize kde_prob + # kde_prob /= kde_prob.max() + leg_label = f'{target.upper()}, ' + if ii == 0: + leg_label += '$u_0 < 0$' + elif ii == 1: + leg_label += '$u_0 > 0$' +# if ii == 0: +# leg_label += '$u_0 > 0$, high $\mu_{{rel}}$' +# elif ii == 1: +# leg_label += '$u_0 > 0$, low $\mu_{{rel}}$' +# elif ii == 2: +# leg_label += '$u_0 <= 0$' + plt.plot(kde_mass, kde_prob, color=colors[ii], linestyle='-', label=leg_label) + + # Bins for the histogram + bins = np.linspace(-2, 2, 80) + + n, b = np.histogram(np.log10(tab['mL']), bins = bins, + weights = tab['weights'], density = True) + b0 = 0.5 * (b[1:] + b[:-1]) + + + plt.axvline(np.log10(stats['Med_mL']), color=colors[ii], linestyle='--', lw = 2) + + conf_int = get_CIs(tab['mL'], tab['weights']) + print('Best-Fit Lens Mass MaxLike = {0:.2f} for {1:s}'.format(stats['MaxLike_mL'], target)) + print('Best-Fit Lens Mass MAP = {0:.2f} for {1:s}'.format(stats['MAP_mL'], target)) + print('Best-Fit Lens Mass Median = {0:.2f} for {1:s}'.format(stats['Med_mL'], target)) + print('Best-Fit Lens Mass Mean = {0:.2f} for {1:s}'.format(stats['Mean_mL'], target)) + print(' 68.3% CI = [{0:6.2f} - {1:6.2f}]'.format(conf_int[0], conf_int[1])) + print(' 95.5% CI = [{0:6.2f} - {1:6.2f}]'.format(conf_int[2], conf_int[3])) + print(' 99.7% CI = [{0:6.2f} - {1:6.2f}]'.format(conf_int[4], conf_int[5])) + + plt.xlabel('Lens Mass $(M_\odot)$', fontsize=fontsize1, labelpad=10) + plt.ylabel('Posterior Probability', fontsize=fontsize1, labelpad=10) + plt.xticks(fontsize=fontsize2) + plt.yticks(fontsize=fontsize2) + plt.xlim(-1.1, 2.0) + plt.tick_params(axis='x', which='minor') + # plt.ylim(0, 2) + # plt.xlim(0, 5) + plt.ylim(0, 1.8) + plt.legend() + + def pow_10(x, pos): + """The two args are the value and tick position. + Label ticks with the product of the exponentiation""" + return '%0.1f' % (10**x) + + formatter = plt.FuncFormatter(pow_10) + plt.gca().xaxis.set_major_formatter(formatter) + + x_minor = matplotlib.ticker.FixedLocator([np.log10(mm) for mm in np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, + 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, + 10, 20, 30, 40, 50, 60, 70, 80, 90, 100])]) + plt.gca().xaxis.set_minor_locator(x_minor) + plt.gca().xaxis.set_minor_formatter(plt.NullFormatter()) + + plt.savefig(paper_dir + 'ob150211_mass_posterior_modes.png') + + return + + +def make_pBH_detect_table(): + """ + Calculate the probability of getting N BH detections in PopSyCLE, + based on the tE of the event. + """ + # Get array of tE for each target. + tE = {} + targets = ['ob110022', 'ob120169', 'ob140613', 'ob150029', 'ob150211'] + for ii, target in enumerate(targets): + # Load up phot and ast results. + if target == 'ob110022': + tE[target] = [61.4, 58.7, 64.1] + continue + + # Also fetch our best fit and figure out the source and lens/neighbor + # brightness. + foo = get_data_fitter_params_models_samples(target, return_mode = 'global') + fitter = foo[0] + data = foo[1] + stats = foo[2] + params = foo[3] + models = foo[4] + mnest_results = foo[5][0] + + weights = mnest_results['weights'] + + # 3 sigma. + sig3 = 0.9973 + sig3_lo = (1.0 - sig3) / 2.0 + sig3_hi = 1.0 - sig3_lo + + # 1 sigma. + sig1 = 0.682689 + sig1_lo = (1.0 - sig1) / 2.0 + sig1_hi = 1.0 - sig1_lo + + # Calculate the median and quantiles. + tE[target] = model_fitter.weighted_quantile(mnest_results['tE'], + [0.5, sig3_lo, sig3_hi], + sample_weight=weights) + + def calc_fraction(t, mintE, maxtE): + """ + Calculate the fraction of long duration events + that have black hole lenses, assuming Poisson errors. + """ + + not_bh_idx = np.where((t['t_E'] > mintE) & + (t['t_E'] < maxtE) & + (t['rem_id_L'] != 103))[0] + + bh_idx = np.where((t['t_E'] > mintE) & + (t['t_E'] < maxtE) & + (t['rem_id_L'] == 103))[0] + + frac = len(bh_idx)/(len(not_bh_idx) + len(bh_idx)) + + return frac + + t = Table.read('/u/casey/scratch/papers/microlens_2019/popsycle_rr_files/Mock_EWS_v2_NEW_DELTAM.fits') + + # Array of success probabilities for each target, given it's tE. + # Success = probability of a BH with mass 5 < M < 15 Msun. + # pi_arr = using the median value + pi_arr = np.zeros(len(targets)) + + pk_arr = np.zeros(len(targets) + 1) + + # Delete old file if exists + table_file = paper_dir + 'tE_bh_prob.txt' + if os.path.exists(table_file): + os.remove(table_file) + + with open(table_file, 'a+') as tb: + for ii, target in enumerate(targets): + min_tE = tE[target][1] + max_tE = tE[target][2] + frac = calc_fraction(t, min_tE, max_tE) + print('{0} ({1:.1f} days < tE < {2:.2f} days) : {3:.0f}% BHs'.format(target, + min_tE, max_tE, + 100*frac)) + pi_arr[ii] = frac + + # HACK + if target == 'ob140613': + pi_arr[ii] = 0.99 + + tb.write('{0} & ${1:.0f} < t_E < {2:.0f}$ days & ' \ + '{3:.0f} \\\ \n'.format(target, + min_tE, max_tE, + 100*frac)) + + + # Delete old file if exists + table_file = paper_dir + 'ndetect_bh_prob.txt' + if os.path.exists(table_file): + os.remove(table_file) + + with open(table_file, 'a+') as tb: + # Calculate probabilities + sum = 0 + for i in np.arange(6): + sum += calc_pk(i, pi_arr) + print('P(K={0}) = {1}'. format(i, calc_pk(i, pi_arr))) + + tb.write('{0} & {1:.0f} \\\ \n'.format(i, 100*calc_pk(i, pi_arr))) + + pk_arr[i] = calc_pk(i, pi_arr) + + print('Total probability (should be 1!): ', sum) + if np.isnan(sum): + pdb.set_trace() + + # I THINK PLT.STAIRS IS WHAT I WANT IN THIS CASE BUT IT KEEPS THROWING THIS ERROR + # AttributeError: module 'matplotlib.pyplot' has no attribute 'stairs' + # (I get the same thing on my laptop too... I don't get it.) + # So this code is basically my hack version of plt.stairs... + plt.close('all') + plt.figure(1) + plt.clf() + + # Use step to get the bars, and fill in the missing bits with vlines and hlines + plt.step(np.arange(6), pk_arr, color='k', lw=2.5, where='mid') + plt.vlines(x=-0.5, ymin=0, ymax=pk_arr[0], color='k', lw=2.5) + plt.vlines(x=5.5, ymin=0, ymax=pk_arr[5], color='k', lw=2.5) + plt.hlines(y=pk_arr[0], xmin=-0.5, xmax=0, color='k', lw=2.5) + plt.hlines(y=pk_arr[5], xmin=5, xmax=5.5, color='k', lw=2.5, label='Theory') + plt.fill_between([-0.5, 1.5], [0, 0], [0.6, 0.6], color='red', alpha=0.2, label='Observation') + + # Shading + plt.bar(np.arange(6), pk_arr, alpha=0.1, color='k', width=1, + tick_label=['0', '1', '2', '3', '4', '5']) + + plt.ylim(0, 0.5) + plt.xlabel('$N_{BH}$') + plt.ylabel('Probability') + plt.legend(loc='upper right') + plt.savefig(paper_dir + 'ndetect_bh_prob.png') + + return + + + +def calc_pk(k, pi_arr): + """ + Implementing the recursive formula for the Poisson binomial distribution + described here: https://www.jstor.org/stable/2683639 + https://en.wikipedia.org/wiki/Poisson_binomial_distribution + + k = number of successes + pi_arr = array of the success probabilities. + len(pi_arr) = number of independent yes/no experiments + """ + def calc_Ti(i): + T = 0 + for pi in pi_arr: + term_j = (pi/(1 - pi))**i + T += term_j + + return T + + if k == 0: + pk = 1 + for pi in pi_arr: + pk *= (1 - pi) + return pk + + else: + pk = 0 + for i in (np.arange(k)[::-1] + 1): + pi = ((-1)**(i-1) * calc_pk(k-i, pi_arr) * calc_Ti(i)) + pk += pi + return pk/k + + + +def plot_trace_corner(target): + labels = {'t0': '$t_0$ (MJD)', + 'u0_amp': '$u_0$', + 'tE': '$t_E$ (days)', + 'piE_E': '$\pi_{E,E}$', + 'piE_N': '$\pi_{E,N}$', + 'piE': '$\pi_{E}$', + 'b_sff1': '$b_{SFF,I}$', + 'mag_src1': '$I_{src}$ (mag)', + 'mag_base1': '$I_{base}$ (mag)', + 'mult_err1': '$\\varepsilon_{m,I}$', + 'add_err1': '$\\varepsilon_{a,I}$ (mmag)', + 'thetaE_amp':'$\\theta_E$ (mas)', + 'thetaE': '$\\theta_E$ (mas)', + 'log10_thetaE':'$\log_{10} [\\theta_E$ (mas)]', + 'piS': '$\pi_S$ (mas)', + 'muS_E': '$\mu_{S,\\alpha*}$ (mas/yr)', + 'muS_N': '$\mu_{S,\delta}$ (mas/yr)', + 'xS0_E': '$x_{S0,\\alpha*}$ (mas)', + 'xS0_N': '$x_{S0,\delta}$ (mas)', + 'b_sff2': '$b_{SFF,Kp}$', + 'mag_src2': '$Kp_{src}$ (mag)', + 'mag_base2': '$Kp_{base}$ (mag)', + 'mult_err2': '$\\varepsilon_{m,Kp}$', + 'add_err2': '$\\varepsilon_{a,Kp}$ (mmag)', + 'mL': '$M_L (M_\odot)$', + 'log_mL': '$\log_{10} [M_L (M_\odot)]$', + 'piL': '$\pi_L$ (mas)', + 'piRel': '$\pi_{rel}$ (mas)', + 'muL_E': '$\mu_{L,\\alpha*}$ (mas/yr)', + 'muL_N': '$\mu_{L,\delta}$ (mas/yr)', + 'muRel_E': '$\mu_{rel,\\alpha*}$ (mas/yr)', + 'muRel_N': '$\mu_{rel,\delta}$ (mas/yr)', + 'muRel': '$\mu_{rel}$ (mas/yr)', + 'gp_log_sigma1': '$\log \sigma_{GP, I} (mag)$', + 'gp_rho1': '$\\rho_{GP, I}$ (days)', + 'gp_log_omega04_S01': '$\log S_{0, GP, I} \omega_{0, GP, I}^4$ (mag$^2$ days$^{-2}$)', + 'gp_log_omega01': '$\log \omega_{0, GP, I}$ (days$^{-1}$)', + 'gp_log_omega0_S01': '$\log S_{0, GP, I} \omega_{0, GP, I}$ (CLARIFY UNITS)', + 'pi_ref_frame': '$\pi_{ref\_frame} (mas)$', + 'b_sff3': '$b_{SFF,R}$', + 'mag_src3': '$R_{src}$ (mag)', + 'mag_base3': '$R_{base}$ (mag)', + 'mult_err3': '$\\varepsilon_{m,R}$', + 'add_err3': '$\\varepsilon_{a,R}$ (mmag)', + 'b_sff4': '$b_{SFF,V}$', + 'mag_src4': '$V_{src}$ (mag)', + 'mag_base4': '$V_{base}$ (mag)', + 'mult_err4': '$\\varepsilon_{m,V}$', + 'add_err4': '$\\varepsilon_{a,V}$ (mmag)', + } + + + # Photometric and Astrometry Posteriors + fitter, data = get_data_and_fitter(pspl_ast_multiphot[target]) + + from dynesty import plotting as dyplot + + res = fitter.load_mnest_results_for_dynesty() + res_m = fitter.load_mnest_modes_results_for_dynesty() + params_global = fitter.get_best_fit(def_best='median')[0] + fitter_params = copy.deepcopy(fitter.all_param_names) + smy = calc_summary_statistics(fitter) + fitter.all_param_names = fitter_params + + # + # Add log mL + # + idx_mL = fitter.all_param_names.index('mL') + + logmL = np.log10(res['samples'][:, idx_mL]) + res['samples'] = np.append(res['samples'], np.array([logmL]).T, axis=1) + for mm in range(len(res_m)): + logmL_m = np.log10(res_m[mm]['samples'][:, idx_mL]) + res_m[mm]['samples'] = np.append(res_m[mm]['samples'], np.array([logmL_m]).T, axis=1) + + fitter.all_param_names.append('log_mL') + smy['MaxLike_log_mL'] = np.log10(smy['MaxLike_mL']) + smy['MAP_log_mL'] = np.log10(smy['MAP_mL']) + smy['Med_log_mL'] = np.log10(smy['Med_mL']) + params_global['log_mL'] = np.log10(params_global['mL']) + + # + # Add ampltidue of piE + # + idx_piEE = fitter.all_param_names.index('piE_E') + idx_piEN = fitter.all_param_names.index('piE_N') + + piE = np.hypot(res['samples'][:, idx_piEE], res['samples'][:, idx_piEN]) + res['samples'] = np.append(res['samples'], np.array([piE]).T, axis=1) + for mm in range(len(res_m)): + piE_m = np.hypot(res_m[mm]['samples'][:, idx_piEE], res_m[mm]['samples'][:, idx_piEN]) + res_m[mm]['samples'] = np.append(res_m[mm]['samples'], np.array([piE_m]).T, axis=1) + + fitter.all_param_names.append('piE') + smy['MaxLike_piE'] = np.hypot(smy['MaxLike_piE_E'], smy['MaxLike_piE_N']) + smy['MAP_piE'] = np.hypot(smy['MAP_piE_E'], smy['MAP_piE_N']) + smy['Med_piE'] = np.hypot(smy['Med_piE_E'], smy['Med_piE_N']) + params_global['piE'] = np.hypot(params_global['piE_E'], params_global['piE_N']) + + # + # Add ampltidue of muRel + # + idx_muRelE = fitter.all_param_names.index('muRel_E') + idx_muRelN = fitter.all_param_names.index('muRel_N') + + muRel = np.hypot(res['samples'][:, idx_muRelE], res['samples'][:, idx_muRelN]) + res['samples'] = np.append(res['samples'], np.array([muRel]).T, axis=1) + for mm in range(len(res_m)): + muRel_m = np.hypot(res_m[mm]['samples'][:, idx_muRelE], res_m[mm]['samples'][:, idx_muRelN]) + res_m[mm]['samples'] = np.append(res_m[mm]['samples'], np.array([muRel_m]).T, axis=1) + + fitter.all_param_names.append('muRel') + smy['MaxLike_muRel'] = np.hypot(smy['MaxLike_muRel_E'], smy['MaxLike_muRel_N']) + smy['MAP_muRel'] = np.hypot(smy['MAP_muRel_E'], smy['MAP_muRel_N']) + smy['Med_muRel'] = np.hypot(smy['Med_muRel_E'], smy['Med_muRel_N']) + params_global['muRel'] = np.hypot(params_global['muRel_E'], params_global['muRel_N']) + + + # # Trim down to just the primary fitting parameters. + # N_fit = len(fitter.fitter_param_names) + # samples = res['samples'][0:N_fit] + + # + # Setup the truths arrays (choose Median) + # + best_sol = 'Med_' + truths = np.zeros(len(fitter.all_param_names), dtype=float) + truths_m = np.zeros((len(res_m), len(fitter.all_param_names)), dtype=float) + ax_labels = [] + + for pp in range(len(fitter.all_param_names)): + param = fitter.all_param_names[pp] + + ax_labels.append(labels[param]) + + # Global solution + if param in params_global: + # truths[pp] = smy[best_sol + param][0] # global best fit. + truths[pp] = params_global[param] # global best fit. + else: + truths[pp] = None + + # Mode solutions + for mm in range(len(res_m)): + if best_sol + param in smy.colnames: + truths_m[mm, pp] = smy[best_sol + param][mm] # global best fit. + else: + truths_m[mm, pp] = None + + ax_labels = np.array(ax_labels) + + + # plt.close('all') + # dyplot.traceplot(res, labels=ax_labels, + # show_titles=True, truths=truths) + # plt.subplots_adjust(hspace=0.7) + # plt.savefig(paper_dir + target + '_dy_trace.png') + + + sigma_vals = np.array([0.682689]) # , 0.9545, 0.9973]) + credi_ints_lo = (1.0 - sigma_vals) / 2.0 + credi_ints_hi = (1.0 + sigma_vals) / 2.0 + credi_ints_med = np.array([0.5]) + quantiles = np.concatenate([credi_ints_med, credi_ints_lo, credi_ints_hi]) + + ########## + # Prep the figure + ########## + + # First subset + fig5 = ['log_mL', 'piE', 'muRel'] + fig1 = ['mL', 'u0_amp', 'tE', 'piE', 'log10_thetaE', 'muRel', 'piRel', ] + fig2 = ['mL', 'piS', 'piL', 'piE_E', 'piE_N', 'xS0_E', 'xS0_N', 't0'] + # if target == 'ob140613': + # fig3 = ['mL', 'b_sff1', 'mag_base1', 'mult_err1', 'b_sff2', 'mag_base2', 'mult_err2'] + # else: + # fig3 = ['mL', 'b_sff1', 'mag_base1', 'add_err1', 'b_sff2', 'mag_base2', 'add_err2'] + fig3 = ['mL', 'b_sff1', 'mag_base1', 'b_sff2', 'mag_base2'] + fig4 = ['mL', 'muS_E', 'muS_N', 'muL_E', 'muL_N', 'muRel_E', 'muRel_N'] + + idx1 = [fitter.all_param_names.index(fig1_val) for fig1_val in fig1] + idx2 = [fitter.all_param_names.index(fig2_val) for fig2_val in fig2] + idx3 = [fitter.all_param_names.index(fig3_val) for fig3_val in fig3] + idx4 = [fitter.all_param_names.index(fig4_val) for fig4_val in fig4] + idx5 = [fitter.all_param_names.index(fig5_val) for fig5_val in fig5] + + # all_idxs = [idx1, idx2, idx3, idx4] + all_idxs = [idx5] + + for ii in range(len(all_idxs)): + idx = all_idxs[ii] + ndim = len(idx) + + # Set the axis limits. hard code the mass limit. + span = [1.0 - 1e-6] * ndim + mdx = np.where(np.array(fitter.all_param_names)[idx] == 'mL')[0] + if len(mdx) > 0: + if target == 'ob150211': + span[mdx[0]] = [0, 100] + else: + span[mdx[0]] = [0, 10] + + smooth = 0.05 + + fig, axes = plt.subplots(ndim, ndim, figsize=(20, 20)) + plt.subplots_adjust(left=0.3, bottom=0.3) +# dyplot.cornerplot(res, +# dims=idx, labels=ax_labels[idx], truths=truths[idx], +# show_titles=False, quantiles=quantiles, +# fig=(fig, axes), span=span, smooth=smooth) + model_fitter.cornerplot_custom([res], + dims=idx, labels=ax_labels[idx], truths=truths[idx], + show_titles=False, quantiles=quantiles, + fig=(fig, axes), smooth=smooth) #span=span, + #ax = plt.gca() + [[ax.tick_params(axis='both', which='major', labelsize=30) for ax in axs] for axs in axes] + [[ax.xaxis.get_label().set_fontsize(30) for ax in axs] for axs in axes] + [[ax.yaxis.get_label().set_fontsize(30) for ax in axs] for axs in axes] + plt.savefig(paper_dir + target + '_dy_corner_' + str(ii) + '.png', bbox_inches="tight") + + plt.close('all') + + ##### + # Now plot the individual modes. + ##### + if (len(smy) > 1): + for mm in range(len(smy)): + for ii in range(len(all_idxs)): + idx = all_idxs[ii] + ndim = len(idx) + + # Set the axis limits. hard code the mass limit. + span = [1.0 - 1e-6] * ndim + mdx = np.where(np.array(fitter.all_param_names)[idx] == 'mL')[0] + if len(mdx) > 0: + if target == 'ob150211': + span[mdx[0]] = [0, 100] + else: + span[mdx[0]] = [0, 10] + + smooth = 0.05 + + fig, axes = plt.subplots(ndim, ndim, figsize=(20, 20)) + plt.subplots_adjust(left=0.3, bottom=0.3) +# dyplot.cornerplot(res_m[mm], +# dims=idx, labels=ax_labels[idx], truths=truths_m[mm, idx], +# show_titles=False, quantiles=quantiles, +# fig=(fig, axes), span=span, smooth=smooth) + model_fitter.cornerplot_custom([res_m[mm]], + dims=idx, labels=ax_labels[idx], truths=truths_m[mm, idx], + show_titles=False, quantiles=quantiles, + fig=(fig, axes), smooth=smooth) # span=span, + #ax = plt.gca() + [[ax.tick_params(axis='both', which='major', labelsize=30) for ax in axs] for axs in axes] + [[ax.xaxis.get_label().set_fontsize(30) for ax in axs] for axs in axes] + [[ax.yaxis.get_label().set_fontsize(30) for ax in axs] for axs in axes] + plt.savefig(paper_dir + target + '_dy_corner_' + 'mode' + str(mm) + '_' + str(ii) + '.png', + bbox_inches="tight") + + return + +def plot_ob150211_mass_piE_muRel_all_modes(): + target = 'ob150211' + + foo = get_data_fitter_params_models_samples(target, return_mode = 'all') + fitter = foo[0] + data = foo[1] + stats_all = foo[2] + params_all = foo[3] + models_all = foo[4] + sampls_all = foo[5] + + # plt.close('all') + # plt.figure(1, figsize=(12, 6)) + # plt.clf() + # plt.subplots_adjust(left=0.08, right=0.95, top=0.95) + # ax1 = plt.subplot(1, 2, 1) + # ax2 = plt.subplot(1, 2, 2) + + plt.figure(1, figsize=(6, 6)) + plt.clf() + plt.subplots_adjust(left=0.15, right=0.95, top=0.95) + ax1 = plt.subplot(1, 1, 1) + # ax2 = plt.subplot(1, 2, 2) + + colors = ['black', 'orange'] + + for ii in range(len(sampls_all)): + sampls_all[ii]['muRel'] = np.hypot(sampls_all[ii]['muRel_E'], sampls_all[ii]['muRel_N']) + sampls_all[ii]['piE'] = np.hypot(sampls_all[ii]['piE_E'], sampls_all[ii]['piE_N']) + + span_mL = 1.0 - 1e-3 + span_muRel = 1.0 - 1e-3 + span_piE = 1.0 - 1e-3 + + smooth_mL = 0.025 + smooth_muRel = 0.05 + smooth_piE = 0.05 + + plot_2d_contour(np.log10(sampls_all[ii]['mL']), sampls_all[ii]['muRel'], + sampls_all[ii]['weights'], + ax1, colors[ii], + span1=span_mL, span2=span_muRel, + smooth1=smooth_mL, smooth2=smooth_muRel) + # plot_2d_contour(sampls_all[ii]['piE'], sampls_all[ii]['muRel'], + # sampls_all[ii]['weights'], + # ax2, colors[ii], + # span1=span_piE, span2=span_muRel, + # smooth1=smooth_piE, smooth2=smooth_muRel) + + # ax1.set_xscale('log') + ax1.set_xlabel('$\log M_L$ (M$_\odot$)') + ax1.set_ylabel('$\mu_{rel}$ (mas/yr)') + ax1.set_ylim(-0.1, 4.5) + ax1.set_xlim(-1.2, 1.2) + + # ax2.set_xlabel('$\pi_E$') + # ax2.set_ylabel('$\mu_{rel}$ (mas/yr)') + # ax2.set_xlim(0, 0.15) + + ax1.text(-1.1, 4.2, 'Mode 1 - Preferred', color=colors[0]) + ax1.text(-1.1, 3.9, 'Mode 2', color=colors[1]) + #ax1.text(-1.8, 3.7, 'Mode 3', color=colors[2]) + plt.savefig(paper_dir + 'ob150211_mL_piE_muRel_all_modes.png') + + + # # Check against other corner plot code. + # fitter.all_param_names = fitter.all_param_names[:-3] + # res_m = fitter.load_mnest_modes_results_for_dynesty() + + # # + # # Add ampltidue of piE and muRel + # # + # idx_piEE = fitter.all_param_names.index('piE_E') + # idx_piEN = fitter.all_param_names.index('piE_N') + # idx_muRelE = fitter.all_param_names.index('muRel_E') + # idx_muRelN = fitter.all_param_names.index('muRel_N') + + # for mm in range(len(res_m)): + # piE_m = np.hypot(res_m[mm]['samples'][:, idx_piEE], res_m[mm]['samples'][:, idx_piEN]) + # res_m[mm]['samples'] = np.append(res_m[mm]['samples'], np.array([piE_m]).T, axis=1) + + # muRel_m = np.hypot(res_m[mm]['samples'][:, idx_muRelE], res_m[mm]['samples'][:, idx_muRelN]) + # res_m[mm]['samples'] = np.append(res_m[mm]['samples'], np.array([muRel_m]).T, axis=1) + # fitter.all_param_names += ['piE', 'muRel'] + + + # fig_params = ['mL', 'piE', 'muRel'] + # idx = [fitter.all_param_names.index(fig_par) for fig_par in fig_params] + # ndim = len(idx) + + + # fig, axes = plt.subplots(ndim, ndim, figsize=(10, 10)) + # plt.subplots_adjust(left=0.3, bottom=0.3) + # for mm in range(len(sampls_all)): + # span = [1.0 - 1e-4] * ndim + # mdx = np.where(np.array(fig_params) == 'mL')[0] + # if len(mdx) > 0: + # span[mdx[0]] = [0, 100] + + # dyplot.cornerplot(res_m[mm], + # dims=idx, labels=fig_params, + # show_titles=False, color=colors[mm], + # fig=(fig, axes), span=span, smooth=0.02) + # # fig=(fig, axes), smooth=100) + # ax = plt.gca() + # ax.tick_params(axis='both', which='major', labelsize=10) + + # plt.savefig(paper_dir + 'ob150211_mL_piE_muRel_all_modes1.png') + + # plt.figure(3) + # plt.hist(np.log10(res_m[0]['samples'][:, idx[0]]), bins=100, weights=res_m[0]['weights']) + # plt.xlabel('log(mL)') + # plt.ylabel('Probability') + + # plt.figure(4) + # plt.hist(res_m[0]['samples'][:, idx[0]], bins=1000, weights=res_m[0]['weights']) + # plt.xlabel('mL') + # plt.ylabel('Probability') + # plt.xlim(0, 60) + + + return + + +def plot_2d_contour(samples1, samples2, weights, axes, color, + smooth1=0.02, smooth2=0.02, + span1=0.999, span2=0.999, + truths=None): + # Plot the 2-D marginalized posteriors. + + # Generate distribution. + fill_contours = False + plot_contours = True + + levels_sigma = np.array([0.5, 1.0, 2.0]) + quantiles_2d = 1.0 - np.exp(-0.5 * levels_sigma**2) + + hist2d_kwargs = dict() + hist2d_kwargs['levels'] = hist2d_kwargs.get('levels', quantiles_2d) + hist2d_kwargs['fill_contours'] = hist2d_kwargs.get('fill_contours', + fill_contours) + hist2d_kwargs['plot_contours'] = hist2d_kwargs.get('plot_contours', + plot_contours) + #hist2d_kwargs['alpha'] = 1.0 + hist2d_kwargs['no_fill_contours'] = True + hist2d_kwargs['plot_density'] = False + + # This "color map" is the list of colors for the contour levels if the + # contours are filled. + from matplotlib.colors import LinearSegmentedColormap, colorConverter + rgba_color = colorConverter.to_rgba(color) + contour_cmap = [list(rgba_color) for l in quantiles_2d] + [rgba_color] + for i, l in enumerate(quantiles_2d): + contour_cmap[i][-1] *= float(i+1) / (len(quantiles_2d)) + + contour_kwargs = dict() + contour_kwargs['colors'] = contour_cmap + + dyplot._hist2d(samples1, samples2, ax=axes, + weights=weights, color=color, + smooth=[smooth1, smooth2], span=[span1, span2], + contour_kwargs=contour_kwargs, **hist2d_kwargs) + #span=[span[j], span[i]], + + # Add truth values + if truths is not None: + if truths[0] is not None: + ax.axvline(truths[0], color=color) #, **truth_kwargs) + if truths[1] is not None: + ax.axhline(truths[1], color=color) # , **truth_kwargs) + + return + + +def get_data_and_fitter(mnest_base): + info_file = open(mnest_base + 'params.yaml', 'r') + info = yaml.full_load(info_file) + + pho_dsets = info['phot_data'] + if 'astrom_data' in info.keys(): + ast_dsets = info['astrom_data'] + else: + ast_dsets = [] + + if '_perlmutter' in info['target']: + info['target'] = info['target'][:-11] + + my_model = getattr(model, info['model']) + my_data = munge.getdata2(info['target'].lower(), + phot_data=pho_dsets, + ast_data=ast_dsets, + use_keck_file=astrom_data[info['target'].lower()]) + + # Need this for backwards compatability. + if 'use_phot_optional_params' in info: + use_phot_opt = info['use_phot_optional_params'] + else: + use_phot_opt = False + + # Load up the first fitter object to get the parameter names. + fitter = model_fitter.PSPL_Solver(my_data, my_model, + use_phot_optional_params = use_phot_opt, + add_error_on_photometry = info['add_error_on_photometry'], + multiply_error_on_photometry = info['multiply_error_on_photometry'], + outputfiles_basename = mnest_base) + + return fitter, my_data + +def get_data_fitter_params_models_samples(target, return_mode = 'best', def_best='median'): + """ + Return the fitter, data, stats table, parameters array, model, and posterior samples for + the desired target from the PSPL astrometry + multi-photometry fits. + + If return_mode == 'best', then return the mode designated in the + pspl_ast_multiphot_mode array. + + If return_mode == 'all' (or anything else), then return all the modes. + """ + # Load model_fitter and data objects + fitter, data = get_data_and_fitter(pspl_ast_multiphot[target]) + + # Load best-fit model objects for all modes. + models_all = fitter.get_best_fit_modes_model(def_best = def_best) + + # Load best-fit parameters and statistics (median, mean, maxLike, etc.) for all modes. + # Load posterior samples for all modes. + stats_all, sampls_all = calc_summary_statistics(fitter, return_samples=True) + + # Select the best-fit parameters and make them into a useful table. + params_all = get_best_fit_from_stats(fitter, stats_all, def_best=def_best) + + mode = pspl_ast_multiphot_mode[target] + + # Sort all of the samples by logLike + for mm in range(len(stats_all)): + sdx = sampls_all[mm]['logLike'].argsort() + sampls_all[mm] = sampls_all[mm][sdx] + + # Return just th designated mode. + if return_mode == 'best': + stats_all = stats_all[mode] + params_all = params_all[mode] + models_all = models_all[mode] + sampls_all = sampls_all[mode] + + + return (fitter, data, stats_all, params_all, models_all, sampls_all) + + +def load_summary_statistics(mnest_base, verbose=False): + info_file = open(mnest_base + 'params.yaml', 'r') + info = yaml.full_load(info_file) + if '_perlmutter' in info['target']: + info['target'] = info['target'][:-11] + + my_model = getattr(model, info['model']) + my_data = munge.getdata2(info['target'].lower(), + phot_data=info['phot_data'], + ast_data=info['astrom_data'], + use_keck_file=astrom_data[info['target'].lower()]) + + if 'use_phot_optional_params' in info: + use_phot_opt = info['use_phot_optional_params'] + else: + use_phot_opt = False + + + # Load up the first fitter object to get the parameter names. + fitter = model_fitter.PSPL_Solver(my_data, my_model, + use_phot_optional_params = use_phot_opt, + add_error_on_photometry = info['add_error_on_photometry'], + multiply_error_on_photometry = info['multiply_error_on_photometry'], + outputfiles_basename = mnest_base) + + stats = calc_summary_statistics(fitter, verbose=verbose) + + return stats, my_data, my_model + + +def calc_summary_statistics(fitter, verbose=False, return_samples=False): + # Get the number of modes. + summ_tab = Table.read(fitter.outputfiles_basename + 'summary.fits') + N_modes = len(summ_tab) - 1 + + # Calculate the number of data points we have all together. + N_data = get_num_data_points(fitter.data, + astrometryFlag=fitter.model_class.astrometryFlag, + verbose=verbose) + + N_params = len(fitter.fitter_param_names) + N_dof = N_data - N_params + + if verbose: + print('**** calc_summary_statistics: ****') + print('Model = ', type(fitter.model_class).__name__) + print('Data = ', fitter.data.keys()) + + # First, we want the statistics for the following types of solutions. + sol_types = ['maxl', 'mean', 'map', 'median'] + sol_prefix = {'maxl': 'MaxLike_', + 'mean': 'Mean_', + 'map': 'MAP_', + 'median': 'Med_' } + + tab_list = fitter.load_mnest_modes() + smy = fitter.load_mnest_summary() + # remember smy has N+1 because the 0th entry is the global solution. + # Trim this one out. + smy = smy[1:] + + # Add in custom variables derived from other quantites. + current_params = tab_list[0].colnames + + # Add thetaE (from log thetaE) + if ('log10_thetaE' in current_params) and ('thetaE' not in current_params): + for ii in range(len(tab_list)): + tab_list[ii]['thetaE'] = 10**tab_list[ii]['log10_thetaE'] + + smy['Mean_thetaE'] = 10**smy['Mean_log10_thetaE'] + smy['MAP_thetaE'] = 10**smy['MAP_log10_thetaE'] + smy['MaxLike_thetaE'] = 10**smy['MaxLike_log10_thetaE'] + #smy['Med_thetaE'] = 10**smy['Med_log10_thetaE'] + + fitter.all_param_names.append('thetaE') + + # Add mag_src. + if ('mag_base1' in current_params) and ('mag_src1' not in current_params): + for ii in range(len(tab_list)): + tab_list[ii]['mag_src1'] = tab_list[ii]['mag_base1'] - 2.5 * np.log10(tab_list[ii]['b_sff1']) + + smy['Mean_mag_src1'] = smy['Mean_mag_base1'] - 2.5 * np.log10(smy['Mean_b_sff1']) + smy['MAP_mag_src1'] = smy['MAP_mag_base1'] - 2.5 * np.log10(smy['MAP_b_sff1']) + smy['MaxLike_mag_src1'] = smy['MaxLike_mag_base1'] - 2.5 * np.log10(smy['MaxLike_b_sff1']) + #smy['Med_mag_src1'] = smy['Med_mag_base1'] - 2.5 * np.log10(smy['Med_b_sff1']) + + fitter.all_param_names.append('mag_src1') + + + if ('mag_base2' in current_params) and ('mag_src2' not in current_params): + for ii in range(len(tab_list)): + tab_list[ii]['mag_src2'] = tab_list[ii]['mag_base2'] - 2.5 * np.log10(tab_list[ii]['b_sff2']) + + smy['Mean_mag_src2'] = smy['Mean_mag_base2'] - 2.5 * np.log10(smy['Mean_b_sff2']) + smy['MAP_mag_src2'] = smy['MAP_mag_base2'] - 2.5 * np.log10(smy['MAP_b_sff2']) + smy['MaxLike_mag_src2'] = smy['MaxLike_mag_base2'] - 2.5 * np.log10(smy['MaxLike_b_sff2']) + #smy['Med_mag_src2'] = smy['Med_mag_base2'] - 2.5 * np.log10(smy['Med_b_sff2']) + + fitter.all_param_names.append('mag_src2') + + + # Make a deepcopy of this table and set everything to zeros. + # This will contain our final results. + stats = copy.deepcopy(smy) + for col in stats.colnames: + stats[col] = np.nan + + # Loop through the different modes. + for nn in range(N_modes): + + # Loop through different types of "solutions" + for sol in sol_types: + + # Loop through the parameters and get the best fit values. + foo = fitter.calc_best_fit(tab_list[nn], smy[[nn]], s_idx=0, def_best=sol) + + if sol == 'maxl' or sol == 'map': + best_par = foo + else: + best_par = foo[0] + best_parerr = foo[1] + + for param in fitter.all_param_names: + if sol_prefix[sol] + param not in stats.colnames: + stats[sol_prefix[sol] + param] = 0.0 + stats[sol_prefix[sol] + param][nn] = best_par[param] + + # Add chi^2 to the table. + chi2 = fitter.calc_chi2(best_par) + if sol_prefix[sol] + 'chi2' not in stats.colnames: + stats[sol_prefix[sol] + 'chi2'] = 0.0 + stats[sol_prefix[sol] + 'chi2'][nn] = chi2 + + # Add reduced chi^2 to the table. + rchi2 = chi2 / N_dof + if sol_prefix[sol] + 'rchi2' not in stats.colnames: + stats[sol_prefix[sol] + 'rchi2'] = 0.0 + stats[sol_prefix[sol] + 'rchi2'][nn] = rchi2 + + # Add log-likelihood to the table. + logL = fitter.log_likely(best_par) + if sol_prefix[sol] + 'logL' not in stats.colnames: + stats[sol_prefix[sol] + 'logL'] = 0.0 + stats[sol_prefix[sol] + 'logL'][nn] = logL + + # BIC + if sol_prefix[sol] + 'BIC' not in stats.colnames: + stats[sol_prefix[sol] + 'BIC'] = 0.0 + stats[sol_prefix[sol] + 'BIC'][nn] = calc_BIC(N_data, N_params, stats[sol_prefix[sol] + 'logL'][nn]) + + # Next figure out the errors. + # Only need to do this once. + if sol == 'median': + sigma_vals = np.array([0.682689, 0.9545, 0.9973]) + credi_ints_lo = (1.0 - sigma_vals) / 2.0 + credi_ints_hi = (1.0 + sigma_vals) / 2.0 + credi_ints_med = np.array([0.5]) + credi_ints = np.concatenate([credi_ints_med, credi_ints_lo, credi_ints_hi]) + + sumweights = np.sum(tab_list[nn]['weights']) + weights = tab_list[nn]['weights'] / sumweights + + for param in fitter.all_param_names: + # Calculate median, 1 sigma lo, and 1 sigma hi credible interval. + tmp = model_fitter.weighted_quantile(tab_list[nn][param], credi_ints, sample_weight=weights) + ci_med_val = tmp[0] + ci_lo = tmp[1:1+len(sigma_vals)] + ci_hi = tmp[1+len(sigma_vals):] + + if 'lo68_' + param not in stats.colnames: + stats['lo68_' + param] = 0.0 + stats['hi68_' + param] = 0.0 + if 'lo95_' + param not in stats.colnames: + stats['lo95_' + param] = 0.0 + stats['hi95_' + param] = 0.0 + if 'lo99_' + param not in stats.colnames: + stats['lo99_' + param] = 0.0 + stats['hi99_' + param] = 0.0 + + # Add back in the median to get the actual value (not diff on something). + stats['lo68_' + param][nn] = ci_lo[0] + stats['hi68_' + param][nn] = ci_hi[0] + stats['lo95_' + param][nn] = ci_lo[1] + stats['hi95_' + param][nn] = ci_hi[1] + stats['lo99_' + param][nn] = ci_lo[2] + stats['hi99_' + param][nn] = ci_hi[2] + + # Get the evidence values out of the _stats.dat file. + if 'logZ' not in stats.colnames: + stats['logZ'] = 0.0 + stats['logZ'][nn] = smy['logZ'][nn] + + # Add number of degrees of freedom + stats['N_dof'] = N_dof + + # # Sort such that the modes are in reverse order of evidence. + # # Increasing logZ (nan's are at the end) + # zdx = np.argsort(stats['logZ']) + # non_nan = np.where(np.isfinite(stats['logZ'][zdx]))[0] + # zdx = zdx[non_nan[::-1]] + + # stats = stats[zdx] + + if return_samples: + return stats, tab_list + else: + return stats + +def get_best_fit_from_stats(fitter, stats, def_best='median'): + """ + Return a dictionary of all the best-fit parameters for + the best-fit style of your choice. + + This will work on a single mode or all modes, + stats or summary tables. + """ + best_params_all = [] + + sol_types = ['maxl', 'mean', 'map', 'median'] + sol_prefix = {'maxl': 'MaxLike_', + 'mean': 'Mean_', + 'map': 'MAP_', + 'median': 'Med_' } + + # Loop through all solutions/modes. + for mm in range(len(stats)): + best_params = {} + + # Loop through all parameters. + for pp in range(len(fitter.all_param_names)): + param = fitter.all_param_names[pp] + prefix = sol_prefix[def_best] + + if prefix + param in stats.colnames: + try: + best_params[param] = stats[prefix + param][mm] + except: + best_params[param] = stats[prefix + param] + else: + best_params[param] = None + + best_params_all.append(best_params) + + return best_params_all + + +def make_BIC_comparison_table(): + # Use the one with the highest likelihood solution. + ob120169_none = load_summary_statistics(ogle_phot_all['ob120169_none'])[0] + ob120169_add = load_summary_statistics(ogle_phot_all['ob120169_add'])[0] + ob120169_mult = load_summary_statistics(ogle_phot_all['ob120169_mult'])[0] + ob120169_addmult = load_summary_statistics(ogle_phot_all['ob120169_addmult'])[0] + + ob140613_none = load_summary_statistics(ogle_phot_all['ob140613_none'])[0] + ob140613_add = load_summary_statistics(ogle_phot_all['ob140613_add'])[0] + ob140613_mult = load_summary_statistics(ogle_phot_all['ob140613_mult'])[0] + ob140613_addmult = load_summary_statistics(ogle_phot_all['ob140613_addmult'])[0] + + ob150029_none = load_summary_statistics(ogle_phot_all['ob150029_none'])[0] + ob150029_add = load_summary_statistics(ogle_phot_all['ob150029_add'])[0] + ob150029_mult = load_summary_statistics(ogle_phot_all['ob150029_mult'])[0] + ob150029_addmult = load_summary_statistics(ogle_phot_all['ob150029_addmult'])[0] + + ob150211_none = load_summary_statistics(ogle_phot_all['ob150211_none'])[0] + ob150211_add = load_summary_statistics(ogle_phot_all['ob150211_add'])[0] + ob150211_mult = load_summary_statistics(ogle_phot_all['ob150211_mult'])[0] + ob150211_addmult = load_summary_statistics(ogle_phot_all['ob150211_addmult'])[0] + + with open(paper_dir + 'BIC_comparison.txt', 'w+') as tab_file: + tab_file.write('No error term' + ' & ' + + '{0:.2f}'.format(np.min(ob120169_none['MaxLike_BIC'])) + ' & ' + + '{0:.2f}'.format(np.min(ob140613_none['MaxLike_BIC'])) + ' & ' + + '{0:.2f}'.format(np.min(ob150029_none['MaxLike_BIC'])) + ' & ' + + '{0:.2f}'.format(np.min(ob150211_none['MaxLike_BIC'])) + r' \\ ' + '\n' + + + 'Additive' + ' & ' + + '{0:.2f}'.format(np.min(ob120169_add['MaxLike_BIC'])) + ' & ' + + '{0:.2f}'.format(np.min(ob140613_add['MaxLike_BIC'])) + ' & ' + + '{0:.2f}'.format(np.min(ob150029_add['MaxLike_BIC'])) + ' & ' + + '{0:.2f}'.format(np.min(ob150211_add['MaxLike_BIC'])) + r' \\ ' + '\n' + + + 'Multiplicative' + ' & ' + + '{0:.2f}'.format(np.min(ob120169_mult['MaxLike_BIC'])) + ' & ' + + '{0:.2f}'.format(np.min(ob140613_mult['MaxLike_BIC'])) + ' & ' + + '{0:.2f}'.format(np.min(ob150029_mult['MaxLike_BIC'])) + ' & ' + + '{0:.2f}'.format(np.min(ob150211_mult['MaxLike_BIC'])) + r' \\ ' + '\n' + + + 'Additive + Multiplicative' + ' & ' + + '{0:.2f}'.format(np.min(ob120169_addmult['MaxLike_BIC'])) + ' & ' + + '{0:.2f}'.format(np.min(ob140613_addmult['MaxLike_BIC'])) + ' & ' + + '{0:.2f}'.format(np.min(ob150029_addmult['MaxLike_BIC'])) + ' & ' + + '{0:.2f}'.format(np.min(ob150211_addmult['MaxLike_BIC'])) + r' \\ ' + '\n') + + return + + +def calc_chi2(target): + """ + Calculate the chi^2 with and without the additive (or multiplicative + error and separetely for each astrometric and photometric data + set so we can report back in the paper. + """ + fitter1, data1 = get_data_and_fitter(pspl_phot[target]) + fitter2, data2 = get_data_and_fitter(pspl_ast_multiphot[target]) + + model1 = fitter1.get_best_fit_model(def_best='maxl') + model2 = fitter2.get_best_fit_model(def_best='maxl') + + params1 = fitter1.get_best_fit(def_best='maxl') + params2 = fitter2.get_best_fit(def_best='maxl') + + # Check that these are actually the same u0 sign + if np.sign(model1.u0_amp) != np.sign(model2.u0_amp): + print(' *** Model mis-match!!! ***') + + # Assume that model2 (ast + phot) is what we want to go + # with. Pick out the corresponding same-sign u0 for the + # photometry fit as well. + model1_all = fitter1.get_best_fit_modes_model(def_best='maxl') + params1_all = fitter1.get_best_fit_modes(def_best='maxl') + model1 = model1_all[1] + params1 = params1_all[1] + + assert np.sign(model1.u0_amp) == np.sign(model2.u0_amp) + + def print_chi2_info(fitter, pspl, params): + # Get likelihoods. + lnL_phot = fitter.log_likely_photometry(pspl, params) + lnL_ast = fitter.log_likely_astrometry(pspl) + + # Calculate constants needed to subtract from lnL to calculate chi2. + if pspl.astrometryFlag: + lnL_const_ast = -0.5 * np.log(2.0 * math.pi * fitter.data['xpos_err1'] ** 2) + lnL_const_ast += -0.5 * np.log(2.0 * math.pi * fitter.data['ypos_err1'] ** 2) + lnL_const_ast = lnL_const_ast.sum() + else: + lnL_const_ast = 0 + + # Lists to store lnL, chi2, and constants for each filter. + chi2_phot_filts1 = [] # no error modification + chi2_phot_filts2 = [] # error modification + rchi2_phot_filts1 = [] # no error modification + rchi2_phot_filts2 = [] # error modification + lnL_const_phot_filts1 = [] + lnL_const_phot_filts2 = [] + ndata_phot = [] + + for nn in range(fitter.n_phot_sets): + t_phot = fitter.data['t_phot' + str(nn + 1)] + mag = fitter.data['mag' + str(nn + 1)] + mag_err1 = fitter.data['mag_err' + str(nn + 1)] + mag_err2 = fitter.get_modified_mag_err(params, nn) + + # Calculate the lnL for just a single filter. + # Without additive/multiplicative error. + lnL_phot_nn1 = pspl.likely_photometry(t_phot, mag, mag_err1, nn) + lnL_phot_nn1 = lnL_phot_nn1.sum() + # With additive/multiplicative error. + lnL_phot_nn2 = pspl.likely_photometry(t_phot, mag, mag_err2, nn) + lnL_phot_nn2 = lnL_phot_nn2.sum() + + # Calculate the chi2 and constants for just a single filter. + lnL_const_phot_nn1 = -0.5 * np.log(2.0 * math.pi * mag_err1**2) + lnL_const_phot_nn1 = lnL_const_phot_nn1.sum() + lnL_const_phot_nn2 = -0.5 * np.log(2.0 * math.pi * mag_err2**2) + lnL_const_phot_nn2 = lnL_const_phot_nn2.sum() + + chi2_phot_nn1 = (lnL_phot_nn1 - lnL_const_phot_nn1) / -0.5 + chi2_phot_nn2 = (lnL_phot_nn2 - lnL_const_phot_nn2) / -0.5 + + N_dof = len(mag) - len(params) + + rchi2_phot_nn1 = chi2_phot_nn1 / N_dof + rchi2_phot_nn2 = chi2_phot_nn2 / (N_dof + 1) # discount the additional error term + + # Save to our lists + chi2_phot_filts1.append(chi2_phot_nn1) + chi2_phot_filts2.append(chi2_phot_nn2) + rchi2_phot_filts1.append(rchi2_phot_nn1) + rchi2_phot_filts2.append(rchi2_phot_nn2) + lnL_const_phot_filts1.append(lnL_const_phot_nn1) + lnL_const_phot_filts2.append(lnL_const_phot_nn2) + ndata_phot.append(len(mag)) + + # For the "all photometry" chi^2, we need to subtract off the total constant. + lnL_const_phot = np.sum(lnL_const_phot_filts2) + + # Calculate chi2. + chi2_ast = (lnL_ast - lnL_const_ast) / -0.5 + chi2_phot = (lnL_phot - lnL_const_phot) / -0.5 + chi2 = chi2_ast + chi2_phot + + if pspl.astrometryFlag: + N_dof_ast = len(fitter.data['t_ast1']) - len(params) + rchi2_ast = chi2_ast / N_dof_ast + + N_dof_phot = np.sum(ndata_phot) - len(params) + N_dof = len(fitter.data['t_ast1']) + np.sum(ndata_phot) - len(params) + rchi2_phot = chi2_phot / N_dof_phot + rchi2 = chi2 / N_dof + + # Now print everything out. + fmt = '{0:13s} = {1:f} ' + for ff in range(fitter.n_phot_sets): + print(fmt.format('chi2_phot' + str(ff + 1) + ', no error mod ', chi2_phot_filts1[ff])) + print(fmt.format('chi2_phot' + str(ff + 1) + ', with error mod', chi2_phot_filts2[ff])) + print(fmt.format('rchi2_phot' + str(ff + 1) + ', no error mod ', rchi2_phot_filts1[ff])) + print(fmt.format('rchi2_phot' + str(ff + 1) + ', with error mod', rchi2_phot_filts2[ff])) + + if pspl.astrometryFlag: + print(fmt.format('chi2_ast', chi2_ast)) + print(fmt.format('chi2_phot', chi2_phot)) + print(fmt.format('chi2', chi2)) + + if pspl.astrometryFlag: + print(fmt.format('rchi2_ast', rchi2_ast)) + print(fmt.format('rchi2_phot', rchi2_phot)) + print(fmt.format('rchi2', rchi2)) + + # Calculate a total chi^2 with and without extra error terms. + chi2_tot1 = np.sum(chi2_phot_filts1) + chi2_tot2 = np.sum(chi2_phot_filts2) + if pspl.astrometryFlag: + chi2_tot1 += chi2_ast + chi2_tot2 += chi2_ast + rchi2_tot1 = chi2_tot1 / N_dof + rchi2_tot2 = chi2_tot2 / N_dof + print(fmt.format('chi2_tot, no error mod ', chi2_tot1)) + print(fmt.format('chi2_tot, with error mod ', chi2_tot2)) + print(fmt.format('rchi2_tot, no error mod ', rchi2_tot1)) + print(fmt.format('rchi2_tot, with error mod', rchi2_tot2)) + + + if pspl.astrometryFlag: + print('Ndata_ast = {0:d}'.format(len(fitter.data['t_ast1']))) + for ff in range(fitter.n_phot_sets): + print('Ndata_phot{0:d} = {1:d}'.format(ff+1, ndata_phot[ff])) + print('Ndata_phot all = {0:d}'.format(np.sum(ndata_phot))) + + return + + print('\n**** OGLE-only Phot ****') + print_chi2_info(fitter1, model1, params1) + + print('\n**** OGLE+Keck Phot+Ast ****') + print_chi2_info(fitter2, model2, params2) + + return + + +def calc_BIC(n, k, maxlogL): + """ + maxL = maximized value of the LOG likelihood function + n = number of data points + k = number of parameters in model + """ + + bic = np.log(n) * k - 2 * maxlogL + + return bic + + +#################################### +### PopSyCLE Visualization Stuff ### +#################################### +def murel_popsycle(): + t = Table.read(popsycle_events) + + mas_to_rad = 4.848 * 10**-9 + + long_idx = np.where(t['t_E'] > 100)[0] + + idx = np.where((t['t_E'] > 100) & + (t['pi_E']/mas_to_rad < 0.1))[0] + + print(len(t['t_E'])) + print(len(long_idx)) + print(len(idx)) + + murel = t['mu_rel'] + + murel_long = t['mu_rel'][long_idx] + + murel_long_piE = t['mu_rel'][idx] + +# fig = plt.figure(1, figsize=(6,6)) +# plt.clf() +# plt.hist(murel, +# bins = 50, +# normed = True) +# xmin, xmax = plt.xlim() +# x = np.linspace(xmin, xmax, 100) +# y = norm.pdf(x, mean, std) +# plt.plot(x,y) +# plt.xlabel('murel (mas/yr)') + + fig = plt.figure(2, figsize=(6,6)) + plt.clf() + plt.hist(murel, +# bins = np.linspace(0, 20, 51), + bins = np.logspace(-1, 1.3, 51), + histtype = 'step', + density=True, + label = 'All') + plt.hist(murel_long, +# bins = np.linspace(0, 20, 51), + bins = np.logspace(-1, 1.3, 51), + histtype = 'step', + density=True, + label = 'Long') + plt.hist(murel_long_piE, +# bins = np.linspace(0, 20, 51), + bins = np.logspace(-1, 13., 51), + histtype = 'step', + density=True, + label = 'Long, piE < 0.1') + plt.xlabel('murel (mas/yr)') + plt.xscale('log') + plt.legend() + +def dLdS_popsycle(): + t = Table.read(popsycle_events) + + long_idx = np.where(t['t_E'] > 100)[0] + + dL = t['rad_L'] + dS = t['rad_S'] + dLdS = (1.0 * dL)/(1.0 * dS) + + dL_long = t['rad_L'][long_idx] + dS_long = t['rad_S'][long_idx] + dLdS_long = (1.0 * dL_long)/(1.0 * dS_long) + + fig = plt.figure(1, figsize=(6,6)) + plt.clf() + plt.hist(dLdS, bins = np.linspace(0, 1, 11), histtype = 'step', density=True, label = 'All') + plt.hist(dLdS_long, bins = np.linspace(0, 1, 11), histtype = 'step', density=True, label = 'Long') + plt.xlabel('dL/dS') + plt.legend() + + fig = plt.figure(2, figsize=(6,6)) + plt.clf() + plt.hist(dL, bins = np.linspace(0, 12, 13), histtype = 'step', density=True, label = 'All') + plt.hist(dL_long, bins = np.linspace(0, 12, 13), histtype = 'step', density=True, label = 'Long') + plt.xlabel('dL (kpc)') + plt.legend() + + fig = plt.figure(3, figsize=(6,6)) + plt.clf() + plt.hist(dLdS, bins = np.logspace(-2, 1)) + plt.xlabel('dL/dS') + plt.xscale('log') + plt.show() + + plt.show() + +def dS_popsycle(): + t = Table.read(popsycle_events) + + long_idx = np.where(t['t_E'] > 100)[0] + + dS = t['rad_S'] + + piS = 1.0/dS + + dS_long = t['rad_S'][long_idx] + + mean, std = norm.fit(piS) + print(mean, std) + + fig = plt.figure(1, figsize=(6,6)) + plt.clf() + plt.hist(piS, + bins = 50, + normed = True) + xmin, xmax = plt.xlim() + x = np.linspace(xmin, xmax, 100) + y = norm.pdf(x, mean, std) + plt.plot(x,y) + plt.xlabel('piS (mas)') + + fig = plt.figure(2, figsize=(6,6)) + plt.clf() + plt.hist(dS, + bins = np.linspace(0, 20, 21), + histtype = 'step', + density=True, + label = 'All') + plt.hist(dS_long, + bins = np.linspace(0, 20, 21), + histtype = 'step', + density=True, + label = 'Long') + plt.xlabel('dS (kpc)') + plt.legend() + + fig = plt.figure(3, figsize=(6,6)) + plt.clf() + plt.hist(1.0/dS, + bins = np.linspace(0, 0.25, 21), + histtype = 'step', + density=True, + label = 'All') + plt.hist(1.0/dS_long, + bins = np.linspace(0, 0.25, 21), + histtype = 'step', + density=True, + label = 'Long') + plt.xlabel('piS (mas)') + plt.legend() + + plt.show() + +def pi_popsycle(): + t = Table.read(popsycle_events) + + long_idx = np.where(t['t_E'] > 100)[0] + + dS = t['rad_S'] + piS = 1.0/dS + dS_long = t['rad_S'][long_idx] + piS_long = 1.0/dS_long + + dL = t['rad_L'] + piL = 1.0/dL + dL_long = t['rad_L'][long_idx] + piL_long = 1.0/dL_long + + meanS, stdS = norm.fit(piS) + print('Mean, STD for piS') + print(meanS, stdS) + + meanL, stdL = norm.fit(piL) + print('Mean, STD for piL') + print(meanL, stdL) + + bins = np.linspace(0, 0.5, 50) +# bins = np.logspace(-4, 0, 50) + + print('Max piL') + print(np.max(piL)) + + print('Max piS') + print(np.max(piS)) + + fig = plt.figure(1, figsize=(6,6)) + plt.clf() + plt.hist(piS, + bins = bins, +# normed = True, + label = 'piS', + histtype = 'step') + plt.hist(piL, + bins = bins, +# normed = True, + label = 'piL', + histtype='step') + plt.hist(piL - piS, + bins = bins, + label = 'piRel', + histtype = 'step') +# xmin, xmax = plt.xlim() +# x = np.linspace(xmin, xmax, 100) +# y = norm.pdf(x, mean, std) +# plt.plot(x,y) + plt.legend() +# plt.xscale('log') + plt.yscale('log') + plt.xlabel('pi (mas)') + +# fig = plt.figure(2, figsize=(6,6)) +# plt.clf() +# plt.hist(dS, +# bins = np.linspace(0, 20, 21), +# histtype = 'step', +# density=True, +# label = 'All') +# plt.hist(dS_long, +# bins = np.linspace(0, 20, 21), +# histtype = 'step', +# density=True, +# label = 'Long') +# plt.xlabel('dS (kpc)') +# plt.legend() +# +# fig = plt.figure(3, figsize=(6,6)) +# plt.clf() +# plt.hist(1.0/dS, +# bins = np.linspace(0, 0.25, 21), +# histtype = 'step', +# density=True, +# label = 'All') +# plt.hist(1.0/dS_long, +# bins = np.linspace(0, 0.25, 21), +# histtype = 'step', +# density=True, +# label = 'Long') +# plt.xlabel('piS (mas)') +# plt.legend() +# + plt.show() + + +################################## +### OB150211 solo paper things ### +################################## + +def make_obs_table_ob150211(): + """ + Make a LaTeX table for all of the observations of the three targets from 2014/2015. + """ + + targets = list(epochs.keys()) + + tables = {} + + # Build only OB150211 + target = 'ob150211' + + n_epochs = len(epochs[target]) + + obj_name = np.repeat(target.upper(), n_epochs) + obj_name[1:] = '' + + date = np.zeros(n_epochs, dtype='S10') + tint = np.zeros(n_epochs, dtype=int) + n_exp = np.zeros(n_epochs, dtype=int) + strehl = np.zeros(n_epochs, dtype=float) + fwhm = np.zeros(n_epochs, dtype=float) + strehl_e = np.zeros(n_epochs, dtype=float) + fwhm_e = np.zeros(n_epochs, dtype=float) + n_star = np.zeros(n_epochs, dtype=int) + m_base = np.zeros(n_epochs, dtype=float) + ast_err = np.zeros(n_epochs, dtype=float) + phot_err = np.zeros(n_epochs, dtype=float) + + # Loop through each epoch and grab information to populate our table. + for ee in range(n_epochs): + epoch = epochs[target][ee] + img_file = '/g/lu/data/microlens/{0:s}/combo/mag{0:s}_{1:s}_kp.fits'.format(epoch, target) + log_file = '/g/lu/data/microlens/{0:s}/combo/mag{0:s}_{1:s}_kp.log'.format(epoch, target) + pos_file = '/g/lu/data/microlens/{0:s}/combo/starfinder/plotPosError_{1:s}_kp.txt'.format(epoch, target) + + # Fetch stuff from the image header. + hdr = fits.getheader(img_file) + date[ee] = hdr['DATE-OBS'].strip() + tint[ee] = np.round(float(hdr['ITIME']) * float(hdr['COADDS']), 0) + + # From the log file, average Strehl and FWHM + _log = Table.read(log_file, format='ascii') + _log.rename_column('col2', 'fwhm') + _log.rename_column('col3', 'strehl') + strehl[ee] = _log['strehl'].mean() + strehl_e[ee] = _log['strehl'].std() + fwhm[ee] = _log['fwhm'].mean() + fwhm_e[ee] = _log['fwhm'].std() + n_exp[ee] = len(_log) + + # Read in the stats file from the analysis of the AIROPA starlist. + _pos = open(pos_file, 'r') + lines = _pos.readlines() + _pos.close() + + n_star[ee] = int(lines[0].split(':')[-1]) + ast_err[ee] = float(lines[1].split(':')[-1]) + phot_err[ee] = float(lines[2].split(':')[-1]) + m_base[ee] = float(lines[3].split('=')[-1]) + + # Make our table + c_date = Column(data=date, name='Date', format='{:10s}') + c_tint = Column(data=tint, name='t$_{int}$', format='{:3.0f}', unit='s') + c_nexp = Column(data=n_exp, name='N$_{exp}$', format='{:3d}') + c_fwhm = Column(data=fwhm, name='FWHM', format='{:3.0f}', unit='mas') + c_fwhm_err = Column(data=fwhm_e, name='FWHM$_{err}$', format='{:3.0f}', unit='mas') + c_strehl = Column(data=strehl, name='Strehl', format='{:4.2f}') + c_strehl_err = Column(data=strehl_e, name='Strehl$_{err}$', format='{:4.2f}') + c_nstar = Column(data=n_star, name='N$_{star}$', format='{:4d}') + c_mbase = Column(data=m_base, name='Kp$_{turn}$', format='{:4.1f}', unit='mag') + c_asterr = Column(data=ast_err, name='$\sigma_{ast}$', format='{:5.2f}', unit='mas') + c_photerr = Column(data=phot_err, name='$\sigma_{phot}$', format='{:5.2f}', unit='mag') + + final_table = Table((c_date, c_tint, c_nexp, + c_fwhm, c_fwhm_err, c_strehl, c_strehl_err, + c_nstar, c_mbase, c_asterr, c_photerr)) + + print(final_table) + + final_table.write(paper_dir + 'data_table.tex', format='aastex', overwrite=True) + + return + +def plot_astrometry(target): + data = munge.getdata(target, use_astrom_phot=True, + use_astrom_file=astrom_data[info['target'].lower()]) + + plt.close('all') + + best = {} + best['mL'] = 10.386 + best['t0'] = 57211.845 + # best['xS0_E'] = 0.023101 + best['xS0_E'] = 0.022981 + # best['xS0_N'] = -0.113297 + best['xS0_N'] = -0.113357 + best['beta'] = -0.462895 + best['muL_E'] = -0.129050 + best['muL_N'] = -3.92588 + best['muS_E'] = 0.7187671 + best['muS_N'] = -1.77336 + best['dL'] = 5841.39 + best['dS'] = best['dL'] / 0.8772 + best['b_sff'] = 0.6451 + best['mag_src'] = 17.77 + + # mymodel = model.PSPL_parallax(data['raL'], data['decL'], + # best['mL'], best['t0'], np.array([best['xS0_E'], best['xS0_N']]), + # best['beta'], np.array([best['muL_E'], best['muL_N']]), + # np.array([best['muS_E'], best['muS_N']]), + # best['dL'], best['dS'], best['b_sff'], best['mag_src']) + + fitter = model_fitter.PSPL_parallax_Solver(data, outputfiles_basename=pspl_ast_multiphot[target]) + fitter.load_mnest_results() + mymodel = fitter.get_best_fit_model(use_median=True) + + ##### + # Astrometry on the sky + ##### + plt.figure(2) + plt.clf() + + # Data + plt.errorbar(data['xpos1']*1e3, data['ypos1']*1e3, + xerr=data['xpos_err1']*1e3, yerr=data['ypos_err1']*1e3, fmt='k.') + + # 1 day sampling over whole range + t_mod = np.arange(data['t_ast1'].min(), data['t_ast1'].max(), 1) + + # Model - usually from fitter + pos_out = mymodel.get_astrometry(t_mod) + plt.plot(pos_out[:, 0]*1e3, pos_out[:, 1]*1e3, 'r-') + + plt.gca().invert_xaxis() + plt.xlabel(r'$\Delta \alpha^*$ (mas)') + plt.ylabel(r'$\Delta \delta$ (mas)') + plt.title('Input Data and Output Model') + + ##### + # astrometry vs. time + ##### + plt.figure(3) + plt.clf() + plt.errorbar(data['t_ast1'], data['xpos1']*1e3, + yerr=data['xpos_err1']*1e3, fmt='k.') + plt.plot(t_mod, pos_out[:, 0]*1e3, 'r-') + plt.xlabel('t - t0 (days)') + plt.ylabel(r'$\Delta \alpha^*$ (mas)') + plt.title('Input Data and Output Model') + + plt.figure(4) + plt.clf() + plt.errorbar(data['t_ast1'], data['ypos1']*1e3, + yerr=data['ypos_err1']*1e3, fmt='k.') + plt.plot(t_mod, pos_out[:, 1]*1e3, 'r-') + plt.xlabel('t - t0 (days)') + plt.ylabel(r'$\Delta \delta$ (mas)') + plt.title('Input Data and Output Model') + + ##### + # Remove the unlensed motion (proper motion) + # astrometry vs. time + ##### + # Make the model unlensed points. + p_mod_unlens_tdat = mymodel.get_astrometry_unlensed(data['t_ast1']) + x_mod_tdat = p_mod_unlens_tdat[:, 0] + y_mod_tdat = p_mod_unlens_tdat[:, 1] + x_no_pm = data['xpos1'] - x_mod_tdat + y_no_pm = data['ypos1'] - y_mod_tdat + + # Make the dense sampled model for the same plot + dp_tmod_unlens = mymodel.get_astrometry(t_mod) - mymodel.get_astrometry_unlensed(t_mod) + x_mod_no_pm = dp_tmod_unlens[:, 0] + y_mod_no_pm = dp_tmod_unlens[:, 1] + + # Prep some colorbar stuff + cmap = plt.cm.viridis + norm = plt.Normalize(vmin=data['t_ast1'].min(), vmax=data['t_ast1'].max()) + smap = plt.cm.ScalarMappable(cmap=cmap, norm=norm) + smap.set_array([]) + + # Average the data for the last three years. + t_year = [] + x_year = [] + y_year = [] + xe_year = [] + ye_year = [] + + t_dat_yr = multinest_plot.mmjd_to_year(data['t_ast1']) + + min_year = np.floor(t_dat_yr.min()) + max_year = np.ceil(t_dat_yr.max()) + + years = np.arange(min_year, max_year + 1, 1) + for tt in range(len(years)-1): + ii = np.where((years[tt] < t_dat_yr) & (t_dat_yr <= years[tt+1]))[0] + + if tt == 100: + t_year = data['t_ast1'][ii].data + x_year = x_no_pm[ii] + y_year = y_no_pm[ii] + xe_year = data['xpos_err1'][ii] + ye_year = data['ypos_err1'][ii] + else: + #wgts = np.hypot(data['xpos_err1'][ii], data['ypos_err1'][ii]) + wgts = (data['xpos_err1'][ii] + data['ypos_err1'][ii]) / 2.0 + t_avg, t_std = weighted_avg_and_std(data['t_ast1'][ii], wgts ) + x_avg, x_std = weighted_avg_and_std(x_no_pm[ii], wgts ) + y_avg, y_std = weighted_avg_and_std(y_no_pm[ii], wgts ) + + t_avg = data['t_ast1'][ii].mean() + t_std = data['t_ast1'][ii].std() + x_avg = x_no_pm[ii].mean() + x_std = x_no_pm[ii].std() + y_avg = y_no_pm[ii].mean() + y_std = y_no_pm[ii].std() + + t_year = np.append( t_year, t_avg ) + x_year = np.append( x_year, x_avg ) + y_year = np.append( y_year, y_avg) + xe_year = np.append( xe_year, x_std / np.sqrt(len(ii) - 1) ) + ye_year = np.append( ye_year, y_std / np.sqrt(len(ii) - 1) ) + + + t_year = np.array(t_year) + x_year = np.array(x_year) + y_year = np.array(y_year) + xe_year = np.array(xe_year) + ye_year = np.array(ye_year) + print(t_year) + print(x_year) + + + plt.figure(5) + plt.clf() + plt.scatter(x_year*1e3, y_year*1e3, c=t_year, + cmap=cmap, norm=norm, s=10) + plt.errorbar(x_year*1e3, y_year*1e3, + xerr=xe_year*1e3, yerr=ye_year*1e3, + fmt='none', ecolor=smap.to_rgba(t_year)) + plt.scatter(x_mod_no_pm*1e3, y_mod_no_pm*1e3, c=t_mod, cmap=cmap, norm=norm, s=4) + plt.gca().invert_xaxis() + plt.axis('equal') + plt.xlabel(r'$\Delta \alpha^*$ (mas)') + plt.ylabel(r'$\Delta \delta$ (mas)') + plt.colorbar() + + + plt.figure(6) + plt.clf() + plt.scatter(x_no_pm*1e3, y_no_pm*1e3, c=data['t_ast1'], + cmap=cmap, norm=norm, s=10) + plt.errorbar(x_no_pm*1e3, y_no_pm*1e3, + xerr=data['xpos_err1']*1e3, yerr=data['ypos_err1']*1e3, + fmt='none', ecolor=smap.to_rgba(data['t_ast1'])) + plt.scatter(x_mod_no_pm*1e3, y_mod_no_pm*1e3, c=t_mod, cmap=cmap, norm=norm, s=4) + plt.gca().invert_xaxis() + plt.axis('equal') + plt.xlabel(r'$\Delta \alpha^*$ (mas)') + plt.ylabel(r'$\Delta \delta$ (mas)') + plt.colorbar() + + return + + +def plot_ob150211_posterior_tE_piE_phot_astrom(): + span=None + levels=None + color='gray' + plot_datapoints=False + plot_density=True + plot_contours=True + no_fill_contours=False + fill_contours=True + contour_kwargs=None + contourf_kwargs=None + data_kwargs=None + + try: + str_type = types.StringTypes + float_type = types.FloatType + int_type = types.IntType + except: + str_type = str + float_type = float + int_type = int + + """ + Basically the _hist2d function from dynesty, but with a few mods I made. + https://github.com/joshspeagle/dynesty/blob/master/dynesty/plotting.py + """ + + tab = Table.read('/u/jlu/work/microlens/OB150211/a_2019_05_04/notes/4_fit_phot_astrom_parallax/bb_.fits') + + x = tab['tE'] + y = (tab['piE_E']**2 + tab['piE_N']**2)**0.5 + weights = tab['weights'] + + plt.close(1) + fig = plt.figure(1) + plt.clf() + ax = plt.gca() + + # Determine plotting bounds. + data = [x, y] + if span is None: + span = [0.999999426697 for i in range(2)] + span = list(span) + if len(span) != 2: + raise ValueError("Dimension mismatch between samples and span.") + for i, _ in enumerate(span): + try: + xmin, xmax = span[i] + except: + q = [0.5 - 0.5 * span[i], 0.5 + 0.5 * span[i]] + span[i] = dyutil.quantile(data[i], q, weights=weights) + + # The default "sigma" contour levels. + if levels is None: + levels = 1.0 - np.exp(-0.5 * np.arange(0.5, 2.1, 0.5) ** 2) + + # Color map for the density plot, over-plotted to indicate the + # density of the points near the center. + density_cmap = LinearSegmentedColormap.from_list( + "density_cmap", [color, (1, 1, 1, 0)]) + + # Color map used to hide the points at the high density areas. + white_cmap = LinearSegmentedColormap.from_list( + "white_cmap", [(1, 1, 1), (1, 1, 1)], N=2) + + # This "color map" is the list of colors for the contour levels if the + # contours are filled. + rgba_color = colorConverter.to_rgba(color) + contour_cmap = [list(rgba_color) for l in levels] + [rgba_color] + for i, l in enumerate(levels): + contour_cmap[i][-1] *= float(i) / (len(levels)+1) + + xmax = x.max() + xmin = x.min() + + ymax = y.max() + ymin = y.min() + + xliml = 0.9 * xmin + xlimu = 1.1 * xmax + xbins = np.linspace(xliml, xlimu, 500) + + yliml = 0.9 * ymin + ylimu = 1.1 * ymax + ybins = np.linspace(yliml, ylimu, 500) + + # We'll make the 2D histogram to directly estimate the density. + H, X, Y = np.histogram2d(x.flatten(), y.flatten(), bins=[xbins, ybins], + range=list(map(np.sort, span)), + weights=weights) + # Smooth the results. + H = norm_kde(H, [3, 3]) + + # Compute the density levels. + Hflat = H.flatten() + inds = np.argsort(Hflat)[::-1] + Hflat = Hflat[inds] + sm = np.cumsum(Hflat) + sm /= sm[-1] + V = np.empty(len(levels)) + for i, v0 in enumerate(levels): + try: + V[i] = Hflat[sm <= v0][-1] + except: + V[i] = Hflat[0] + V.sort() + m = (np.diff(V) == 0) + if np.any(m) and plot_contours: + logging.warning("Too few points to create valid contours.") + logging.warning("Make xnbin or ynbin bigger!!!!!!!") + while np.any(m): + V[np.where(m)[0][0]] *= 1.0 - 1e-4 + m = (np.diff(V) == 0) + V.sort() + + # Compute the bin centers. + X1, Y1 = 0.5 * (X[1:] + X[:-1]), 0.5 * (Y[1:] + Y[:-1]) + + # Extend the array for the sake of the contours at the plot edges. + H2 = H.min() + np.zeros((H.shape[0] + 4, H.shape[1] + 4)) + H2[2:-2, 2:-2] = H + H2[2:-2, 1] = H[:, 0] + H2[2:-2, -2] = H[:, -1] + H2[1, 2:-2] = H[0] + H2[-2, 2:-2] = H[-1] + H2[1, 1] = H[0, 0] + H2[1, -2] = H[0, -1] + H2[-2, 1] = H[-1, 0] + H2[-2, -2] = H[-1, -1] + X2 = np.concatenate([X1[0] + np.array([-2, -1]) * np.diff(X1[:2]), X1, + X1[-1] + np.array([1, 2]) * np.diff(X1[-2:])]) + Y2 = np.concatenate([Y1[0] + np.array([-2, -1]) * np.diff(Y1[:2]), Y1, + Y1[-1] + np.array([1, 2]) * np.diff(Y1[-2:])]) + + # Plot the data points. + if plot_datapoints: + if data_kwargs is None: + data_kwargs = dict() + data_kwargs["color"] = data_kwargs.get("color", color) + data_kwargs["ms"] = data_kwargs.get("ms", 2.0) + data_kwargs["mec"] = data_kwargs.get("mec", "none") + data_kwargs["alpha"] = data_kwargs.get("alpha", 0.1) + ax.plot(x, y, "o", zorder=-1, rasterized=True, **data_kwargs) + + # Plot the base fill to hide the densest data points. + if (plot_contours or plot_density) and not no_fill_contours: + ax.contourf(X2, Y2, H2.T, [V.min(), H.max()], + cmap=white_cmap, antialiased=False) + + if plot_contours and fill_contours: + if contourf_kwargs is None: + contourf_kwargs = dict() + contourf_kwargs["colors"] = contourf_kwargs.get("colors", contour_cmap) + contourf_kwargs["antialiased"] = contourf_kwargs.get("antialiased", + False) + ax.contourf(X2, Y2, H2.T, np.concatenate([[0], V, [H.max()*(1+1e-4)]]), + **contourf_kwargs) + + # Plot the density map. This can't be plotted at the same time as the + # contour fills. + elif plot_density: + ax.pcolor(X, Y, H.max() - H.T, cmap=density_cmap) + + # Plot the contour edge colors. + if plot_contours: + if contour_kwargs is None: + contour_kwargs = dict() + contour_kwargs["colors"] = contour_kwargs.get("colors", color) + ax.contour(X2, Y2, H2.T, V, **contour_kwargs) + + ax.set_xlabel('$t_E$ (days)') + ax.set_ylabel('$\pi_E$') + + ax.set_xlim(132, 144) + ax.set_ylim(0, 0.04) + + plt.show() + + return + +def plot_ob150211_posterior_deltac_piE_phot_astrom(): + span=None + levels=None + color='gray' + plot_datapoints=False + plot_density=True + plot_contours=True + no_fill_contours=False + fill_contours=True + contour_kwargs=None + contourf_kwargs=None + data_kwargs=None + + try: + str_type = types.StringTypes + float_type = types.FloatType + int_type = types.IntType + except: + str_type = str + float_type = float + int_type = int + + """ + Basically the _hist2d function from dynesty, but with a few mods I made. + https://github.com/joshspeagle/dynesty/blob/master/dynesty/plotting.py + """ + + tab = Table.read('/u/jlu/work/microlens/OB150211/a_2019_05_04/notes/4_fit_phot_astrom_parallax/bb_.fits') + + x = tab['tE'] + y = (tab['piE_E']**2 + tab['piE_N']**2)**0.5 + weights = tab['weights'] + + plt.close(1) + fig = plt.figure(1) + plt.clf() + ax = plt.gca() + + # Determine plotting bounds. + data = [x, y] + if span is None: + span = [0.999999426697 for i in range(2)] + span = list(span) + if len(span) != 2: + raise ValueError("Dimension mismatch between samples and span.") + for i, _ in enumerate(span): + try: + xmin, xmax = span[i] + except: + q = [0.5 - 0.5 * span[i], 0.5 + 0.5 * span[i]] + span[i] = dyutil.quantile(data[i], q, weights=weights) + + # The default "sigma" contour levels. + if levels is None: + levels = 1.0 - np.exp(-0.5 * np.arange(0.5, 2.1, 0.5) ** 2) + + # Color map for the density plot, over-plotted to indicate the + # density of the points near the center. + density_cmap = LinearSegmentedColormap.from_list( + "density_cmap", [color, (1, 1, 1, 0)]) + + # Color map used to hide the points at the high density areas. + white_cmap = LinearSegmentedColormap.from_list( + "white_cmap", [(1, 1, 1), (1, 1, 1)], N=2) + + # This "color map" is the list of colors for the contour levels if the + # contours are filled. + rgba_color = colorConverter.to_rgba(color) + contour_cmap = [list(rgba_color) for l in levels] + [rgba_color] + for i, l in enumerate(levels): + contour_cmap[i][-1] *= float(i) / (len(levels)+1) + + xmax = x.max() + xmin = x.min() + + ymax = y.max() + ymin = y.min() + + xliml = 0.9 * xmin + xlimu = 1.1 * xmax + xbins = np.linspace(xliml, xlimu, 500) + + yliml = 0.9 * ymin + ylimu = 1.1 * ymax + ybins = np.linspace(yliml, ylimu, 500) + + # We'll make the 2D histogram to directly estimate the density. + H, X, Y = np.histogram2d(x.flatten(), y.flatten(), bins=[xbins, ybins], + range=list(map(np.sort, span)), + weights=weights) + # Smooth the results. + H = norm_kde(H, [3, 3]) + + # Compute the density levels. + Hflat = H.flatten() + inds = np.argsort(Hflat)[::-1] + Hflat = Hflat[inds] + sm = np.cumsum(Hflat) + sm /= sm[-1] + V = np.empty(len(levels)) + for i, v0 in enumerate(levels): + try: + V[i] = Hflat[sm <= v0][-1] + except: + V[i] = Hflat[0] + V.sort() + m = (np.diff(V) == 0) + if np.any(m) and plot_contours: + logging.warning("Too few points to create valid contours.") + logging.warning("Make xnbin or ynbin bigger!!!!!!!") + while np.any(m): + V[np.where(m)[0][0]] *= 1.0 - 1e-4 + m = (np.diff(V) == 0) + V.sort() + + # Compute the bin centers. + X1, Y1 = 0.5 * (X[1:] + X[:-1]), 0.5 * (Y[1:] + Y[:-1]) + + # Extend the array for the sake of the contours at the plot edges. + H2 = H.min() + np.zeros((H.shape[0] + 4, H.shape[1] + 4)) + H2[2:-2, 2:-2] = H + H2[2:-2, 1] = H[:, 0] + H2[2:-2, -2] = H[:, -1] + H2[1, 2:-2] = H[0] + H2[-2, 2:-2] = H[-1] + H2[1, 1] = H[0, 0] + H2[1, -2] = H[0, -1] + H2[-2, 1] = H[-1, 0] + H2[-2, -2] = H[-1, -1] + X2 = np.concatenate([X1[0] + np.array([-2, -1]) * np.diff(X1[:2]), X1, + X1[-1] + np.array([1, 2]) * np.diff(X1[-2:])]) + Y2 = np.concatenate([Y1[0] + np.array([-2, -1]) * np.diff(Y1[:2]), Y1, + Y1[-1] + np.array([1, 2]) * np.diff(Y1[-2:])]) + + # Plot the data points. + if plot_datapoints: + if data_kwargs is None: + data_kwargs = dict() + data_kwargs["color"] = data_kwargs.get("color", color) + data_kwargs["ms"] = data_kwargs.get("ms", 2.0) + data_kwargs["mec"] = data_kwargs.get("mec", "none") + data_kwargs["alpha"] = data_kwargs.get("alpha", 0.1) + ax.plot(x, y, "o", zorder=-1, rasterized=True, **data_kwargs) + + # Plot the base fill to hide the densest data points. + if (plot_contours or plot_density) and not no_fill_contours: + ax.contourf(X2, Y2, H2.T, [V.min(), H.max()], + cmap=white_cmap, antialiased=False) + + if plot_contours and fill_contours: + if contourf_kwargs is None: + contourf_kwargs = dict() + contourf_kwargs["colors"] = contourf_kwargs.get("colors", contour_cmap) + contourf_kwargs["antialiased"] = contourf_kwargs.get("antialiased", + False) + ax.contourf(X2, Y2, H2.T, np.concatenate([[0], V, [H.max()*(1+1e-4)]]), + **contourf_kwargs) + + # Plot the density map. This can't be plotted at the same time as the + # contour fills. + elif plot_density: + ax.pcolor(X, Y, H.max() - H.T, cmap=density_cmap) + + # Plot the contour edge colors. + if plot_contours: + if contour_kwargs is None: + contour_kwargs = dict() + contour_kwargs["colors"] = contour_kwargs.get("colors", color) + ax.contour(X2, Y2, H2.T, V, **contour_kwargs) + + ax.set_xlabel('$t_E$ (days)') + ax.set_ylabel('$\pi_E$') + + ax.set_xlim(132, 144) + ax.set_ylim(0, 0.04) + + plt.show() + + return + + +def plot_ob150211_posterior_tE_piE_phot_only(): + span=None + levels=None + color='gray' + plot_datapoints=False + plot_density=True + plot_contours=True + no_fill_contours=False + fill_contours=True + contour_kwargs=None + contourf_kwargs=None + data_kwargs=None + + try: + str_type = types.StringTypes + float_type = types.FloatType + int_type = types.IntType + except: + str_type = str + float_type = float + int_type = int + + """ + Basically the _hist2d function from dynesty, but with a few mods I made. + https://github.com/joshspeagle/dynesty/blob/master/dynesty/plotting.py + """ + + tab = Table.read('/u/jlu/work/microlens/OB150211/a_2019_05_04/notes/3_fit_phot_parallax/u0_plusminus/aa_.fits') + + x = tab['tE'] + y = (tab['piE_E']**2 + tab['piE_N']**2)**0.5 + weights = tab['weights'] + + plt.close(2) + fig = plt.figure(2) + plt.clf() + ax = plt.gca() + + # Determine plotting bounds. + data = [x, y] + if span is None: + span = [0.999999426697 for i in range(2)] + span = list(span) + if len(span) != 2: + raise ValueError("Dimension mismatch between samples and span.") + for i, _ in enumerate(span): + try: + xmin, xmax = span[i] + except: + q = [0.5 - 0.5 * span[i], 0.5 + 0.5 * span[i]] + span[i] = dyutil.quantile(data[i], q, weights=weights) + + # The default "sigma" contour levels. + if levels is None: + levels = 1.0 - np.exp(-0.5 * np.arange(0.5, 2.1, 0.5) ** 2) + + # Color map for the density plot, over-plotted to indicate the + # density of the points near the center. + density_cmap = LinearSegmentedColormap.from_list( + "density_cmap", [color, (1, 1, 1, 0)]) + + # Color map used to hide the points at the high density areas. + white_cmap = LinearSegmentedColormap.from_list( + "white_cmap", [(1, 1, 1), (1, 1, 1)], N=2) + + # This "color map" is the list of colors for the contour levels if the + # contours are filled. + rgba_color = colorConverter.to_rgba(color) + contour_cmap = [list(rgba_color) for l in levels] + [rgba_color] + for i, l in enumerate(levels): + contour_cmap[i][-1] *= float(i) / (len(levels)+1) + + xmax = x.max() + xmin = x.min() + + ymax = y.max() + ymin = y.min() + + xliml = 0.9 * xmin + xlimu = 1.1 * xmax + xbins = np.linspace(xliml, xlimu, 500) + + yliml = 0.9 * ymin + ylimu = 1.1 * ymax + ybins = np.linspace(yliml, ylimu, 500) + + # We'll make the 2D histogram to directly estimate the density. + H, X, Y = np.histogram2d(x.flatten(), y.flatten(), bins=[xbins, ybins], + range=list(map(np.sort, span)), + weights=weights) + # Smooth the results. + H = norm_kde(H, [3, 3]) + + # Compute the density levels. + Hflat = H.flatten() + inds = np.argsort(Hflat)[::-1] + Hflat = Hflat[inds] + sm = np.cumsum(Hflat) + sm /= sm[-1] + V = np.empty(len(levels)) + for i, v0 in enumerate(levels): + try: + V[i] = Hflat[sm <= v0][-1] + except: + V[i] = Hflat[0] + V.sort() + m = (np.diff(V) == 0) + if np.any(m) and plot_contours: + logging.warning("Too few points to create valid contours.") + logging.warning("Make xnbin or ynbin bigger!!!!!!!") + while np.any(m): + V[np.where(m)[0][0]] *= 1.0 - 1e-4 + m = (np.diff(V) == 0) + V.sort() + + # Compute the bin centers. + X1, Y1 = 0.5 * (X[1:] + X[:-1]), 0.5 * (Y[1:] + Y[:-1]) + + # Extend the array for the sake of the contours at the plot edges. + H2 = H.min() + np.zeros((H.shape[0] + 4, H.shape[1] + 4)) + H2[2:-2, 2:-2] = H + H2[2:-2, 1] = H[:, 0] + H2[2:-2, -2] = H[:, -1] + H2[1, 2:-2] = H[0] + H2[-2, 2:-2] = H[-1] + H2[1, 1] = H[0, 0] + H2[1, -2] = H[0, -1] + H2[-2, 1] = H[-1, 0] + H2[-2, -2] = H[-1, -1] + X2 = np.concatenate([X1[0] + np.array([-2, -1]) * np.diff(X1[:2]), X1, + X1[-1] + np.array([1, 2]) * np.diff(X1[-2:])]) + Y2 = np.concatenate([Y1[0] + np.array([-2, -1]) * np.diff(Y1[:2]), Y1, + Y1[-1] + np.array([1, 2]) * np.diff(Y1[-2:])]) + + # Plot the data points. + if plot_datapoints: + if data_kwargs is None: + data_kwargs = dict() + data_kwargs["color"] = data_kwargs.get("color", color) + data_kwargs["ms"] = data_kwargs.get("ms", 2.0) + data_kwargs["mec"] = data_kwargs.get("mec", "none") + data_kwargs["alpha"] = data_kwargs.get("alpha", 0.1) + ax.plot(x, y, "o", zorder=-1, rasterized=True, **data_kwargs) + + # Plot the base fill to hide the densest data points. + if (plot_contours or plot_density) and not no_fill_contours: + ax.contourf(X2, Y2, H2.T, [V.min(), H.max()], + cmap=white_cmap, antialiased=False) + + if plot_contours and fill_contours: + if contourf_kwargs is None: + contourf_kwargs = dict() + contourf_kwargs["colors"] = contourf_kwargs.get("colors", contour_cmap) + contourf_kwargs["antialiased"] = contourf_kwargs.get("antialiased", + False) + ax.contourf(X2, Y2, H2.T, np.concatenate([[0], V, [H.max()*(1+1e-4)]]), + **contourf_kwargs) + + # Plot the density map. This can't be plotted at the same time as the + # contour fills. + elif plot_density: + ax.pcolor(X, Y, H.max() - H.T, cmap=density_cmap) + + # Plot the contour edge colors. + if plot_contours: + if contour_kwargs is None: + contour_kwargs = dict() + contour_kwargs["colors"] = contour_kwargs.get("colors", color) + ax.contour(X2, Y2, H2.T, V, **contour_kwargs) + + ax.set_xlabel('$t_E$ (days)') + ax.set_ylabel('$\pi_E$') + + ax.set_xlim(100, 160) + ax.set_ylim(0, 0.12) + + plt.show() + + return + + + +def plot_ob150211_phot(): + data = munge.getdata("ob150211", use_astrom_phot=True, + use_astrom_file=astrom_data[info['target'].lower()]) + + mnest_dir = '/u/jlu/work/microlens/OB150211/a_2019_05_04/notes/3_fit_phot_parallax/u0_plusminus/' + mnest_root = 'aa_' + + fitter = model_fitter.MicrolensSolver(data, + outputfiles_basename = None) + + tab_phot_par = fitter.load_mnest_results() + + multinest_plot.plot_phot_fit(data, mnest_dir, mnest_root, outdir=mnest_dir, parallax=True) + + return + +def marginalize_tE_piE(): + t = Table.read(popsycle_events) + + mas_to_rad = 4.848 * 10**-9 + + bh_idx = np.where(t['rem_id_L'] == 103)[0] + ns_idx = np.where(t['rem_id_L'] == 102)[0] + wd_idx = np.where((t['rem_id_L'] == 101) | + (t['rem_id_L'] == 6))[0] + st_idx = np.where(t['rem_id_L'] == 0)[0] + + # start with a rectangular Figure + plt.close(15) + plt.figure(15, figsize=(8, 8)) + plt.clf() + + minpiE = 0.003 + maxpiE = 5 + mintE = 0.8 + maxtE = 300 + + norm = matplotlib.colors.Normalize(np.log10(np.min(t['mu_rel'])), np.log10(np.max(t['mu_rel']))) + plt.set_cmap('inferno_r') + + # the scatter plot: + plt.scatter(t['t_E'][st_idx], t['pi_E'][st_idx]/mas_to_rad, + alpha = 0.4, label = 'Star', marker = 's', s = 1, + c = np.log10(t['mu_rel'][st_idx]), norm = norm) + plt.scatter(t['t_E'][wd_idx], t['pi_E'][wd_idx]/mas_to_rad, + alpha = 0.4, label = 'WD', marker = 'P', + c = np.log10(t['mu_rel'][wd_idx]), norm = norm) + plt.scatter(t['t_E'][ns_idx], t['pi_E'][ns_idx]/mas_to_rad, + alpha = 0.4, label = 'NS', marker = 'v', + c = np.log10(t['mu_rel'][ns_idx]), norm = norm) + plt.scatter(t['t_E'][bh_idx], t['pi_E'][bh_idx]/mas_to_rad, + alpha = 0.4, label = 'BH', + c = np.log10(t['mu_rel'][bh_idx]), norm = norm) + plt.xlabel('$t_E$ (days)') + plt.ylabel('$\pi_E$') + plt.xscale('log') + plt.yscale('log') + plt.legend() + plt.xlim(mintE, maxtE) + plt.ylim(minpiE, maxpiE) + tEbins = np.logspace(-1, 2.5, 26) + piEbins = np.logspace(-4, 1, 26) + + plt.colorbar() + + plt.show() +# plt.savefig('margin_tE_vs_piE.png') + + return + +def make_all_comparison_plots(): + raise Error("HEY NO DONT") + data_150029 = munge_ob150029.getdata() + data_150211 = munge_ob150211.getdata() + + fit_ob150211_phot_only = model_fitter.PSPL_phot_parallax_Solver(data_150211, + outputfiles_basename = '/u/jlu/work/microlens/OB150211/model_fits/3_fit_phot_parallax/u0_plusminus/aa_') + + fit_ob150211_phot_astr = model_fitter.PSPL_parallax_Solver(data_150211, + outputfiles_basename = '/u/jlu/work/microlens/OB150211/model_fits/4_fit_phot_astrom_parallax/bb_') + + fit_ob150029_phot_only = model_fitter.PSPL_phot_parallax_Solver(data_150029, + outputfiles_basename = '/u/jlu/work/microlens/OB150029/model_fits/3_fit_phot_parallax/u0_plusminus/cc_') + + fit_ob150029_phot_astr = model_fitter.PSPL_parallax_Solver(data_150029, + outputfiles_basename = '/u/jlu/work/microlens/OB150029/model_fits/4_fit_phot_astrom_parallax/aa_') + + # Best fit = median +# fit_ob150211_phot_only.plot_model_and_data_modes() +# fit_ob150211_phot_astr.plot_model_and_data_modes() +# fit_ob150029_phot_only.plot_model_and_data_modes() + fit_ob150029_phot_astr.plot_model_and_data_modes() + + +def plot_all_photometry_single(): + plot_photometry_single('ob120169') + plot_photometry_single('ob150029') + plot_photometry_single('ob150211') + plot_photometry_single('ob140613') + + return + +def plot_photometry_single(target): + data = munge.getdata(target, use_astrom_phot=True, + use_astrom_file=astrom_data[info['target'].lower()]) + + fitter = model_fitter.PSPL_multiphot_astrom_parallax2_Solver(data, outputfiles_basename=pspl_ast_multiphot[target]) + fitter.load_mnest_results() + fitter.separate_modes() + par_all = fitter.get_best_fit_modes(def_best='median') + par = par_all[0] + mod_all = fitter.get_best_fit_modes_model(def_best='median') + mod = mod_all[0] + + ########## + # Make amplification plot + ########## + amp1 = 10**((data['mag1'] - par['mag_src1']) / -2.5) - ((1 - par['b_sff1']) / par['b_sff1']) + amp2 = 10**((data['mag2'] - par['mag_src2']) / -2.5) - ((1 - par['b_sff2']) / par['b_sff2']) + + const = 2.5 / math.log(10) # 1.08574 + f1 = 10**(data['mag1'] / -2.5) + f2 = 10**(data['mag2'] / -2.5) + f_err1 = (1. / const) * data['mag_err1'] * f1 + f_err2 = (1. / const) * data['mag_err2'] * f2 + + f_src1 = 10**(par['mag_src1'] / -2.5) + f_src2 = 10**(par['mag_src2'] / -2.5) + + amp_err1 = f_err1 / f_src1 + amp_err2 = f_err2 / f_src2 + + t_min = np.min(np.append(data['t_phot1'], data['t_phot2'])) + t_max = np.max(np.append(data['t_phot1'], data['t_phot2'])) + t_mod = np.arange(t_min, t_max, 1) + amp_mod = mod.get_amplification(t_mod) + amp_mod_t_dat1 = mod.get_amplification(data['t_phot1']) + amp_mod_t_dat2 = mod.get_amplification(data['t_phot2']) + + plt.close(1) + fig_a = plt.figure(1, figsize=(6,6)) + fig_a.clf() + + f1 = fig_a.add_axes([0.2, 0.33, 0.75, 0.6]) + f2 = fig_a.add_axes([0.2, 0.13, 0.75, 0.2]) + + # Amplification Curve + f1.plot(t_mod, amp_mod, '-', label='model') + f1.errorbar(data['t_phot1'], amp1, yerr=amp_err1, color='red', + label='OGLE I', fmt='r.', alpha=0.4, zorder=3000) + f1.errorbar(data['t_phot2'], amp2, yerr=amp_err2, color='blue', + label='Keck Kp', fmt='b.', alpha=0.6, zorder=3001) + f1.set_ylabel('Amplification') + f1.legend() + f1.set_title(target.upper()) + + # Residuals + f1.get_shared_x_axes().join(f1, f2) + f2.errorbar(data['t_phot1'], amp1 - amp_mod_t_dat1, + yerr=amp_err1, fmt='r.', alpha=0.2) + f2.errorbar(data['t_phot2'], amp2 - amp_mod_t_dat2, + yerr=amp_err2, fmt='b.', alpha=0.2) + f2.axhline(0, linestyle='--', color='r') + f2.set_xlabel('Time (HJD)') + f2.set_ylabel('Obs - Mod') + + ########## + # Make magntidue plot + ########## + mag_mod1 = mod.get_photometry(t_mod, 0) + mag_mod2 = mod.get_photometry(t_mod, 1) + + mag_mod_t_dat1 = mod.get_photometry(data['t_phot1'], 0) + mag_mod_t_dat2 = mod.get_photometry(data['t_phot2'], 1) + + # Calculate the baseline-mag correction factor. + base1 = par['mag_src1'] - (-2.5 * math.log10( par['b_sff1'] )) + base2 = par['mag_src2'] - (-2.5 * math.log10( par['b_sff2'] )) + + dbase = base2 - base1 + print(par['mag_src1'], par['mag_src2']) + print(par['b_sff1'], par['b_sff2']) + print(base1, base2, dbase) + + plt.close(2) + fig_b = plt.figure(2, figsize=(6,6)) + fig_b.clf() + + f3 = fig_b.add_axes([0.2, 0.33, 0.75, 0.6]) + f4 = fig_b.add_axes([0.2, 0.13, 0.75, 0.2]) + + # light curve + f3.errorbar(data['t_phot1'], data['mag1'], yerr=data['mag_err1'], color='red', + label='OGLE I', fmt='r.', alpha=0.4, zorder=3000) + f3.errorbar(data['t_phot2'], data['mag2'] - dbase, yerr=data['mag_err2'], color='blue', + label='Keck Kp + {0:.1f}'.format(-dbase), fmt='b.', alpha=0.6, zorder=3000) + f3.invert_yaxis() + f3.plot(t_mod, mag_mod1, 'r--') + f3.plot(t_mod, mag_mod2 - dbase, 'b--') + f3.set_ylabel('Observed Magnitude') + f3.legend() + f3.set_title(target.upper()) + + # residuals + f3.get_shared_x_axes().join(f3, f4) + f4.errorbar(data['t_phot1'], data['mag1'] - mag_mod_t_dat1, + yerr=data['mag_err1'], fmt='r.', alpha=0.2) + f4.errorbar(data['t_phot2'], data['mag2'] - mag_mod_t_dat2, + yerr=data['mag_err2'], fmt='b.', alpha=0.2) + f4.axhline(0, linestyle='--', color='r') + f4.set_xlabel('Time (HJD)') + f4.set_ylabel('Obs - Mod') + + return + +def get_base_photometry(): + + fmt = '{0:s}: Kp = {1:6.3f} +/- {2:6.3f} mag' + for targ, ep in epochs.items(): + # Fetch the photometry for this target + data = munge.getdata(targ, use_astrom_phot=True, + use_astrom_file=astrom_data[info['target'].lower()]) + + # Photometry 2 is the Kp photometry. Only get the last 4 epochs. + times = data['t_phot2'] + mags = data['mag2'] + + sdx = times.argsort() + times = times[sdx] + mags = mags[sdx] + + mags = mags[-4:] + + m_mean = mags.mean() + m_err = mags.std() + + print(fmt.format(targ, m_mean, m_err)) + + return + +def get_num_ref_stars(): + all_targets = epochs.keys() + + print('Number of reference stars for transformation:') + + for target in all_targets: + ast_data_file = astrom_data[target] + data5 = Table.read(ast_data_file) + + if target != 'ob150029': + ast_data_file = ast_data_file.replace('p5', 'p4') + data4 = Table.read(ast_data_file) + else: + data4 = data5 + + print('{0:s} N={1:d} N_final={2:d}'.format(target, + data4['use_in_trans'].sum(), + data5['use_in_trans'].sum())) + + return + + +def plot_vpd(): + all_targets = epochs.keys() + #all_targets = ['ob150029'] + for target in all_targets: + ast_data_file = astrom_data[target] + + data = Table.read(ast_data_file) + + # Flip the coordinates to what we see on sky (+x increase to the East) + # Convert proper motions to mas/yr + data['x'] *= -1.0 + data['x0'] *= -1.0 + data['vx'] *= -1.0 + + data['vx'] *= 1e3 # mas/yr + data['vy'] *= 1e3 # mas/yr + data['vx_err'] *= 1e3 # mas/yr + data['vy_err'] *= 1e3 # mas/yr + + # Trim out junky data: + # -- stars detected in too few epochs + # -- stars with too-large proper motion errors. + verr_max = 0.5 + idx = np.where((data['n_fit'] > 5) & + (data['vx_err'] < verr_max) & + (data['vx_err'] < verr_max))[0] + fmt = '{0:s}: Trimming out {1:d} of {2:d} junk stars.' + print(fmt.format(target, len(data) - len(idx), len(data))) + + data = data[idx] + + # Find the target. + tdx = np.where(data['name'] == target)[0] + + # Plot the proper motion VPD. + plt.close(1) + plt.figure(1) + plt.clf() + plt.errorbar(data['vx'], data['vy'], xerr=data['vx_err'], yerr=data['vy_err'], fmt='k.') + plt.errorbar(data['vx'][tdx], data['vy'][tdx], xerr=data['vx_err'][tdx], yerr=data['vy_err'][tdx], fmt='r.', ecolor='red') + plt.axis('equal') + plt.gca().invert_xaxis() + plt.xlabel(r'$\mu_{\alpha^*}$ (mas/yr)') + plt.xlabel(r'$\mu_{\delta}$ (mas/yr)') + plt.ylim(-15, 15) + plt.xlim(15, -15) + + return + +def get_num_data_points(data_dict, astrometryFlag=True, verbose=False): + N_data = 0 + + # Loop through photometry data + for pp in range(len(data_dict['phot_files'])): + N_phot_pp = len(data_dict['t_phot{0:d}'.format(pp+1)]) + if verbose: print('N_phot_pp = ', N_phot_pp) + N_data += N_phot_pp + + # Loop through astrometry data + if astrometryFlag: + for aa in range(len(data_dict['ast_files'])): + # Multiply astrometry by 2 to account for X and Y independent positions. + if len(data_dict['ast_files']) > 1: + N_ast_aa = 2 * len(data_dict['t_ast{0:d}'.format(aa+1)]) + else: + N_ast_aa = 2 * len(data_dict['t_ast1']) + + if verbose: print('N_ast_aa = ', N_ast_aa) + N_data += N_ast_aa + + if verbose: print('N_data = ', N_data) + + return N_data + + +#plot_images() +#make_obs_table() + +#calc_base_mag() +#plot_pos_err() + +#compare_all_linear_motions() +#plot_linear_motion_all() +# +## separate_modes_all() +# +#plot_ob120169_phot_ast() +#plot_ob140613_phot_ast() +#plot_ob150029_phot_ast() +#plot_ob150211_phot_ast() +# +## PSPL Fit Tables and Results Values +## org_solutions_for_table() +## -- Manually adjust which solutions are positive/negative/best +## -- and the order to display the solutions in the table functions below. +#table_ob120169_phot_astrom() +#table_ob140613_phot_astrom() +#table_ob150029_phot_astrom() +#table_ob150211_phot_astrom() +#table_ob150211_phot() +# +## Parameters and confidence intervals for the results text. +## results_best_params_all() +# +## Lens Geometry, velocity plots +#targets = ['ob120169', 'ob140613', 'ob150029', 'ob150211'] +#for targ in targets: +# plot_linear_motion(targ) +# plot_lens_geometry(targ, axis_lim_scale=1, vel_scale=0.25) +# calc_velocity(targ) +# plot_trace_corner(targ) +# +## Mass Posteriors +#plot_ob150211_mass_posterior_modes() +#plot_all_mass_posteriors() +# +## Statistics +#for targ in targets: +# calc_bayes_factor(targ) +# +## tE vs. piE vs. deltaC plots +#piE_tE_deltac(fit_type='ast') +# +## CMDs +#plot_cmds() diff --git a/jlu/papers/lu_2019_lens.py b/jlu/papers/lu_2019_lens.py index 33cd6ca..9849f7f 100755 --- a/jlu/papers/lu_2019_lens.py +++ b/jlu/papers/lu_2019_lens.py @@ -6314,7 +6314,11 @@ def get_data_and_fitter(mnest_base): ast_dsets = [] my_model = getattr(model, info['model']) - my_data = munge.getdata2(info['target'].lower(), + tgt =info['target'].lower() + if '_perlmutter' in tgt: + tgt = tgt.split('_')[0] + print(tgt) + my_data = munge.getdata2(tgt, phot_data=pho_dsets, ast_data=ast_dsets) diff --git a/jlu/papers/prop_keck_26B.ipynb b/jlu/papers/prop_keck_26B.ipynb new file mode 100755 index 0000000..826ba7f --- /dev/null +++ b/jlu/papers/prop_keck_26B.ipynb @@ -0,0 +1,845 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 18, + "id": "7a776cc5-03b7-4edb-aa89-b97568ea587e", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import json\n", + "import pylab as plt\n", + "import pdb\n", + "import math\n", + "import os\n", + "from jlu.observe import skycalc\n", + "from microlens.jlu import munge \n", + "from microlens.jlu import model_fitter, model\n", + "import shutil, os, sys\n", + "import scipy\n", + "import scipy.stats\n", + "from scipy.stats import chi2\n", + "from jlu.papers import huston_2025_lens\n", + "from astropy.table import Table\n", + "from jlu.util import fileUtil\n", + "from astropy.table import Table, Column, vstack\n", + "from astropy.io import fits\n", + "import matplotlib.ticker\n", + "import matplotlib.colors\n", + "from matplotlib.pylab import cm\n", + "from matplotlib.colors import Normalize, LogNorm\n", + "import mpl_toolkits\n", + "from mpl_toolkits.axes_grid1.axes_divider import make_axes_locatable\n", + "from matplotlib.ticker import NullFormatter\n", + "from microlens.jlu import model_fitter, multinest_utils, multinest_plot, munge_ob150211, munge_ob150029, model\n", + "from matplotlib.colors import LinearSegmentedColormap, colorConverter\n", + "import pdb\n", + "import pickle\n", + "from scipy.stats import norm\n", + "import yaml\n", + "from flystar import plots\n", + "from flystar import analysis\n", + "from astropy.coordinates import SkyCoord\n", + "import astropy.units as u\n", + "from astropy.io import fits\n", + "from astropy.wcs import WCS\n", + "from jlu.util import datetimeUtil as dtUtil\n", + "from datetime import datetime as dt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "959fc0c5-0fdc-4851-99bb-bccea5d25fce", + "metadata": {}, + "outputs": [], + "source": [ + "# Fontsize\n", + "plt.rc('font', size=17)\n", + "\n", + "# Default matplotlib color cycles.\n", + "mpl_b = '#1f77b4'\n", + "mpl_o = '#ff7f0e'\n", + "mpl_g = '#2ca02c'\n", + "mpl_r = '#d62728'" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "afbe283f-d06f-4493-adea-8c7f99581b55", + "metadata": {}, + "outputs": [], + "source": [ + "phot_ast_fits = {'MB09260' : '/u/jlu/work/microlens/MB09260/a_2021_09_19/model_fits/moa_hst_phot_ast_gp/base_a/a0_',\n", + " 'MB09260_split' : '/u/jlu/work/microlens/MB09260/a_2021_09_19/model_fits/moa_hst_phot_ast_gp/base_a/a0_split_',\n", + " 'MB10364' : '/u/jlu/work/microlens/MB10364/a_2021_09_19/model_fits/moa_hst_phot_ast_adderr/base_a/a0_', # NO GP, TEMPORARY \n", + " 'OB110037' : '/u/jlu/work/microlens/OB110037/a_2021_07_08/model_fits/ogle_hst_phot_ast_gp/base_a/a0_',\n", + " 'OB110310' : '/u/jlu/work/microlens/OB110310/a_2021_07_08/model_fits/ogle_hst_phot_ast_gp/base_a/a0_',\n", + " 'OB110310_split' : '/u/jlu/work/microlens/OB110310/a_2021_07_08/model_fits/ogle_hst_phot_ast_gp/base_a/a0_split_',\n", + " 'OB110462_el' : '/u/jlu/work/microlens/OB110462/a_2021_12_28/model_fits/ogle_hst_phot_ast/pspl/fixed_weight/a0_', # EQUAL LIKELIHOOD \n", + " 'OB110462_p' : '/u/jlu/work/microlens/OB110462/a_2021_07_08/model_fits/ogle_hst_phot_ast_gp/u0p_En_Nn/a0_',\n", + " 'OB110462_new_dw_ast' : '/u/jlu/work/microlens/OB110462/a_2023_04_23/model_fits/hst_ast/base_a/a0_',\n", + " #'MB19284' : '/g2/scratch/jlu/microlens/MB19284/a_2024_08_29/model_fit/BSPL_base_a0_allDATA_Hobson_Weighted_noOM_dragon/a0_'\n", + " 'MB19284' : '/u/jlu/work/microlens/MB19284/a_2025_11_11/model_fit/BSPL_base_a0_EW_OM_nersc/a0_'\n", + " }\n", + "# From reanalysis\n", + "phot_fits = {'OB110462' : '/u/jlu/work/microlens/OB110462/a_2023_04_23/model_fits/ogle_hst_phot_gp/base_a/a0_'} # nominal fits \n", + "ast_fits = {'OB110462' : '/u/jlu/work/microlens/OB110462/a_2023_04_23/model_fits/hst_ast/base_a/a0_'}\n", + "\n", + "mdir = '/u/jlu/work/microlens/'\n", + "phot_2020_dir = {'kb200101' : mdir + 'KB200101/a_2026_01_08/model_fit/PSPL_phot_only/a0_',\n", + " 'MB19284' : mdir + 'MB19284/a_2025_11_11/model_fit/BSPL_base_a0_EW_OM_nersc/a0_',\n", + " 'ob190017' : mdir + 'OB190017/a_2025_09_17/a0_',\n", + " 'ob170019' : mdir + 'OB170019/a_2025_09_17/a2_',\n", + " 'ob170095' : mdir + 'OB170095/a_2025_09_17/a0_',\n", + " 'ob230215' : mdir + 'OB230215_MB23024/a_2026_03_19/model_fits/a0_',\n", + " 'ob240062' : mdir + 'OB240062/a_2026_03_19/model_fits/a0_'}" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "acd56345-a16f-40bd-9bc2-3744df9d2c28", + "metadata": {}, + "outputs": [], + "source": [ + "# run directory\n", + "ob120169_dir = '/u/jlu/work/microlens/OB120169/a_2026_01_07/model_fits/ogle_keck/124_phot_astrom_aerr_merr/'\n", + "ob140613_dir = '/u/jlu/work/microlens/OB140613/a_2026_01_07/model_fits/perlmutter/NOOS/ogle_moa_keck/124_phot_astrom_aerr_merr/'\n", + "ob150029_dir = '/u/jlu/work/microlens/OB150029/a_2026_01_07/model_fits/perlmutter/ogle_moa_keck/124noV_phot_astrom_aerr_merr/'\n", + "ob150211_dir = '/u/jlu/work/microlens/OB150211/a_2026_01_07/model_fits/ogle_keck/123_phot_astrom_aerr/'\n", + "\n", + "# run id\n", + "ob120169_id = 'a4'\n", + "ob140613_id = 'a2'\n", + "ob150029_id = 'a1'\n", + "ob150211_id = 'a0'\n", + "\n", + "mod_roots = {'ob120169': ob120169_dir + ob120169_id + '_',\n", + " 'ob140613': ob140613_dir + ob140613_id + '_',\n", + " 'ob150029': ob150029_dir + ob150029_id + '_',\n", + " 'ob150211': ob150211_dir + ob150211_id + '_',\n", + " 'mb19284': phot_ast_fits['MB19284']}" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "8386db22-7c4e-4222-a002-35d47dac5022", + "metadata": {}, + "outputs": [], + "source": [ + "pspl_ast_multiphot = {'ob120169': ob120169_dir + ob120169_id + '_',\n", + " 'ob140613': ob140613_dir + ob140613_id + '_',\n", + " 'ob140613_alt': ob140613_dir + ob140613_id + '_',\n", + " 'ob150029': ob150029_dir + ob150029_id + '_',\n", + " 'ob150211': ob150211_dir + ob150211_id + '_'}\n", + "pspl_ast_multiphot_mode = {'ob120169': 0,\n", + " 'ob140613': 0,\n", + " 'ob140613_alt': 1,\n", + " 'ob150029': 0,\n", + " 'ob150211': 0}" + ] + }, + { + "cell_type": "markdown", + "id": "560843d7-8139-4ebb-aeb5-71af0eb37bc4", + "metadata": {}, + "source": [ + "# Airmass + moon position" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ff70ab0e-4494-4f3a-b32b-54c8a5d0e6f3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[['17:53:57.68', '-28:34:21.6'], ['18:05:55.06', '-30:20:12.94'], ['18:20:20.3777', '-21:35:14.9'], ['17:49:11.12', '-21:10:19.9']]\n" + ] + } + ], + "source": [ + "target_data = json.load(open('/u/mhuston/code/plot-airmass/target_coords.json'))\n", + "print([target_data['all_coords'][x] for x in target_data['run_targets']['Keck_AO_2025']])" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "51e4baa4-eefe-4ae3-a86c-8462f8f1dac6", + "metadata": {}, + "outputs": [], + "source": [ + "ra = \"18:00:00\"\n", + "dec = \"-30:00:00\"\n", + "months = np.array([8,8,9])\n", + "days = np.array([1,15,1])\n", + "outdir = '/u/mhuston/work/prop_keck_2026b/'" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "8cf2c0b2-113c-4de9-a7a4-84642ef57dce", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Midnight: 2026-08-15 10:00:00.000\n", + "Sunrise 6.1 Sunset -5.2 (hours around midnight HST)\n", + "12-degr -4.3 12-degr 5.2 (hours around midnight HST)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "skycalc.plot_airmass(ra, dec, 2026, months, days, 'keck1', outfile=outdir + 'microlens_airmass_keck1_26B.png', \n", + " date_idx=1, proposal_cycle = 'B')" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "2cf94793-555d-4686-a816-786e944e50d5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Day: 1 Moon Illum: 92.3 Moon Dist: 69.9\n", + "Day: 2 Moon Illum: 85.9 Moon Dist: 82.6\n", + "Day: 3 Moon Illum: 77.9 Moon Dist: 95.6\n", + "Day: 4 Moon Illum: 68.3 Moon Dist: 108.8\n", + "Day: 5 Moon Illum: 57.7 Moon Dist: 122.3\n", + "Day: 6 Moon Illum: 46.5 Moon Dist: 136.1\n", + "Day: 7 Moon Illum: 35.3 Moon Dist: 150.1\n", + "Day: 8 Moon Illum: 24.6 Moon Dist: 164.4\n", + "Day: 9 Moon Illum: 15.1 Moon Dist: 177.0\n", + "Day: 10 Moon Illum: 7.6 Moon Dist: 165.6\n", + "Day: 11 Moon Illum: 2.5 Moon Dist: 150.9\n", + "Day: 12 Moon Illum: 0.2 Moon Dist: 136.2\n", + "Day: 13 Moon Illum: 0.6 Moon Dist: 121.7\n", + "Day: 14 Moon Illum: 3.7 Moon Dist: 107.5\n", + "Day: 15 Moon Illum: 9.1 Moon Dist: 93.6\n", + "Day: 16 Moon Illum: 16.2 Moon Dist: 80.2\n", + "Day: 17 Moon Illum: 24.6 Moon Dist: 67.3\n", + "Day: 18 Moon Illum: 33.8 Moon Dist: 54.7\n", + "Day: 19 Moon Illum: 43.4 Moon Dist: 42.4\n", + "Day: 20 Moon Illum: 53.0 Moon Dist: 30.3\n", + "Day: 21 Moon Illum: 62.4 Moon Dist: 18.5\n", + "Day: 22 Moon Illum: 71.3 Moon Dist: 6.7\n", + "Day: 23 Moon Illum: 79.5 Moon Dist: 5.4\n", + "Day: 24 Moon Illum: 86.6 Moon Dist: 17.2\n", + "Day: 25 Moon Illum: 92.5 Moon Dist: 29.2\n", + "Day: 26 Moon Illum: 96.8 Moon Dist: 41.4\n", + "Day: 27 Moon Illum: 99.4 Moon Dist: 53.9\n", + "Day: 28 Moon Illum: 99.9 Moon Dist: 66.5\n", + "Day: 29 Moon Illum: 98.3 Moon Dist: 79.4\n", + "Day: 30 Moon Illum: 94.5 Moon Dist: 92.6\n", + "Day: 1 Moon Illum: 80.7 Moon Dist: 119.5\n", + "Day: 2 Moon Illum: 71.2 Moon Dist: 133.2\n", + "Day: 3 Moon Illum: 60.5 Moon Dist: 147.0\n", + "Day: 4 Moon Illum: 49.1 Moon Dist: 161.0\n", + "Day: 5 Moon Illum: 37.7 Moon Dist: 174.5\n", + "Day: 6 Moon Illum: 26.9 Moon Dist: 169.9\n", + "Day: 7 Moon Illum: 17.2 Moon Dist: 155.8\n", + "Day: 8 Moon Illum: 9.4 Moon Dist: 141.5\n", + "Day: 9 Moon Illum: 3.8 Moon Dist: 127.2\n", + "Day: 10 Moon Illum: 0.7 Moon Dist: 113.1\n", + "Day: 11 Moon Illum: 0.1 Moon Dist: 99.2\n", + "Day: 12 Moon Illum: 2.0 Moon Dist: 85.7\n", + "Day: 13 Moon Illum: 6.1 Moon Dist: 72.4\n", + "Day: 14 Moon Illum: 11.9 Moon Dist: 59.5\n", + "Day: 15 Moon Illum: 19.2 Moon Dist: 47.0\n", + "Day: 16 Moon Illum: 27.5 Moon Dist: 34.7\n", + "Day: 17 Moon Illum: 36.5 Moon Dist: 22.6\n", + "Day: 18 Moon Illum: 45.9 Moon Dist: 10.8\n", + "Day: 19 Moon Illum: 55.3 Moon Dist: 1.7\n", + "Day: 20 Moon Illum: 64.6 Moon Dist: 13.1\n", + "Day: 21 Moon Illum: 73.5 Moon Dist: 25.0\n", + "Day: 22 Moon Illum: 81.6 Moon Dist: 37.1\n", + "Day: 23 Moon Illum: 88.6 Moon Dist: 49.5\n", + "Day: 24 Moon Illum: 94.2 Moon Dist: 62.2\n", + "Day: 25 Moon Illum: 98.1 Moon Dist: 75.1\n", + "Day: 26 Moon Illum: 99.9 Moon Dist: 88.4\n", + "Day: 27 Moon Illum: 99.3 Moon Dist: 102.0\n", + "Day: 28 Moon Illum: 96.3 Moon Dist: 115.8\n", + "Day: 29 Moon Illum: 90.8 Moon Dist: 129.8\n", + "Day: 30 Moon Illum: 83.2 Moon Dist: 143.9\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "skycalc.plot_moon(ra, dec, 2026, [8,9], outfile=outdir + 'microlens_moon_26B.png')" + ] + }, + { + "cell_type": "markdown", + "id": "efd3caf1-4b04-4be9-88fc-2acb72f796db", + "metadata": {}, + "source": [ + " # tE piE plots" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "74accfcc-a99c-4e36-82f3-513293dd2589", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/mambaforge3/envs/astro/lib/python3.11/site-packages/scipy/optimize/_minpack_py.py:178: RuntimeWarning: The iteration is not making good progress, as measured by the \n", + " improvement from the last ten iterations.\n", + " warnings.warn(msg, RuntimeWarning)\n", + "/opt/mambaforge3/envs/astro/lib/python3.11/site-packages/scipy/optimize/_minpack_py.py:178: RuntimeWarning: The iteration is not making good progress, as measured by the \n", + " improvement from the last ten iterations.\n", + " warnings.warn(msg, RuntimeWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "***** WARNING: PHOTOMETRY DATA WILL NOT BE FIT BY *****\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: Tried to get polar motions for times after IERS data is valid. Defaulting to polar motion from the 50-yr mean for those. This may affect precision at the arcsec level. Please check your astropy.utils.iers.conf.iers_auto_url and point it to a newer version if necessary. [astropy.coordinates.builtin_frames.utils]\n", + "WARNING: Tried to get polar motions for times after IERS data is valid. Defaulting to polar motion from the 50-yr mean for those. This may affect precision at the arcsec level. Please check your astropy.utils.iers.conf.iers_auto_url and point it to a newer version if necessary. [astropy.coordinates.builtin_frames.utils]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ob120169 178.3909805502215 0.15424644712651073 56020.309461986544\n", + "ob140613 294.68210713606095 0.15113210495397678 57192.19351099519\n", + "ob140613 294.68210713606095 0.15113210495397678\n", + "ob150029 121.66692824699746 0.14980118441292853 57246.06640664478\n", + "ob150029 121.66692824699746 0.14980118441292853\n", + "ob150211 124.22550717872723 0.03855724542901922 57212.15049831765\n", + "ob170019 135.2091970486517 0.06227405755684999 57928.34652272504\n", + "ob170019 135.2091970486517 0.06227405755684999\n", + "ob170095 105.63364685242767 0.06587231278387992 57892.19722745522\n", + "ob190017 243.97568134943612 0.29487147224277366 58604.581484277944\n", + "kb200101 98.45919261964956 0.034818459211325044 59022.45940951111\n", + "ob230215 388.33970285280043 0.1395076980046931 60005.16905096981\n", + "ob240062 191.92819312453204 0.034405414031792196 60448.52966120576\n", + "MB09260 142.9685443906927 0.09596691148210074 55099.27950805289\n", + "MB10364 61.107527351576955 0.2665760903689065 55445.12856951317\n", + "OB110037 92.80317932371783 0.37113004158553836 55781.51110912173\n", + "OB110310 82.92010219198843 0.14585662708090866 55802.353201738806\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/u/mhuston/code/BAGLE_Microlensing/src/bagle/model_fitter.py:5791: UserWarning: The following kwargs were not used by contour: 'quantiles_2d'\n", + " ax.contour(X2, Y2, H2.T, V, colors = color, **contour_kwargs, **kwargs)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def piE_tE(fit_type = 'ast'):\n", + " \"\"\"\n", + " Supports plotting for several different fit solutions:\n", + "\n", + " fit_type = 'ast'\n", + " Keck + OGLE photometry, Keck astrometry\n", + " fit_type = 'phot'\n", + " OGLE photometry\n", + " fit_type = 'multiphot'\n", + " Keck + OGLE photometry\n", + " \"\"\"\n", + " piE_tE_textsize = 22\n", + " \n", + " if fit_type == 'ast':\n", + " data_dict = mod_roots\n", + " if fit_type == 'phot':\n", + " data_dict = huston_2025_lens.pspl_phot\n", + " if fit_type == 'multiphot':\n", + " data_dict = huston_2025_lens.pspl_multiphot\n", + "\n", + " ##########\n", + " # !!! NOTE: CHOICE OF THE quantiles_2d HAS A LARGE EFFECT \n", + " # ON THE WAY THIS PLOT LOOKS !!!\n", + " # Plot piE-tE 2D posteriors from OGLE photometry only fits.\n", + " # Also plot PopSyCLE simulations simultaneously.\n", + " ##########\n", + " span = 0.999999426697\n", + " smooth = 0.04\n", + " quantiles_2d = None\n", + " hist2d_kwargs = None\n", + " labels = None\n", + " label_kwargs = None\n", + " show_titles = False \n", + " title_fmt = \".2f\" \n", + " title_kwargs = None\n", + " \n", + " # Initialize values.\n", + " if label_kwargs is None:\n", + " label_kwargs = dict()\n", + " if title_kwargs is None:\n", + " title_kwargs = dict()\n", + " if hist2d_kwargs is None:\n", + " hist2d_kwargs = dict()\n", + "\n", + " # Dictionary of dictionaries containing the tE and piE\n", + " # label position for each of the text labels.\n", + " # WARNING: THE 'PHOT' AND 'AST' ARE THE SAME FOR THE NEW\n", + " # TARGETS... THEY ARE JUST PHOT THOUGH.\n", + " label_pos = {'phot': {'OB110462': [400, 0.15],\n", + " 'ob120169': [150, 0.01],\n", + " 'ob140613': [170, 0.1],\n", + " 'ob150029': [150, 0.2],\n", + " 'ob150211': [35, 0.04],\n", + " 'ob170019': [0, 0.04],\n", + " 'ob170095': [0, 0.04],\n", + " 'ob190017': [0, 0.04],\n", + " 'kb200101': [0, 0],\n", + " 'ob230215': [400, 0.1],\n", + " 'ob240062': [220, 0.03]},\n", + " 'ast': {'OB110462': [250, 0.06],\n", + " 'ob120169': [45, 0.12],\n", + " 'ob140613': [250, 0.16],\n", + " 'ob150029': [40, 0.22],\n", + " 'ob150211': [140, 0.01],\n", + " 'ob170019': [120, 0.045],\n", + " 'ob170095': [30, 0.04],\n", + " 'ob190017': [65, 0.27],\n", + " 'kb200101': [180, 0.016],\n", + " 'MB19284' : [340, 0.1],\n", + " 'ob230215': [300, 0.18],\n", + " 'ob240062': [220, 0.025]}}\n", + "\n", + " label_pos_ast = {'ob120169': [0.006, 0.06],\n", + " 'ob140613': [0.04, 0.145],\n", + " 'ob150029': [0.02, 0.25],\n", + " 'ob150211': [0.03, 0.012]}\n", + "\n", + " colors = {'ob120169': 'blue',\n", + " 'ob140613': 'blue',\n", + " 'ob150029': 'blue',\n", + " 'ob150211': 'blue',\n", + " 'ob170019': 'orange',\n", + " 'ob170095': 'orange',\n", + " 'ob190017': 'green',\n", + " 'kb200101': 'orange',\n", + " 'ob230215': 'green',\n", + " 'ob240062': 'green',\n", + " 'MB09260' : 'gray',\n", + " 'MB10364' : 'gray',\n", + " 'OB110037' : 'gray',\n", + " 'OB110310' : 'gray',\n", + " 'OB110462' : 'magenta',\n", + " 'MB19284': 'purple'}\n", + "\n", + " #manual_pts = {}\n", + "\n", + " # Set defaults.\n", + " hist2d_kwargs['alpha'] = hist2d_kwargs.get('alpha', 0.8)\n", + " hist2d_kwargs['levels'] = hist2d_kwargs.get('levels', quantiles_2d)\n", + "\n", + "# model_fitter.contour2d_alpha(data['tE'], data['piE'], span=[span, span], quantiles_2d=quantiles_2d,\n", + "# ax=axes, smooth=[sy, sx], color='blue',\n", + "# **hist2d_kwargs, plot_density=False, sigma_levels=[1, 2])\n", + "# axes.text(300, 0.025, 'MB19284', color='blue')\n", + "\n", + "\n", + " targets = ['ob120169','ob140613', 'ob150029', 'ob150211'] \n", + " hst_targets = ['MB09260', 'MB10364', 'OB110037', 'OB110310', 'OB110462']\n", + " new_targets = ['ob170019', 'ob170095', 'ob190017', 'kb200101', 'ob230215', 'ob240062']\n", + " label_targets = ['ob190017', 'ob230215', 'ob240062','OB110462', 'MB19284'] #, 'OB110462']\n", + " tE = {}\n", + " t0 = {}\n", + " piE = {}\n", + " theta_E = {}\n", + " weights = {}\n", + "\n", + " for targ in hst_targets:\n", + " if targ == 'OB110462':\n", + " fit_targ, dat_targ = multinest_utils.get_data_and_fitter(ast_fits['OB110462'])\n", + " else:\n", + " fit_targ, dat_targ = multinest_utils.get_data_and_fitter(phot_ast_fits[targ])\n", + "\n", + " res_targ = fit_targ.load_mnest_results()\n", + "\n", + " tE[targ] = res_targ['tE']\n", + " t0[targ] = res_targ['t0']\n", + " piE[targ] = np.hypot(res_targ['piE_E'], res_targ['piE_N'])\n", + " theta_E[targ] = 10**res_targ['log10_thetaE']\n", + " weights[targ] = res_targ['weights']\n", + "\n", + " for targ in targets:\n", + " fitter, data = huston_2025_lens.get_data_and_fitter(pspl_ast_multiphot[targ])\n", + " #fitter.separate_modes()\n", + "# stats_ast, data_ast, mod_ast = lu_2019_lens.load_summary_statistics(lu_2019_lens.pspl_ast_multiphot[targ])\n", + " tab_list = fitter.load_mnest_modes()\n", + " mode = pspl_ast_multiphot_mode[targ]\n", + " #fit_targ, dat_targ = multinest_utils.get_data_and_fitter(pspl_ast_multiphot[targ])\n", + "\n", + " res_targ = tab_list[mode]\n", + " \n", + "# res_targ = fit_targ.load_mnest_results(remake_fits=True)\n", + "# res_targ = fit_targ.load_mnest_modes()\n", + "# res_targ = res_targ[0]\n", + "#\n", + " tE[targ] = res_targ['tE']\n", + " t0[targ] = res_targ['t0']\n", + " piE[targ] = np.hypot(res_targ['piE_E'], res_targ['piE_N'])\n", + " try:\n", + " theta_E[targ] = res_targ['thetaE_amp']\n", + " except:\n", + " theta_E[targ] = res_targ['thetaE']\n", + " weights[targ] = res_targ['weights']\n", + "\n", + " for targ in new_targets:\n", + " fit_targ, dat_targ = multinest_utils.get_data_and_fitter(phot_2020_dir[targ])\n", + " \n", + " res_targ = fit_targ.load_mnest_modes()\n", + " smy_targ = fit_targ.load_mnest_summary()\n", + "\n", + " # Get rid of the global mode in the summary table.\n", + " smy_targ = smy_targ[1:]\n", + "\n", + " # Find which solution has the max likelihood.\n", + " mdx = smy_targ['maxlogL'].argmax()\n", + " res_targ = res_targ[0]\n", + " smy_targ = smy_targ\n", + " tE[targ] = res_targ['tE']\n", + " t0[targ] = res_targ['t0']\n", + " piE[targ] = np.hypot(res_targ['piE_E'], res_targ['piE_N'])\n", + " weights[targ] = res_targ['weights']\n", + "\n", + " # Plot the piE-tE 2D posteriors.\n", + "# plt.close(1)\n", + " fig = plt.figure(1, figsize=(6,6))\n", + " plt.clf()\n", + " axes = plt.gca()\n", + " plt.subplots_adjust(bottom=0.15)\n", + " sx = smooth\n", + " sy = smooth\n", + "\n", + " hist2d_kwargs['fill_contours'] = hist2d_kwargs.get('fill_contours', False)\n", + " hist2d_kwargs['plot_contours'] = hist2d_kwargs.get('plot_contours', True)\n", + "\n", + " for targ in targets + new_targets + ['MB09260', 'MB10364', 'OB110037', 'OB110310']:\n", + " model_fitter.contour2d_alpha(tE[targ], piE[targ], span=[span, span], quantiles_2d=quantiles_2d,\n", + " weights=weights[targ], ax=axes, smooth=[sy, sx], color=colors[targ],\n", + " **hist2d_kwargs, plot_density=False, sigma_levels=[1, 2])\n", + " print(targ,np.average(tE[targ], weights=weights[targ]), np.average(piE[targ], weights=weights[targ]), np.average(t0[targ], weights=weights[targ]))\n", + " if targ in ['ob150029', 'ob140613', 'ob170019']:\n", + " print(targ, np.average(tE[targ], weights=weights[targ]), np.average(piE[targ], weights=weights[targ]))\n", + " #manual_pts[targ] = (np.average(tE[targ], weights=weights[targ]), np.average(piE[targ], weights=weights[targ]))\n", + " plt.plot(np.average(tE[targ], weights=weights[targ]), np.average(piE[targ], weights=weights[targ]), 'o', color=colors[targ])\n", + "\n", + " \n", + " hist2d_kwargs['plot_contours'] = hist2d_kwargs.get('plot_contours',\n", + " False)\n", + " hist2d_kwargs['alpha'] = hist2d_kwargs.get('alpha', 0.8)\n", + " model_fitter.contour2d_alpha(tE['OB110462'], piE['OB110462'], span=[span, span], quantiles_2d=quantiles_2d,\n", + " weights=weights['OB110462'], ax=axes, smooth=[sy, sx], color=colors['OB110462'],\n", + " contour_kwargs={'alpha' : 0.9}, plot_density=False, sigma_levels=[1, 2])\n", + "\n", + " hist2d_kwargs['alpha'] = hist2d_kwargs.get('alpha', 0.2)\n", + "\n", + "\n", + " for targ in label_targets:\n", + " axes.text(label_pos[fit_type][targ][0], label_pos[fit_type][targ][1],\n", + " targ.upper(), color=colors[targ], ha='left')\n", + "\n", + " # OB110022 from Lu+16.\n", + " piEE_110022 = -0.393\n", + " piEN_110022 = -0.071\n", + " piE_110022 = np.hypot(piEE_110022, piEN_110022)\n", + " tE_110022 = 61.4\n", + "\n", + " dcmax_110022 = 2.19/np.sqrt(8)\n", + " dcmax_110022_pe = 1.06/np.sqrt(8)\n", + " dcmax_110022_me = 1.17/np.sqrt(8)\n", + "\n", + " # MB19284 from nersc 2026\n", + " piEE_19284 = 0.0\n", + " piEN_19284 = -0.14\n", + " piE_19284 = np.hypot(piEE_19284, piEN_19284)\n", + " tE_19284 = 784\n", + "\n", + " # Plotting OB110022 and MB19284.\n", + " plt.scatter(tE_19284, piE_19284, marker = 'o', s = 30, color=colors['MB19284'])\n", + "# axes.text(18, 0.38, 'OB110022', color='indigo')\n", + " plt.scatter(tE_110022, piE_110022, marker = 's', s = 40, color='gray')\n", + " #plt.scatter(129.4, 0.04, marker = 's', s = 40, color='blue')\n", + " #plt.plot(906, 0.102, 'o', color='green')\n", + " \n", + " t = Table.read('/u/nsabrams/work/papers/binary_popsycle/data/all_fields_Srun_EWS.fits')\n", + " lmag = t['ubv_I_app_L']\n", + " smag = t['ubv_I_app_S']\n", + " \n", + "\n", + " bh_idx = np.where(t['rem_id_L'] == 103)[0]\n", + " ns_idx = np.where(t['rem_id_L'] == 102)[0]\n", + " wd_idx = np.where(t['rem_id_L'] == 101)[0]\n", + " st_idx = np.where(t['rem_id_L'] == 0)[0]\n", + "\n", + " u0_arr = t['u0']\n", + " thetaE_arr = t['theta_E']\n", + " # Stores the maximum astrometric shift\n", + " final_delta_arr = np.zeros(len(u0_arr))\n", + " \n", + " # Stores the lens-source separation corresponding\n", + " # to the maximum astrometric shift\n", + " final_u_arr = np.zeros(len(u0_arr))\n", + "\n", + " # Sort by whether the maximum astrometric shift happens\n", + " # before or after the maximum photometric amplification\n", + " big_idx = np.where(u0_arr > np.sqrt(2))[0]\n", + " small_idx = np.where(u0_arr <= np.sqrt(2))[0]\n", + "\n", + " # Flux ratio of lens to source (and make it 0 if dark lens)\n", + " g_arr = 10**(-0.4 * (lmag - smag))\n", + " g_arr = np.nan_to_num(g_arr.filled(np.nan))\n", + "\n", + " for i in np.arange(len(u0_arr)):\n", + " g = g_arr[i] \n", + " thetaE = thetaE_arr[i] \n", + " # Try all values between u0 and sqrt(2) to find max \n", + " # astrometric shift\n", + " if u0_arr[i] < np.sqrt(2):\n", + " u_arr = np.linspace(u0_arr[i], np.sqrt(2), 100)\n", + " delta_arr = np.zeros(len(u_arr))\n", + " for j in np.arange(len(u_arr)):\n", + " u = u_arr[j] \n", + " numer = 1 + g * (u**2 - u * np.sqrt(u**2 + 4) + 3)\n", + " denom = u**2 + 2 + g * u * np.sqrt(u**2 + 4)\n", + " delta = (u * thetaE/(1 + g)) * (numer/denom)\n", + " delta_arr[j] = delta\n", + " max_idx = np.argmax(delta_arr)\n", + " final_delta_arr[i] = delta_arr[max_idx]\n", + " final_u_arr[i] = u_arr[max_idx]\n", + " # Maximum astrometric shift will occur at sqrt(2)\n", + " if u0_arr[i] > np.sqrt(2):\n", + " u = u0_arr[i]\n", + " numer = 1 + g * (u**2 - u * np.sqrt(u**2 + 4) + 3)\n", + " denom = u**2 + 2 + g * u * np.sqrt(u**2 + 4)\n", + " delta = (u * thetaE/(1 + g)) * (numer/denom)\n", + " final_delta_arr[i] = delta\n", + " final_u_arr[i] = u\n", + "\n", + " axes.scatter(t['t_E'][st_idx], t['pi_E'][st_idx], \n", + " alpha = 0.4, marker = '.', s = 25, \n", + " color = 'paleturquoise')\n", + " axes.scatter(t['t_E'][wd_idx], t['pi_E'][wd_idx], \n", + " alpha = 0.4, marker = '.', s = 25, \n", + " color = 'aqua')\n", + " axes.scatter(t['t_E'][ns_idx], t['pi_E'][ns_idx], \n", + " alpha = 0.4, marker = '.', s = 25, \n", + " color = 'tab:cyan')\n", + " axes.scatter(t['t_E'][bh_idx], t['pi_E'][bh_idx],\n", + " alpha = 0.8, marker = '.', s = 25, \n", + " color = 'black')\n", + "\n", + " # Trickery to make the legend darker\n", + " axes.scatter(0.01, 100, \n", + " alpha = 0.8, marker = '.', s = 25, \n", + " label = 'Star', color = 'paleturquoise')\n", + " axes.scatter(0.01, 100, \n", + " alpha = 0.8, marker = '.', s = 25,\n", + " label = 'WD', color = 'aqua')\n", + " axes.scatter(0.01, 100,\n", + " alpha = 0.8, marker = '.', s = 25, \n", + " label = 'NS', color = 'tab:cyan')\n", + " axes.scatter(0.01, 100,\n", + " alpha = 0.8, marker = '.', s = 25, \n", + " label = 'BH', color = 'black')\n", + "\n", + " x_arr, y_arr = 500,1e-2\n", + " plt.annotate('', xytext=(x_arr,y_arr), xy=(x_arr-200,y_arr), arrowprops=dict(shrink=0.,color='k',width=2,headwidth=8))\n", + " plt.text(x_arr-200,y_arr,r'$\\Delta \\mu_{\\rm rel}$', color='k', va='top', ha='center')\n", + " plt.annotate('', xytext=(x_arr,y_arr), xy=(x_arr*1.5,y_arr/1.5), arrowprops=dict(shrink=0.,color='k',width=2,headwidth=8))\n", + " plt.text(x_arr*1.5,y_arr/1.5,r'$\\Delta M$', color='k', va='top', ha='center')\n", + " plt.annotate('', xytext=(x_arr,y_arr), xy=(x_arr*1.5,y_arr*1.5), arrowprops=dict(shrink=0.,color='k',width=2,headwidth=8))\n", + " plt.text(x_arr*1.5,y_arr*1.5,r'$\\Delta \\pi_{\\rm rel}$', color='k', va='bottom', ha='center')\n", + "\n", + " axes.set_xlim(10, 1100)\n", + " axes.set_ylim(0.005, 0.5)\n", + " axes.set_xlabel('$t_E$ (days)', fontsize=piE_tE_textsize)\n", + " axes.set_ylabel('$\\pi_E$', fontsize=piE_tE_textsize)\n", + " axes.set_xscale('log')\n", + " axes.set_yscale('log')\n", + " axes.legend(loc=3)\n", + " plt.savefig('piE_tE_26B.png', bbox_inches='tight')\n", + " #plt.close()\n", + "\n", + " # Plot the deltac-piE 2D posteriors.\n", + "# plt.close(2)\n", + " fig = plt.figure(2, figsize=(6,6))\n", + " plt.clf()\n", + " axes = plt.gca()\n", + " plt.subplots_adjust(bottom=0.15)\n", + "\n", + " axes.errorbar(dcmax_110022, piE_110022, \n", + " xerr = np.array([[dcmax_110022_me], [dcmax_110022_pe]]), \n", + " fmt = 'o', color = 'gray', markersize = 5,\n", + " xuplims = True)\n", + "# axes.text(0.5, 0.3, 'OB110022', color='gray')\n", + "\n", + " # MB09260, MB10364, OB11030\n", + " axes.errorbar(0.6, 0.26, xerr = np.array([[0.3], [0.3]]), \n", + " fmt = 'o', color = 'gray', markersize = 5,\n", + " xuplims = True)\n", + "\n", + " axes.errorbar(0.92, 0.1, xerr = np.array([[0.3], [0.3]]), \n", + " fmt = 'o', color = 'gray', markersize = 5,\n", + " xuplims = True)\n", + "\n", + " axes.errorbar(0.89, 0.085, xerr = np.array([[0.3], [0.3]]), \n", + " fmt = 'o', color = 'gray', markersize = 5,\n", + " xuplims = True)\n", + "\n", + " # ob120169 and ob150029\n", + " # axes.errorbar(1.06, 0.17, xerr = np.array([[0.3], [0.3]]), \n", + " # fmt = 'o', color = 'blue', markersize = 5,\n", + " # xuplims = True)\n", + "\n", + " # axes.errorbar(0.45, 0.17, xerr = np.array([[0.3], [0.3]]), \n", + " # fmt = 'o', color = 'blue', markersize = 5,\n", + " # xuplims = True)\n", + "\n", + " for targ in ['OB110037']+targets:\n", + " model_fitter.contour2d_alpha(theta_E[targ]/np.sqrt(8), piE[targ], span=[span, span], quantiles_2d=quantiles_2d,\n", + " weights=weights[targ], ax=axes, smooth=[sy, sx], color=colors[targ],\n", + " **hist2d_kwargs, plot_density=False, sigma_levels=[1, 2])\n", + " if targ[:4]=='ob14' or targ=='ob150029':\n", + " #plt.plot(np.average(theta_E[targ]/np.sqrt(8), weights=weights[targ]), np.average(piE[targ], weights=weights[targ]), 'o', color=colors[targ])\n", + " pass\n", + "\n", + " hist2d_kwargs['alpha'] = hist2d_kwargs.get('alpha', 0.8)\n", + " \n", + "\n", + " model_fitter.contour2d_alpha(theta_E['OB110462']/np.sqrt(8), piE['OB110462'], span=[span, span], quantiles_2d=quantiles_2d,\n", + " weights=weights['OB110462'], ax=axes, smooth=[sy, sx], color=colors['OB110462'],\n", + " contour_kwargs={'alpha' : 0.9}, plot_density=False, sigma_levels=[1, 2])\n", + " hist2d_kwargs['alpha'] = hist2d_kwargs.get('alpha', 0.2)\n", + " \n", + "\n", + " xarr = np.linspace(0.001, 4, 1000)\n", + " axes.fill_between(xarr, xarr*0.18, xarr*0.07, alpha=0.15, color='orange')\n", + " axes.text(0.05, 0.006, 'Mass Gap', rotation=45)\n", + "\n", + " axes.scatter(final_delta_arr[st_idx], t['pi_E'][st_idx], \n", + " alpha = 0.4, marker = '.', s = 25,\n", + " c = 'paleturquoise')\n", + " axes.scatter(final_delta_arr[wd_idx], t['pi_E'][wd_idx], \n", + " alpha = 0.4, marker = '.', s = 25,\n", + " c = 'aqua')\n", + " axes.scatter(final_delta_arr[ns_idx], t['pi_E'][ns_idx], \n", + " alpha = 0.4, marker = '.', s = 25,\n", + " c = 'tab:cyan')\n", + " axes.scatter(final_delta_arr[bh_idx], t['pi_E'][bh_idx], \n", + " alpha = 0.8, marker = '.', s = 25,\n", + " c = 'black')\n", + "\n", + " x_arr, y_arr = 1.4,1e-2\n", + " plt.annotate('', xytext=(x_arr,y_arr), xy=(x_arr*1.5,y_arr/1.5), arrowprops=dict(shrink=0.,color='k',width=2,headwidth=8))\n", + " plt.text(x_arr*1.5,y_arr/1.5,r'$\\Delta M$', color='k', va='top', ha='center')\n", + " plt.annotate('', xytext=(x_arr,y_arr), xy=(x_arr*1.5,y_arr*1.5), arrowprops=dict(shrink=0.,color='k',width=2,headwidth=8))\n", + " plt.text(x_arr*1.5,y_arr*1.5,r'$\\Delta \\pi_{\\rm rel}$', color='k', va='bottom', ha='center')\n", + "\n", + " axes.set_xlabel('$\\delta_{c,max}$ (mas)', fontsize=piE_tE_textsize)\n", + " axes.set_ylabel('$\\pi_E$', fontsize=piE_tE_textsize)\n", + " axes.set_xscale('log')\n", + " axes.set_yscale('log')\n", + " axes.set_xlim(0.02, 3)\n", + " axes.set_ylim(0.005, 0.5)\n", + " plt.savefig('piE_deltac_26B.png', bbox_inches='tight')\n", + " plt.show()\n", + "piE_tE()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f6cfbc9c-ada7-4196-8db2-32768454fb49", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}