lalsuite 7.26.2.dev20251218__cp314-cp314t-manylinux_2_28_x86_64.whl

lalinference/nest2pos.py

@@ -0,0 +1,151 @@
+import numpy as np
+from numpy import log1p, log, logaddexp, digitize, zeros, exp, concatenate, all, cumsum, ones
+from numpy.random import uniform
+from functools import reduce
+
+def logsubexp(x,y):
+        assert all(x >= y), 'cannot take log of negative number %s - %s'%(str(x),str(y))
+
+        return x + log1p(-exp(y-x))
+
+def log_integrate_log_trap(log_func,log_support):
+    """
+    Trapezoidal integration of given log(func)
+    Returns log of the integral
+    """
+
+    log_func_sum = logaddexp(log_func[:-1], log_func[1:]) - log(2)
+    log_dxs = logsubexp(log_support[:-1], log_support[1:])
+
+    return logaddexp.reduce(log_func_sum + log_dxs)
+
+
+def compute_weights(data, Nlive):
+    """Returns log_ev, log_wts for the log-likelihood samples in data,
+    assumed to be a result of nested sampling with Nlive live points."""
+
+    start_data=concatenate(([float('-inf')], data[:-Nlive]))
+    end_data=data[-Nlive:]
+
+    log_wts=zeros(data.shape[0])
+
+    log_vols_start=cumsum(ones(len(start_data)+1)*log1p(-1./Nlive))-log1p(-1./Nlive)
+    log_vols_end=np.zeros(len(end_data))
+    log_vols_end[-1]=np.NINF
+    log_vols_end[0]=log_vols_start[-1]+np.log1p(-1.0/Nlive)
+    for i in range(len(end_data)-1):
+        log_vols_end[i+1]=log_vols_end[i]+np.log1p(-1.0/(Nlive-i))
+
+    log_likes = concatenate((start_data,end_data,[end_data[-1]]))
+
+    log_vols=concatenate((log_vols_start,log_vols_end))
+
+    log_ev = log_integrate_log_trap(log_likes, log_vols)
+
+    log_dXs = logsubexp(log_vols[:-1], log_vols[1:])
+    log_wts = log_likes[1:-1] + log_dXs[:-1]
+
+    log_wts -= log_ev
+
+    return log_ev, log_wts
+
+def draw_posterior(data, log_wts, verbose=False):
+    """Draw points from the given data (of shape (Nsamples, Ndim))
+    with associated log(weight) (of shape (Nsamples,)). Draws uniquely so
+    there are no repeated samples"""
+    maxWt=max(log_wts)
+    normalised_wts=log_wts-maxWt
+    selection=[n > log(uniform()) for n in normalised_wts]
+    idx=list(filter(lambda i: selection[i], range(len(selection))))
+    return data[idx]
+
+def draw_posterior_many(datas, Nlives, verbose=False):
+    """Draw samples from the posteriors represented by the
+    (Nruns, Nsamples, Nparams)-shaped array datas, each sampled with
+    the corresponding Nlive number of live points. Will draw without repetition,
+    and weight according to the evidence in each input run"""
+    # list of log_evidences, log_weights
+    import astropy
+    log_evs,log_wts=zip(*[compute_weights(data['logL'],Nlive) for data,Nlive in zip(datas, Nlives)])
+    if verbose: print('Computed log_evidences: %s'%(str(log_evs)))
+
+    log_total_evidence=reduce(logaddexp, log_evs)
+    log_max_evidence=max(log_evs)
+    #print 'evidences: %s'%(str(log_evs))
+    fracs=[exp(log_ev-log_max_evidence) for log_ev in log_evs]
+    if verbose: print('Relative weights of input files: %s'%(str(fracs)))
+    Ns=[fracs[i]/len(datas[i]) for i in range(len(fracs))]
+    Ntot=max(Ns)
+    fracs=[n/Ntot for n in Ns]
+    if verbose: print('Relative weights of input files taking into account their length: %s'%(str(fracs)))
+
+    posts=[draw_posterior(data,logwt) for (data,logwt,logZ) in zip(datas,log_wts,log_evs)]
+    if verbose: print('Number of input samples: %s'%(str([len(x) for x in log_wts])))
+    if verbose: print('Expected number of samples from each input file %s'%(str([int(f*len(p)) for f,p in zip(fracs,posts)])))
+    bigpos=[]
+    for post,frac in zip(posts,fracs):
+      mask = uniform(size=len(post))<frac
+      bigpos.append(post[mask])
+    result = astropy.table.vstack(bigpos)
+    if verbose: print('Total number of samples produced: %i'%(len(result)))
+    return result
+
+def draw_N_posterior(data,log_wts, N, verbose=False):
+    """
+    Draw N samples from the input data, weighted by log_wt.
+    For large N there may be repeated samples
+    """
+    if(N==0): return []
+    log_cumsums=zeros(log_wts.shape[0]+1)
+    log_cumsums[0]=-float('inf')
+    for i,log_wt in enumerate(log_wts):
+        log_cumsums[i+1]=logaddexp(log_cumsums[i], log_wt)
+
+    us=log(uniform(size=N))
+    idxs=digitize(us, log_cumsums)
+
+    return data[idxs-1]
+
+def draw_N_posterior_many(datas, Nlives, Npost, verbose=False):
+    """
+    Draw Npost samples from the posteriors represented by the
+    (Nruns, Nsamples, Nparams)-shaped array datas, each sampled with
+    the corresponding number of live points Nlive. The returned number
+    of samples may not be exactly Npost due to rounding
+    """
+    # get log_evidences, log_weights.
+    import astropy
+    log_evs,log_wts=zip(*[compute_weights(data['logL'],Nlive) for data,Nlive in zip(datas, Nlives)])
+
+    log_total_evidence=reduce(logaddexp, log_evs)
+    Ns=[int(round(Npost*exp(log_ev-log_total_evidence))) for log_ev in log_evs]
+    posts=[draw_N_posterior(data,logwt,N) for (data,logwt,N) in zip(datas,log_wts,Ns)]
+    return astropy.table.vstack(posts)
+
+def draw_posterior_many_ROQ_runs(datas, Nlives, verbose=False):
+    """Draw samples from the posteriors represented by the
+    (Nruns, Nsamples, Nparams)-shaped array datas from ROQ runs, each sampled with
+    the corresponding Nlive number of live points. First rescales evidence in each
+    mass prior bin then will draw without repetition,
+    and weight according to the evidence in each input run ala draw_posterior_many"""
+
+    # list of log_evidences, log_weights
+    import astropy
+    log_evs,log_wts=zip(*[compute_weights(data['logL'],Nlive) for data,Nlive in zip(datas, Nlives)])
+    if verbose: print('Computed log_evidences: %s'%(str(log_evs)))
+
+    log_total_evidence=reduce(logaddexp, log_evs)
+    log_max_evidence=max(log_evs)
+    #print 'evidences: %s'%(str(log_evs))
+    fracs=[exp(log_ev-log_max_evidence) for log_ev in log_evs] #TODO: add logPriorVol from ROQ run
+    if verbose: print('Relative weights of input files: %s'%(str(fracs)))
+    Ns=[fracs[i]/len(datas[i]) for i in range(len(fracs))]
+    Ntot=max(Ns)
+    fracs=[n/Ntot for n in Ns]
+    if verbose: print('Relative weights of input files taking into account their length: %s'%(str(fracs)))
+
+    bigpos=[]
+    posts=[draw_posterior(data,logwt) for (data,logwt,logZ) in zip(datas,log_wts,log_evs)]
+    if verbose: print('Number of input samples: %s'%(str([len(x) for x in log_wts])))
+    if verbose: print('Expected number of samples from each input file %s'%(str([int(f*len(p)) for f,p in zip(fracs,posts)])))
+    return astropy.table.vstack(bigpos)

