def makeInjObjs(injfile,event,posfiles):
"""
Make a list of results objects from the posfiles and injections
"""
getByTime=False
resObjs=[]
if injfile:
import itertools
injections = SimInspiralUtils.ReadSimInspiralFromFiles([injfile])
i=0
for posfile in posfiles:
peparser=bppu.PEOutputParser('common')
resObj=peparser.parse(open(posfile,'r'))
pos=bppu.Posterior(resObj)
if event is not None:
injection=injections[event]
else:
time=pos['time'].mean
injection=getInjByTime(time,injections)
if injection is None:
continue
pos.set_injection(injection)
resObjs.append(pos)
i=i+1
return resObjs
def makeInjObjs(injfile, posfiles):
"""
Make a list of results objects from the posfiles and injections
"""
getByTime = False
resObjs = []
if injfile:
import itertools
injections = SimInspiralUtils.ReadSimInspiralFromFiles([injfile])
if (len(injections) != len(posfiles)):
print 'Different numbers of injections and posterior files, attempting to recognise by time'
getByTime = True
i = 0
for posfile in posfiles:
peparser = bppu.PEOutputParser('common')
resObj = peparser.parse(open(posfile, 'r'))
pos = bppu.Posterior(resObj)
if not getByTime:
injection = injections[i]
else:
time = pos['time'].mean
injection = getInjByTime(time, injections)
if injection is None:
continue
pos.set_injection(injection)
resObjs.append(pos)
i = i + 1
return resObjs
def read_posterior_samples(f, injrow):
"""Returns a bppu posterior sample object
"""
peparser = bppu.PEOutputParser('common')
commonResultsObj = peparser.parse(open(f, 'r'))
data = bppu.Posterior(commonResultsObj,
SimInspiralTableEntry=injrow,
injFref=100.0)
# add tilts, comp masses, tidal...
data.extend_posterior()
return data
def gelman_rubin(pos_samples, param_arr, outdir):
"""
Compute Gelman-Rubin R-statistic for each parameter in param_arr.
"""
writefile = os.path.join(outdir, 'merged_files.dat')
runs = len(pos_samples)
R_arr = []
merge_files(pos_samples, param_arr, writefile)
for param in param_arr:
data = bppu.PEOutputParser('common')
inputFileObj = open(writefile)
dataObj0 = data.parse(inputFileObj)
posterior = bppu.Posterior(dataObj0)
R = posterior.gelman_rubin(param)
R_arr.append(R)
return R_arr
def get_modes(posfiles, plot=False):
"""
Return a tuple with the means and covariances of Gaussian mixture models fit
to the posterior modes
"""
fmeans = np.empty(shape=(len(posfiles), 3))
fmeans.fill(None)
fcovars = np.empty(shape=(len(posfiles), 3))
fcovars.fill(None)
# Create PE parser object and construct posterior
peparser = bppu.PEOutputParser('common')
gmms = []
for p, posfile in enumerate(posfiles):
resultsObj = peparser.parse(open(posfile, 'r'), info=[None, None])
posterior = bppu.Posterior(resultsObj)
# Get GMM for frequency posterior
gmmresult = gmm_peaks(posterior['frequency'].samples)
means = np.concatenate(gmmresult.means_)
covars = np.concatenate(gmmresult.covars_)
# Populate the fpeaks array such that the highest frequency is the first
# column
idx = np.argsort(means)[::-1]
for i in xrange(len(idx)):
fmeans[p, i] = means[idx][i]
fcovars[p, i] = means[idx][i]
if plot:
outdir = os.path.dirname(posfile)
f, ax = plot_oneDposterior(posterior,
'frequency',
histbinswidth=2.5)
freqs = np.arange(1500, 4000, 0.1)
ax.plot(freqs,
np.exp(gmmresult.score_samples(freqs)[0]),
color='r',
label='GMM')
ax.legend()
f.savefig(os.path.join(outdir, 'frequency_posterior_with_GMM.png'))
return fmeans, fcovars
def make_posteriors(self):
peparser = bppu.PEOutputParser('common')
resultsObj = peparser.parse(open(self.samples_file, 'r'))
self.posterior = bppu.Posterior(resultsObj)
# Create bppu posterior instance for easy conf intervals and
# characterisation
self.intervals = {}
for p, param in enumerate(self.params):
# --- Statistics from this posterior
toppoints, injection_cl, reses, injection_area, cl_intervals = \
bppu.greedy_bin_one_param(self.posterior,
{param:self.binSizes[param]}, self.levels)
self.intervals[param]=cl_intervals
def single_injection_results(outdir, posterior_file, bsn_file, snr_file,
waveform):
"""
Characterise the results, including producing plots, for a single injection
"""
# Mostly taken from cbcBayesBurstPostProc.py
headerfile = snr_file.replace('_snr', '_params')
# Output dir for this injection (top-level directory + event number and gps time
# taken from posterior samples filename)
currentdir = os.path.join(
outdir,
posterior_file.split('/')[-1].split('_')[-1].replace('.dat', ''))
if not os.path.isdir(currentdir):
os.makedirs(currentdir)
# Create PE parser object
peparser = bppu.PEOutputParser('common')
resultsObj = peparser.parse(open(posterior_file, 'r'),
info=[headerfile, None])
# Read Bayes and SNR files and copy them into this directory in case it's
# useful later
bfile = open(bsn_file, 'r')
BSN = bfile.read()
bfile.close()
BSN = float(BSN.split()[0])
snrstring = ""
snrf = open(snr_file, 'r')
snrs = snrf.readlines()
snrf.close()
for snr in snrs:
if snr == "\n":
continue
snrstring = snrstring + " " + str(snr[0:-1]) + " ,"
snrstring = snrstring[0:-1]
# Just return the final (usually network) snr
SNR = float(snrstring.split()[-1])
# Archive files to this directory
shutil.copyfile(posterior_file,
os.path.join(currentdir,
posterior_file.split('/')[-1]))
shutil.copyfile(bsn_file, os.path.join(currentdir,
bsn_file.split('/')[-1]))
shutil.copyfile(snr_file, os.path.join(currentdir,
snr_file.split('/')[-1]))
# Create Posterior Sample object (shouldn't matter whether we go with Posterior or BurstPosterior)
pos = bppu.Posterior(resultsObj)
# Add in derived parameters
pos = add_derived_params(pos)
oneDMenu, twoDMenu, binSizes = oneD_bin_params()
# Get true values:
truevals = {}
for item in oneDMenu:
if item == 'frequency':
truevals[item] = waveform.fpeak
else:
truevals[item] = None
# Make sure we have quality AND bandwidth samples
# TODO:
# 3) Loop over injections
# 4) webpage for injection population
# 5) plot injected / recovered waveforms
# ----------------------------------------------------------
# --- Corner plot
#corner_fig = plot_corner(pos, [0.05, 0.5, 0.95], parvals=truevals)
#corner_fig.savefig(os.path.join(currentdir,'corner.png'))
# --- 1D Posterior results (see cbcBayesBurstPostProc.py:733)
# Dictionaries to contain confidence intervals and standard accuracies
cl_intervals_allparams = {}
staccs_allparams = {}
accs_allparams = {}
for par_name in oneDMenu:
print >> sys.stdout, "Producing 1D posteriors for %s" % par_name
# Get bin params
try:
pos[par_name.lower()]
except KeyError:
print "No posterior samples for %s, skipping binning." % par_name
continue
try:
par_bin = binSizes[par_name]
except KeyError:
print "Bin size is not set for %s, skipping binning." % par_name
continue
binParams = {par_name: par_bin}
# --- Statistics from this posterior
toppoints, injection_cl, reses, injection_area, cl_intervals = \
bppu.greedy_bin_one_param(pos, binParams, [0.67, 0.9, 0.95])
# add conf intervals dictionary
cl_intervals_allparams[par_name] = cl_intervals[1]
# add standard accuracy to dictionary
staccs_allparams[par_name] = stacc(pos, par_name, truevals[par_name])
accs_allparams[par_name] = acc(pos, par_name, truevals[par_name])
# --- Plotting
#fig, ax = plot_oneDposterior(pos, par_name, cl_intervals[1],
# truevals, plotkde=False)
#
#figname=par_name+'.png'
#oneDplotPath=os.path.join(currentdir,figname)
#fig.savefig(oneDplotPath)
#pl.close(fig)
#pl.close(corner_fig)
return currentdir, BSN, SNR, pos, cl_intervals_allparams, \
staccs_allparams, accs_allparams, pos
def pulsarBayesPostProc(
outdir,
data,
upperlimit,
histbins,
#nested sampling options
priorfile,
parfile,
ns_Nlive,
# analysis data
Bkdata=None,
ifos=None,
# pulsar information
corfile=None #,
#Turn on 2D kdes
#twodkdeplots=False,
#Turn on R convergence tests
#RconvergenceTests=False
):
# check data is input
if data is None:
raise RuntimeError('You must specify an input data file')
# check output directory is input
if outdir is None:
raise RuntimeError("You must specify an output directory.")
# create output dir if it doesn't exist
if not os.path.isdir(outdir):
os.makedirs(outdir)
# list of posteriors for each ifo
poslist = []
# loop over ifos and generate posteriors
for idx, ifo in enumerate(ifos):
# nested sampling data files for IFO idx
idat = data[idx]
# if input format is xml
votfile = None
if '.xml' in data[0]:
peparser = bppu.PEOutputParser('xml')
commonResultsObj = peparser.parse(idat[0])
thefile = open(idat[0], 'r')
votfile = thefile.read()
else: # input as standard nested sampling input
peparser = bppu.PEOutputParser('ns')
commonResultsObj = peparser.parse(idat,
Nlive=ns_Nlive,
xflag=False)
# Create an instance of the posterior class using the posterior values
# loaded from the file.
pos = bppu.Posterior( commonResultsObj, SimInspiralTableEntry=None, \
votfile=votfile )
# append to list
poslist.append(pos)
# read in par file if given
if parfile is not None:
par = pppu.psr_par(parfile)
# convert phi0' and psi' to phi0 and psi
if 'phi0prime' in pos.names and 'psiprime' in pos.names:
phi0samps, psisamps = pppu.phipsiconvert( pos['phi0prime'].samples, \
pos['psiprime'].samples )
# append phi0 and psi to posterior
phi0_pos = bppu.OneDPosterior('phi0', phi0samps)
pos.append(phi0_pos)
psi_pos = bppu.OneDPosterior('psi', phi0samps)
pos.append(psi_pos)
# get parameters to plot from prior file and those with "Errors" in the par
# file
plotpars = []
pri = pppu.psr_prior(priorfile)
for pars in pppu.float_keys:
# prior file values have preference over par file values with errors in the
# nested sampling code
pars_err = pars + '_ERR'
if pri[pars] is not None:
plotpars.append(pars)
elif par[pars_err] is not None:
plotpars.append(pars)
# if h0 exists plot the pdf
if 'H0' in plotpars:
# set bounds of h0
bounds = [0, float("inf")]
plotFig, ulvals = pppu.plot_posterior_hist(poslist, 'H0'.lower(), ifos,
bounds, histbins,
upperlimit)
# output plots for each IFO
for i, ifo in enumerate(ifos):
figname = 'H0'.lower() + '_' + ifo + '.png'
oneDplotPath = os.path.join(outdir, figname)
plotFig[i].savefig(oneDplotPath)
# if the heterodyned data files have been included create time series plots
# of |B_k| and a amplitude spectral density spectrogram of the data
if Bkdata is not None:
Bkfigs, ASDfigs = pppu.plot_Bks_ASDs(Bkdata, ifos)
# output plots
for i, ifo in enumerate(ifos):
figname = 'Bk' + '_' + ifo + '.png'
Bkplotpath = os.path.join(outdir, figname)
Bkfigs[i].savefig(Bkplotpath)
figname = 'ASD' + '_' + ifo + '.png'
ASDplotpath = os.path.join(outdir, figname)
ASDfigs[i].savefig(ASDplotpath)
def cbcBayesConvergence(
outdir,
data,
#Number of live points used in data
ns_Nlive,
#Threshold for failure for gelman-rubin test
gelmanthresh=1.01
#
):
"""
This is a script which calculates convergence statistics for nested
sampling runs.
"""
if data is None:
raise RuntimeError('You must specify an input data file')
#
if outdir is None:
raise RuntimeError("You must specify an output directory.")
if not os.path.isdir(outdir):
os.makedirs(outdir)
#
import string
from numpy import loadtxt
pos_samples = []
new_data = []
for d in reversed(data):
temp = [d]
new_data.append(temp)
peparser = bppu.PEOutputParser('ns')
posfilename = os.path.join(outdir, 'posterior_samples.dat')
for i in range(len(data)):
# Create a posterior object (Npost=None avoids repeated samples which ruin the KS test)
commonResultsObj = peparser.parse(new_data[i],
Nlive=ns_Nlive,
Npost=None)
pos = bppu.Posterior(commonResultsObj)
pos.write_to_file(posfilename)
with open(posfilename) as f:
param_arr = string.split(f.readline())
loadfile = loadtxt(f)
pos_samples.append(loadfile)
#==================================================================#
#Create webpage with nested sampling convergence information
#==================================================================#
import pylal.nsconvergence as nsc
runs = len(pos_samples)
html_nsconvergence = bppu.htmlPage('Convergence Information',
css=bppu.__default_css_string)
convergencedir = os.path.join(outdir, 'convergence')
if not os.path.isdir(convergencedir):
os.makedirs(convergencedir)
#Summary Section
html_nsconvergence_stats = html_nsconvergence.add_section('Summary')
max_l, l_diff = nsc.compare_maxl(pos_samples, param_arr)
html_nsconvergence_stats.p('Max difference in loglikelihood: %f' % l_diff)
summary_table_string = ''
summary_table_header = '<table border="1"><tr><th>Run</th><th>maxloglikelihood</th>'
#maxposterior column
if param_arr.count('prior') > 0:
max_pos, pos_diff = nsc.compare_maxposterior(pos_samples, param_arr)
html_nsconvergence_stats.p('Max difference in posterior: %f' %
pos_diff)
summary_table_header += '<th>maxposterior</th>'
summary_table_header += '</tr>'
summary_table_string += summary_table_header
for i in range(runs):
max_l_val = max_l[i]
summary_table_string += '<tr><td>%i</td><td>%f</td>' % (i, max_l_val)
if param_arr.count('prior') > 0:
max_pos_val = max_pos[i]
summary_table_string += '<td>%f</td>' % max_pos_val
summary_table_string += '</tr>'
summary_table_string += '</table>'
html_nsconvergence_stats.write(summary_table_string)
#KS Test Section
html_nsconvergence_ks = html_nsconvergence.add_section('KS Test')
ks_arr = nsc.kstest(pos_samples, param_arr, convergencedir)
for index, p in enumerate(param_arr):
ks_table_string = '<table><caption>%s</caption><tr><th></th>' % p
for i in range(runs):
ks_table_string += '<th>Run%i</th>' % i
ks_table_string += '</tr>'
for i in range(runs):
ks_table_string += '<tr><th>Run%i</th>' % i
for j in range(i * runs, (i * runs) + runs):
pval = ks_arr[index][j]
ks_table_string += '<td>%f</td>' % pval
ks_table_string += '</tr>'
ks_table_string += '</table>'
html_nsconvergence_ks.write(ks_table_string)
for p in param_arr:
html_nsconvergence_ks.write(
'<a href="./convergence/ks/' + p +
'_ks.png" target="_blank"><img width="35%" src="./convergence/ks/'
+ p + '_ks.png"/></a>')
#Gelman Rubin Section
html_nsconvergence_gelman = html_nsconvergence.add_section('Gelman Rubin')
gelmandir = os.path.join(convergencedir, 'gelmanrubin')
if not os.path.isdir(gelmandir):
os.makedirs(gelmandir)
gelmanrubin = nsc.gelman_rubin(pos_samples, param_arr, gelmandir)
warn = False
warnparams = []
for index, g in enumerate(gelmanrubin):
if g > gelmanthresh:
warn = True
warnparams.append(index)
if warn:
with open(outdir + '/warning.txt', 'w') as warnfile:
warnfile.write('Gelman-Rubin threshold set to %f\n' % gelmanthresh)
for i in warnparams:
warnfile.write('%s has an R-value of %f\n' %
(param_arr[i], gelmanrubin[i]))
colors = ['b', 'r', 'g', 'c', 'k', 'm', 'y', .25, .5, .75]
for param_index, param in enumerate(param_arr):
for i in range(runs):
data_range = []
for j in range(len(pos_samples[i])):
data_range.append(j)
col = nsc.get_data_col(pos_samples[i], param_arr, param)
plt.figure(param_index)
plt.scatter(data_range, col, c=colors[i], s=5, edgecolors='none')
plt.title('R = ' + str(gelmanrubin[param_index]))
plt.xlabel('Sample')
plt.ylabel(param)
plt.xlim(0, len(pos_samples[i]))
plt.ylim(min(col), max(col))
plt.savefig(gelmandir + '/' + param)
for p in param_arr:
html_nsconvergence_gelman.write(
'<a href="./convergence/gelmanrubin/' + p +
'.png" target="_blank"><img width="35%" src="./convergence/gelmanrubin/'
+ p + '.png"/></a>')
#Write convergence page
nsconvergencepage = open(os.path.join(outdir, 'convergence.html'), 'w')
nsconvergencepage.write(str(html_nsconvergence))
nsconvergencepage.close()
def load_data(filename, header=None):
peparser = bppu.PEOutputParser('common')
commonObj = peparser.parse(open(filename, 'r'), info=[header, None])
pos = bppu.Posterior(commonObj)
return pos
sys.exit(1)
if len(opts.weight) != len(opts.posterior):
sys.stderr.write(
'Error: must specify same number of weights and posteriors\n')
sys.exit(1)
# Create posterior samples for each input file
datas = map(load_data, opts.posterior)
weights = []
for d, w in zip(datas, opts.weight):
theseweights = (
log(w) + logl + logp
for logl, logp in zip(d['logl'].samples, d['logprior'].samples))
weights.extend(theseweights)
bigdata = vstack([d.samples()[0] for d in datas])
# Call reweighting function
if opts.npos is not None:
merged = draw_N_posterior(bigdata,
weights,
opts.npos,
verbose=opts.verbose)
else:
merged = draw_posterior(bigdata, weights, verbose=opts.verbose)
outObj = bppu.Posterior((datas[0].names, merged))
# Write output file
if opts.output is not None:
outObj.write_to_file(opts.output)
def compare_bayes(outdir,names_and_pos_folders,injection_path,eventnum,username,password,reload_flag,clf,ldg_flag,contour_figsize=(4.5,4.5),contour_dpi=250,contour_figposition=[0.15,0.15,0.5,0.75],fail_on_file_err=True,covarianceMatrices=None,meanVectors=None,Npixels2D=50):
injection=None
if injection_path is not None and os.path.exists(injection_path) and eventnum is not None:
eventnum=int(eventnum)
import itertools
injections = SimInspiralUtils.ReadSimInspiralFromFiles([injection_path])
if eventnum is not None:
if(len(injections)<eventnum):
print "Error: You asked for event %d, but %s contains only %d injections" %(eventnum,injection_path,len(injections))
sys.exit(1)
else:
injection=injections[eventnum]
#Create analytic likelihood functions if covariance matrices and mean vectors were given
analyticLikelihood = None
if covarianceMatrices and meanVectors:
analyticLikelihood = bppu.AnalyticLikelihood(covarianceMatrices, meanVectors)
peparser=bppu.PEOutputParser('common')
pos_list={}
tp_list={}
common_params=None
working_folder=os.getcwd()
for name,pos_folder in names_and_pos_folders:
import urlparse
pos_folder_url=urlparse.urlparse(pos_folder)
pfu_scheme,pfu_netloc,pfu_path,pfu_params,pfu_query,pfu_fragment=pos_folder_url
if 'http' in pfu_scheme:
"""
Retrieve a file over http(s).
"""
downloads_folder=os.path.join(os.getcwd(),"downloads")
pos_folder_parse=urlparse.urlparse(pos_folder)
pfp_scheme,pfp_netloc,pfp_path,pfp_params,pfp_query,pfp_fragment=pos_folder_parse
head,tail=os.path.split(pfp_path)
if tail is 'posplots.html' or tail:
pos_file_part=head
else:
pos_file_part=pfp_path
pos_file_url=urlparse.urlunsplit((pfp_scheme,pfp_netloc,os.path.join(pos_file_part,'posterior_samples.dat'),'',''))
print pos_file_url
pos_file=os.path.join(os.getcwd(),downloads_folder,"%s.dat"%name)
if not os.path.exists(pos_file):
reload_flag=True
if reload_flag:
if os.path.exists(pos_file):
os.remove(pos_file)
if not os.path.exists(downloads_folder):
os.makedirs(downloads_folder)
open_url_wget(pos_file_url,un=username,pw=password,args=["-O","%s"%pos_file])
elif pfu_scheme is '' or pfu_scheme is 'file':
pos_file=os.path.join(pos_folder,'%s.dat'%name)
# Try looking for posterior_samples.dat if name.dat doesn't exist
if not os.path.exists(pos_file):
print '%s does not exist, trying posterior_samples.dat'%(pos_file)
pos_file=os.path.join(pos_folder,'posterior_samples.dat')
else:
print "Unknown scheme for input data url: %s\nFull URL: %s"%(pfu_scheme,str(pos_folder_url))
exit(0)
print "Reading posterior samples from %s ..."%pos_file
try:
common_output_table_header,common_output_table_raw=peparser.parse(open(pos_file,'r'))
except:
print 'Unable to read file '+pos_file
continue
test_and_switch_param(common_output_table_header,'distance','dist')
test_and_switch_param(common_output_table_header,'chirpmass','mchirp')
test_and_switch_param(common_output_table_header,'mc','mchirp')
test_and_switch_param(common_output_table_header,'asym_massratio','q')
test_and_switch_param(common_output_table_header,'massratio', 'eta')
test_and_switch_param(common_output_table_header,'RA','ra')
test_and_switch_param(common_output_table_header,'rightascension','ra')
test_and_switch_param(common_output_table_header,'declination','dec')
test_and_switch_param(common_output_table_header,'tilt_spin1','tilt1')
test_and_switch_param(common_output_table_header,'tilt_spin2','tilt2')
if 'LI_MCMC' in name or 'FU_MCMC' in name:
try:
idx=common_output_table_header.index('iota')
print "Inverting iota!"
common_output_table_raw[:,idx]= np.pi*np.ones(len(common_output_table_raw[:,0])) - common_output_table_raw[:,idx]
except:
pass
# try:
# print "Converting phi_orb-> 2phi_orb"
# idx=common_output_table_header.index('phi_orb')
# common_output_table_header[idx]='2phi_orb'
# common_output_table_raw[:,idx]= 2*common_output_table_raw[:,idx]
# except:
# pass
try:
print "Converting iota-> cos(iota)"
idx=common_output_table_header.index('iota')
common_output_table_header[idx]='cos(iota)'
common_output_table_raw[:,idx]=np.cos(common_output_table_raw[:,idx])
except:
pass
#try:
# print "Converting tilt1 -> cos(tilt1)"
# idx=common_output_table_header.index('tilt1')
# common_output_table_header[idx]='cos(tilt1)'
# common_output_table_raw[:,idx]=np.cos(common_output_table_raw[:,idx])
#except:
# pass
#try:
# print "Converting tilt2 -> cos(tilt2)"
# idx=common_output_table_header.index('tilt2')
# common_output_table_header[idx]='cos(tilt2)'
# common_output_table_raw[:,idx]=np.cos(common_output_table_raw[:,idx])
#except:
# pass
try:
print "Converting thetas -> cos(thetas)"
idx=common_output_table_header.index('thetas')
common_output_table_header[idx]='cos(thetas)'
common_output_table_raw[:,idx]=np.cos(common_output_table_raw[:,idx])
except:
pass
try:
print "Converting beta -> cos(beta)"
idx=common_output_table_header.index('beta')
common_output_table_header[idx]='cos(beta)'
common_output_table_raw[:,idx]=np.cos(common_output_table_raw[:,idx])
except:
pass
try:
idx=common_output_table_header.index('f_ref')
injFrefs=np.unique(common_output_table_raw[:,idx])
if len(injFrefs) == 1:
injFref = injFrefs[0]
print "Using f_ref in results as injected value"
except:
injFref = None
pass
pos_temp=bppu.Posterior((common_output_table_header,common_output_table_raw),SimInspiralTableEntry=injection, injFref=injFref)
if 'a1' in pos_temp.names and min(pos_temp['a1'].samples)[0] < 0:
pos_temp.append_mapping('spin1', lambda a:a, 'a1')
pos_temp.pop('a1')
pos_temp.append_mapping('a1', lambda a:np.abs(a), 'spin1')
if 'a2' in pos_temp.names and min(pos_temp['a2'].samples)[0] < 0:
pos_temp.append_mapping('spin2', lambda a:a, 'a2')
pos_temp.pop('a2')
pos_temp.append_mapping('a2', lambda a:np.abs(a), 'spin2')
if 'm1' in pos_temp.names and 'm2' in pos_temp.names:
print "Calculating total mass"
pos_temp.append_mapping('mtotal', lambda m1,m2: m1+m2, ['m1','m2'])
if 'mass1' in pos_temp.names and 'mass2' in pos_temp.names:
print "Calculating total mass"
pos_temp.append_mapping('mtotal', lambda m1,m2: m1+m2, ['mass1','mass2'])
try:
idx=common_output_table_header.index('m1')
idx2=common_output_table_header.index('m2')
if pos_temp['m1'].mean<pos_temp['m2'].mean:
print "SWAPPING MASS PARAMS!"
common_output_table_header[idx]='x'
common_output_table_header[idx2]='m1'
common_output_table_header[idx]='m2'
pos_temp=bppu.Posterior((common_output_table_header,common_output_table_raw),SimInspiralTableEntry=injection)
except:
pass
pos_list[name]=pos_temp
if common_params is None:
common_params=pos_temp.names
else:
set_of_pars = set(pos_temp.names)
common_params=list(set_of_pars.intersection(common_params))
print "Common parameters are %s"%str(common_params)
if injection is None and injection_path is not None:
import itertools
injections = SimInspiralUtils.ReadSimInspiralFromFiles([injection_path])
injection=bppu.get_inj_by_time(injections,pos_temp.means['time'])
if injection is not None:
for pos in pos_list.values():
pos.set_injection(injection)
set_of_pars = set(allowed_params)
common_params=list(set_of_pars.intersection(common_params))
print "Using parameters %s"%str(common_params)
if not os.path.exists(os.path.join(os.getcwd(),'results')):
os.makedirs('results')
if not os.path.exists(outdir):
os.makedirs(outdir)
pdfdir=os.path.join(outdir,'pdfs')
if not os.path.exists(pdfdir):
os.makedirs(pdfdir)
greedy2savepaths=[]
if common_params is not [] and common_params is not None: #If there are common parameters....
colorlst=bppu.__default_color_lst
if len(common_params)>1: #If there is more than one parameter...
temp=copy.copy(common_params)
#Plot two param contour plots
#Assign some colours to each different analysis result
color_by_name={}
hatches_by_name={}
my_cm=mpl_cm.Dark2
cmap_size=my_cm.N
color_idx=0
color_idx_max=len(names_and_pos_folders)
cmap_array=my_cm(np.array(range(cmap_size)))
#cmap_array=['r','g','b','c','m','k','0.5','#ffff00']
hatches=['/','\\','|','-','+','x','o','O','.','*']
ldg='auto'
if not ldg_flag:
ldg=None
for name,infolder in names_and_pos_folders:
#color_by_name=cmap_array[color_idx]
color_by_name[name]=cmap_array[int(floor(color_idx*cmap_size/color_idx_max)),:]
color_idx+=1
hatches_by_name[name]=hatches[color_idx]
for i,j in all_pairs(temp):#Iterate over all unique pairs in the set of common parameters
pplst=[i,j]
rpplst=pplst[:]
rpplst.reverse()
pplst_cond=(pplst in twoDplots)
rpplst_cond=(rpplst in twoDplots)
if pplst_cond or rpplst_cond:#If this pair of parameters is in the plotting list...
try:
print '2d plots: building ',i,j
greedy2Params={i:greedyBinSizes[i],j:greedyBinSizes[j]}
except KeyError:
continue
name_list=[]
cs_list=[]
slinestyles=['solid', 'dashed', 'dashdot', 'dotted']
fig=bppu.plot_two_param_kde_greedy_levels(pos_list,greedy2Params,TwoDconfidenceLevels,color_by_name,figsize=contour_figsize,dpi=contour_dpi,figposition=contour_figposition,legend=ldg,line_styles=slinestyles,hatches_by_name=hatches_by_name,Npixels=Npixels2D)
if fig is None: continue
#fig=bppu.plot_two_param_greedy_bins_contour(pos_list,greedy2Params,TwoDconfidenceLevels,color_by_name,figsize=contour_figsize,dpi=contour_dpi,figposition=contour_figposition)
greedy2savepaths.append('%s-%s.png'%(pplst[0],pplst[1]))
fig.savefig(os.path.join(outdir,'%s-%s.png'%(pplst[0],pplst[1])),bbox_inches='tight')
fig.savefig(os.path.join(pdfdir,'%s-%s.pdf'%(pplst[0],pplst[1])),bbox_inches='tight')
plt.clf()
oned_data={}
#confidence_levels={}
confidence_levels=[{},{},{},{}]
confidence_uncertainty={}
for param in common_params:
print "Plotting comparison for '%s'"%param
cl_table_header='<table><th>Run</th>'
cl_table={}
save_paths=[]
cl_table_min_max_str='<tr><td> Min | Max </td>'
level_index=0
for confidence_level in OneDconfidenceLevels:
if analyticLikelihood:
pdf=analyticLikelihood.pdf(param)
cdf=analyticLikelihood.cdf(param)
else:
pdf=None
cdf=None
cl_table_header+='<th colspan="2">%i%% (Lower|Upper)</th>'%(int(100*confidence_level))
hist_fig,cl_intervals=compare_plots_one_param_line_hist(pos_list,param,confidence_level,color_by_name,cl_lines_flag=clf,legend=ldg,analyticPDF=pdf)
hist_fig2,cl_intervals=compare_plots_one_param_line_hist_cum(pos_list,param,confidence_level,color_by_name,cl_lines_flag=clf,analyticCDF=cdf,legend=ldg)
# Save confidence levels and uncertainty
#confidence_levels[param]=[]
confidence_levels[level_index][param]=[]
for name,pos in pos_list.items():
median=pos[param].median
low,high=cl_intervals[name]
#confidence_levels[param].append((name,low,median,high))
confidence_levels[level_index][param].append((name,low,median,high))
level_index=level_index+1
cl_bounds=[]
poses=[]
for name,pos in pos_list.items():
cl_bounds.append(cl_intervals[name])
poses.append(pos[param])
confidence_uncertainty[param]=bppu.confidence_interval_uncertainty(confidence_level, cl_bounds, poses)
save_path=''
if hist_fig is not None:
save_path=os.path.join(outdir,'%s_%i.png'%(param,int(100*confidence_level)))
save_path_pdf=os.path.join(pdfdir,'%s_%i.pdf'%(param,int(100*confidence_level)))
try:
plt.tight_layout(hist_fig)
plt.tight_layout(hist_fig2)
except:
pass
hist_fig.savefig(save_path,bbox_inches='tight')
hist_fig.savefig(save_path_pdf,bbox_inches='tight')
save_paths.append(save_path)
save_path=os.path.join(outdir,'%s_%i_cum.png'%(param,int(100*confidence_level)))
save_path_pdf=os.path.join(pdfdir,'%s_%i_cum.pdf'%(param,int(100*confidence_level)))
hist_fig2.savefig(save_path,bbox_inches='tight')
hist_fig2.savefig(save_path_pdf,bbox_inches='tight')
save_paths.append(save_path)
min_low,max_high=cl_intervals.values()[0]
for name,interval in cl_intervals.items():
low,high=interval
if low<min_low:
min_low=low
if high>max_high:
max_high=high
try:
cl_table[name]+='<td>%s</td><td>%s</td>'%(low,high)
except:
cl_table[name]='<td>%s</td><td>%s</td>'%(low,high)
cl_table_min_max_str+='<td>%s</td><td>%s</td>'%(min_low,max_high)
cl_table_str=cl_table_header
for name,row_contents in cl_table.items():
cl_table_str+='<tr><td>%s<font color="%s"></font></td>'%(name,str(mpl_colors.rgb2hex(color_by_name[name][0:3])))#,'·'.encode('utf-8'))
cl_table_str+=row_contents+'</tr>'
cl_table_str+=cl_table_min_max_str+'</tr>'
cl_table_str+='</table>'
cl_uncer_str='<table> <th>Confidence Relative Uncertainty</th> <th>Confidence Fractional Uncertainty</th> <th>Confidence Percentile Uncertainty</th>\n'
cl_uncer_str+='<tr> <td> %g </td> <td> %g </td> <td> %g </td> </tr> </table>'%(confidence_uncertainty[param][0], confidence_uncertainty[param][1], confidence_uncertainty[param][2])
ks_matrix=compute_ks_pvalue_matrix(pos_list, param)
N=ks_matrix.shape[0]+1
# Make up KS-test table
ks_table_str='<table><th colspan="%d"> K-S test p-value matrix </th>'%N
# Column headers
ks_table_str+='<tr> <td> -- </td> '
for name,pos in pos_list.items():
ks_table_str+='<td> %s </td>'%name
ks_table_str+='</tr>'
# Now plot rows of matrix
for i in range(len(pos_list)):
ks_table_str+='<tr> <td> %s </td>'%(pos_list.keys()[i])
for j in range(len(pos_list)):
if i == j:
ks_table_str+='<td> -- </td>'
elif ks_matrix[i,j] < 0.05:
# Failing at suspiciously low p-value
ks_table_str+='<td> <b> %g </b> </td>'%ks_matrix[i,j]
else:
ks_table_str+='<td> %g </td>'%ks_matrix[i,j]
ks_table_str+='</tr>'
ks_table_str+='</table>'
oned_data[param]=(save_paths,cl_table_str,ks_table_str,cl_uncer_str)
# Watch out---using private variable _logL
max_logls = [[name,max(pos._logL)] for name,pos in pos_list.items()]
return greedy2savepaths,oned_data,confidence_uncertainty,confidence_levels,max_logls
__date__=git_version.date
if __name__=='__main__':
parser=OptionParser()
parser.add_option("--data",dest="data",action="store",help="file of posterior samples",metavar="FILE")
parser.add_option("--Nboxing",dest="Nboxing",action="store",default=64,type="int",metavar="N")
parser.add_option("--bootstrap", dest='bootstrap',action='store',default=1,type='int',metavar='N')
parser.add_option('--output',dest='output',action='store',default=None,metavar='FILE')
(opts,args)=parser.parse_args()
pos_parser=bp.PEOutputParser('common')
f=open(opts.data, "r")
try:
pos=bp.Posterior(pos_parser.parse(f))
finally:
f.close()
outfile=None
if opts.output:
outfile=open(opts.output,'w')
try:
for i in range(opts.bootstrap):
if i == 0:
log_ev=pos.di_evidence(boxing=opts.Nboxing)
else:
log_ev=pos.bootstrap().di_evidence(boxing=opts.Nboxing)
print 'log(evidence) with Nboxing = %d is %.1f (evidence is %g)'%(opts.Nboxing,log_ev,np.exp(ev))
if outfile:
outfile.write('%g\n'%log_ev)
inputFileObj = open(output + '/posteriors/posterior_' + str(event) +
'.dat')
else:
inputFileObj = open(input)
dataObj0 = data.parse(inputFileObj)
from pylal import SimInspiralUtils
injections = SimInspiralUtils.ReadSimInspiralFromFiles([injFile])
if (len(injections) < event):
print "Error: You asked for event %d, but %s contains only %d injections" % (
event, injfile, len(injections))
sys.exit(1)
else:
injection = injections[event]
posterior = bppu.Posterior(dataObj0, injection)
outFile = open(output + '/kdresult' + str(event), 'w')
outFile.write('label injection_cl injection_area\n')
confidenceLevels = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.68, 0.7, 0.8, 0.9]
######################################
def mapping(ra, dec):
return (ra, dec)
def isEdge(bounds):
if bounds[0][0] == 0. or bounds[1][0] == 2 * pi or bounds[0][
1] == -pi / 2. or bounds[1][1] == pi / 2:
return True
cbar.formatter.set_powerlimits((-1, 1))
cbar.update_ticks()
cbar.set_label('posterior probability')
cbar.solids.set_edgecolor("face")
plt.savefig(os.path.join(outpath,"comp_spin_pos.png"), bbox_inches='tight')
plt.clf()
USAGE='What this does is : '
if __name__=='__main__':
import sys
from optparse import OptionParser
from pylal import bayespputils as bppu
parser=OptionParser(USAGE)
parser.add_option("-o","--outpath", dest="outpath",default=None, help="make page and plots in DIR", metavar="DIR")
parser.add_option("-d","--data",dest="data",help="Posteriors samples file (must be in common format)")
(opts,args)=parser.parse_args()
if opts.outpath is None:
opts.outpath=os.getcwd()
if not os.path.isfile(opts.data):
print "Cannot find posterior file %s\n"%opts.data
sys.exit(1)
else:
peparser=bppu.PEOutputParser('common')
commonResultsObj=peparser.parse(open(opts.data,'r'),info=[None,None])
ps,samps = commonResultsObj
pos = bppu.Posterior(commonResultsObj)
make_disk_plot(pos,opts.outpath)