lalinference/plot/__init__.py

@@ -0,0 +1,34 @@
+#
+# Copyright (C) 2012-2018  Leo Singer
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+"""
+Plotting classes and methods
+"""
+from __future__ import absolute_import
+import os
+import pkgutil
+
+__all__ = ()
+
+# Import all symbols from all submodules of this module.
+for _, module, _ in pkgutil.iter_modules([os.path.dirname(__file__)]):
+    exec('from . import {0};'
+         '__all__ += getattr({0}, "__all__", ());'
+         'from .{0} import *'.format(module))
+    del module
+
+# Clean up
+del os, pkgutil

lalinference/plot/spindisk.py

@@ -0,0 +1,104 @@
+# Ben Farr 2016
+
+from __future__ import division
+
+import numpy as np
+import os
+
+__all__=('make_disk_plot',)
+
+def make_disk_plot(post,outpath=None):
+  from matplotlib import pyplot as plt
+  from matplotlib import rc
+  rc('text', usetex=False)
+  rc('font', family='lmodern')
+
+  small, big = 10, 12
+  rc('axes', labelsize=big)
+  rc('font', size=big)
+  rc('legend', fontsize=small)
+  rc('xtick', labelsize=small)
+  rc('ytick', labelsize=small)
+
+
+  try:
+    import corner  # noqa: F401
+  except ImportError:
+    print("cannot import corner. Won't plot spin disk")
+    return None
+
+  a1='a1'
+  tilt1='tilt1'
+  a2='a2'
+  tilt2='tilt2'
+
+  names=post.names
+
+  if not set([a1,a2,tilt1,tilt2]).issubset(names):
+    print("Cannot plot spin disk plot. Not all required spin parameters exist in the posterior file. Skipping...\n")
+    return None
+
+  # Spin disk plot
+  fig, axs = plt.subplots(1, 2, sharey=True, figsize=(4, 4))
+
+  Na, Nt = 20, 30
+  xticks = [0., .25, .5, .75, 1.]
+
+  vmin, vmax = 0., 0.
+  # Work out the colour scale
+  for a, tilt in zip([a1, a2], [tilt1, tilt2]):
+      asamps=(post[a].samples).flatten()
+      tsamps=(post[tilt].samples).flatten()
+      try:
+          H, _, _ = np.histogram2d(asamps, np.cos(tsamps), range=[[0, 1], [-1, 1]], bins=(Na, Nt), density=True)
+      except TypeError:
+          # numpy < 1.15 uses normed instead of density
+          H, _, _ = np.histogram2d(asamps, np.cos(tsamps), range=[[0, 1], [-1, 1]], bins=(Na, Nt), normed=True)
+      vmax = H.max() if H.max() > vmax else vmax
+
+  # Make the plots
+  for ax, a, tilt, flip in zip(axs, [a1, a2], [tilt1, tilt2], [True, False]):
+      asamps=(post[a].samples).flatten()
+      tsamps=(post[tilt].samples).flatten()
+      plt.sca(ax)
+      try:
+          H, rs, costs = np.histogram2d(asamps, np.cos(tsamps), range=[[0, 1], [-1, 1]], bins=(Na, Nt), density=True)
+      except TypeError:
+          # numpy < 1.15 uses normed instead of density
+          H, rs, costs = np.histogram2d(asamps, np.cos(tsamps), range=[[0, 1], [-1, 1]], bins=(Na, Nt), normed=True)
+
+      COSTS, RS = np.meshgrid(costs, rs)
+      X = RS * np.sin(np.arccos(COSTS))
+      Y = RS * COSTS
+
+      HS = np.column_stack((X.flatten(), Y.flatten()))
+      XS = np.reshape(HS[:,0], (Na+1,Nt+1))
+      YS = np.reshape(HS[:,1], (Na+1,Nt+1))
+
+      plt.pcolormesh(XS, YS, H, vmin=vmin, vmax=vmax, edgecolor='face', cmap='Greys')
+
+      ax.set_ylim((-1., 1.))
+      ax.set_xlim((0., 1.))
+      if flip:
+          ax.set_xticks(xticks[1:])
+          ax.invert_xaxis()
+      else:
+          ax.set_xticks(xticks)
+          ax.yaxis.tick_right()
+          ax.yaxis.set_label_position("right")
+
+  axs[0].set_xlabel(r'$|\mathbf{S_1} \times \mathbf{\hat{L}}|$')
+  axs[1].set_xlabel(r'$|\mathbf{S_2} \times \mathbf{\hat{L}}|$')
+  axs[0].set_ylabel(r'$\mathbf{S_1}\cdot\mathbf{\hat{L}}$')
+  axs[1].set_ylabel(r'$\mathbf{S_2}\cdot\mathbf{\hat{L}}$')
+
+  fig.subplots_adjust(wspace=0.04)
+  cax = fig.add_axes([0.06, -0.075, 0.9, 0.05])
+
+  cbar = plt.colorbar(orientation='horizontal', cax=cax)
+  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()