lalsuite 7.26.2.dev20251218__cp314-cp314t-manylinux_2_28_x86_64.whl

lalsuite-7.26.2.dev20251218.data/scripts/cbcBayesPPAnalysis

@@ -0,0 +1,322 @@
+#!python
+# -*- coding: utf-8 -*-
+#
+#       cbcBayesPPAnalysis.py
+#
+#       Copyright 2013
+#       Benjamin Farr <bfarr@u.northwestern.edu>,
+#       Will M. Farr <will.farr@ligo.org>,
+#       SalvatoreVitale <salvatore.vitale@ligo.org>
+#       Vivien Raymond <vivien.raymond@ligo.org>
+#
+#       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 2 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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+
+from igwn_ligolw import lsctables
+from igwn_ligolw import utils
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as pp
+import numpy as np
+import optparse
+import os
+import os.path
+import scipy.stats as ss
+import string
+from lalinference import bayespputils as bppu
+
+posterior_name_to_latex_name = {
+    'm1' : r'$m_1$',
+    'm2' : r'$m_2$',
+    'eta' : r'$\eta$',
+    'q' : r'$q$',
+    'mc' : r'$\mathcal{M}$',
+    'distance' : r'$d$',
+    'time' : r'$t$',
+    'ra' : r'$\alpha$',
+    'dec' : r'$\delta$',
+    'phi_orb' : r'$\phi_\mathrm{orb}$',
+    'psi' : r'$\psi$',
+    'iota' : r'$\iota$',
+    'a1' : r'$a_1$',
+    'a2' : r'$a_2$',
+    'theta1' : r'$\theta_1$',
+    'theta2' : r'$\theta_2$',
+    'phi1' : r'$\phi_1$',
+    'phi2' : r'$\phi_2$',
+    'phi12':r'$\phi_{12}$',
+    'phi_jl':r'$\phi_{jl}$',
+    'theta_jn':r'$\theta_{jn}$',
+    'tilt1':r'$\tau_1$',
+    'tilt2':r'$\tau_2$',
+    'dchiMinus2':r'$d\chi_{-2}$',
+    'dchiMinus1':r'$d\chi_{-1}$',
+    'dchi0':r'$d\chi_0$',
+    'dchi1':r'$d\chi_1$',
+    'dchi2':r'$d\chi_2$',
+    'dchi3':r'$d\chi_3$',
+    'dchi3S':r'$d\chi_{3S}$',
+    'dchi3NS':r'$d\chi_{3NS}$',
+    'dchi4':r'$d\chi_4$',
+    'dchi4S':r'$d\chi_{4S}$',
+    'dchi4NS':r'$d\chi_{4NS}$',
+    'dchi5':r'$d\chi_5$',
+    'dchi5S':r'$d\chi_{5S}$',
+    'dchi5NS':r'$d\chi_{5NS}$',
+    'dchi5l':r'$d\chi_{5l}$',
+    'dchi5lS':r'$d\chi_{5lS}$',
+    'dchi5lNS':r'$d\chi_{5lNS}$',
+    'dchi6':r'$d\chi_6$',
+    'dchi6S':r'$d\chi_{6S}$',
+    'dchi6NS':r'$d\chi_{6NS}$',
+    'dchi6l':r'$d\chi_{6l}$',
+    'dchi7':r'$d\chi_7$',
+    'dchi7S':r'$d\chi_{7S}$',
+    'dchi7NS':r'$d\chi_{7NS}$',
+    'dsigma1':r'$d\sigma_1$',
+    'dsigma2':r'$d\sigma_2$',
+    'dsigma3':r'$d\sigma_3$',
+    'dsigma4':r'$d\sigma_4$',
+    'dalpha1':r'$d\alpha_1$',
+    'dalpha2':r'$d\alpha_2$',
+    'dalpha3':r'$d\alpha_3$',
+    'dalpha4':r'$d\alpha_4$',
+    'dalpha5':r'$d\alpha_5$',
+    'dbeta1':r'$d\beta_1$',
+    'dbeta2':r'$d\beta_2$',
+    'dbeta3':r'$d\beta_3$',
+    'dbeta4':r'$d\beta_4$',
+    'dchikappaS':r'$d\chi_{\kappa_{S}}$',
+    'dchikappaA':r'$d\chi_{\kappa_{A}}$'
+}
+
+def fractional_rank(x, xs):
+    """Returns the fraction of samples, ``xs``, that fall below the value
+    ``x``.
+
+    """
+    nbelow = np.sum(xs < x)
+
+    return float(nbelow)/float(xs.shape[0])
+
+def pp_plot(ps, title=None, outfile=None):
+    """Generates a p-p plot for the given ps.
+
+    :param ps: The p-values whose cumulative distribution is to be
+      plotted.
+
+    :param title: An (optional) title for the plot.
+
+    :param outfile: An (optional) basename for the plot file; both
+      basename.png and basename.pdf will be created.
+
+    """
+
+    ps = np.atleast_1d(ps)
+    ps = np.sort(ps)
+    ys = np.zeros(ps.shape[0]+2)
+    ys[:-1] = np.linspace(0, 1, ps.shape[0]+1)
+    ys[-1] = 1.0
+    xs = np.zeros(ps.shape[0]+2)
+    xs[-1] = 1.0
+    xs[1:-1] = ps
+
+    pp.figure(figsize=(6,6), dpi=100)
+
+    for i in range(10):
+        syn_ps = np.random.uniform(size=ps.shape[0])
+        syn_xs = np.zeros(ps.shape[0]+2)
+        syn_xs[-1] = 1.0
+        syn_xs[1:-1] = np.sort(syn_ps)
+        pp.plot(syn_xs, ys, '-', color='0.9')
+
+    pp.plot(xs, ys, '-k')
+    pp.plot(ys, ys, '--k')
+
+    pp.xlabel(r'$p$')
+    pp.ylabel(r'$P(p)$')
+    if title is not None:
+        pp.title(title)
+
+    if outfile is not None:
+        pp.savefig(outfile + '.png')
+        pp.savefig(outfile + '.pdf')
+
+def pp_kstest_pvalue(ps):
+    """Returns the K-S p-value for the test of the given ``ps`` against a
+    uniform distribution on [0,1].
+
+    """
+    stat, p = ss.kstest(ps, lambda x: x)
+
+    return p
+
+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...
+    try:
+      data.extend_posterior()
+    except Exception as e:
+      pass
+    return data
+
+def output_html(outdir, ks_pvalues, injnum,skypp=False):
+    """Outputs the HTML page summarizing the results.
+
+    """
+    table_row_template = string.Template("""<tr> <td> ${name} </td>
+    <td> ${pvalue} </td>
+    <td> <img src="${name}.png" alt="${name} p-p plot" width="300" height="300" /> </td> <td> <a href="${name}.png">PNG</a> <a href="${name}.pdf">PDF</a> <a href="${name}-ps.dat">p-values</a> </td> </tr>
+
+    """)
+
+    html_template = string.Template("""<!DOCTYPE html>
+    <html>
+    <head>
+    <title> LALInference P-P Plots </title>
+    </head>
+
+    <body>
+
+	<p>This page was generated with the output of ${injnum} simulations.</p>
+	${linkstr}
+	<br>
+    <table border="1">
+    <tr>
+    <th> Parameter </th> <th> K-S p-value </th> <th> p-p Plot </th> <th> Links </th>
+    </tr>
+
+    ${tablerows}
+    ${skypp}
+    </table>
+
+    </body>
+    </html>
+
+    """)
+
+    # If this script is run with lalinference_pp_pipe then the following directory structure should exist
+    links="<ul>"
+    if os.path.isdir(os.path.join(outdir,'prior')):
+        links+='<li><a href="prior/">Prior Samples used in this test</a>'
+    if os.path.isdir(os.path.join(outdir,'injections')):
+        links+='<li><a href="injections/">Posteriors for each injection</a>'
+    links+='</ul>'
+
+    tablerows = []
+    for par, pv in ks_pvalues.items():
+        tablerows.append(table_row_template.substitute(name=par, pvalue=str(pv)))
+    tablerows = '\n'.join(tablerows)
+
+    if skypp is False:
+      skysub=''
+    else:
+      skysub='<tr> <td> sky </td> <td> See Plot </td> <td> <img src="sky_p-p.png" alt="sky p-p plot" width="300" height="300" /> </td> <td> <a href="sky_p-p.png">PNG</a> <a href="sky_p-p.pdf">PDF</a></td>  </tr>'
+
+    html = html_template.substitute(tablerows=tablerows, injnum=str(injnum), linkstr=links,skypp=skysub)
+
+    with open(os.path.join(outdir, 'index.html'), 'w') as out:
+        out.write(html)
+
+if __name__ == '__main__':
+    USAGE='''%prog [options] posfile1.dat posfile2.dat ...
+            Generate PP analysis for a set of injections. posfiles must be in same order as injections.'''
+    parser = optparse.OptionParser(USAGE)
+    parser.add_option('--injXML', action='store', type='string', dest='injxml',
+                      help='sim_inspiral XML file for injections')
+    parser.add_option('--outdir', action='store', type='string',
+                      help='output directory')
+
+    parser.add_option('--postsamples', action='store', type='string',
+                      default='posterior_samples.dat',
+                      help='filename for posterior samples files')
+
+    parser.add_option('--par', action='append', default=[], type='string',
+                      help='parameter names for the p-p plot')
+    parser.add_option('--skyPPfolder', action='store',dest='skypp',type='string',default=None,help='Path to folder containing png/pdf with 2D skyarea PP plots')
+
+    (options, args) = parser.parse_args()
+
+    injs = lsctables.SimInspiralTable.get_table(utils.load_filename(options.injxml))
+
+    if options.par == []:
+        parameters = ['m1', 'm2', 'mc', 'eta', 'q',  'theta_jn', 'a1', 'a2', 'tilt1', 'tilt2', 'phi12', 'phi_jl', 'ra', 'dec', 'distance', 'time', 'phi_orb', 'psi']
+    else:
+        parameters = options.par
+
+    try:
+        os.mkdir(options.outdir)
+    except:
+        pass
+
+    pvalues = { }
+    posfiles=args
+    Ninj=0
+    for index,posfile in enumerate(posfiles):
+        try:
+            psamples = read_posterior_samples(posfile,injs[index])
+            Ninj+=1
+        except:
+            # Couldn't read the posterior samples or the XML.
+            continue
+
+        for par in parameters:
+            try:
+                samples = psamples[par].samples
+                true_value=psamples[par].injval
+                p = fractional_rank(true_value, samples)
+                try:
+                    pvalues[par].append(p)
+                except:
+                    pvalues[par] = [p]
+            except:
+                # Couldn't read samples for parameter or injection
+                continue
+
+    # Generate plots, K-S tests
+    ks_pvalues = {}
+    for par, ps in pvalues.items():
+        print("Trying to create the plot for",par,".")
+        try:
+          pp_plot(ps, title=posterior_name_to_latex_name[par], outfile=os.path.join(options.outdir, par))
+          pp.clf()
+          ks_pvalues[par] = pp_kstest_pvalue(ps)
+          np.savetxt(os.path.join(options.outdir, par + '-ps.dat'), np.reshape(ps, (-1, 1)))
+        except:
+          print("Could not create the plot for",par,"!!!")
+
+    skypp=False
+    if options.skypp is not None:
+      found=0
+      if os.path.isdir(options.skypp):
+        for i in ['png','pdf']:
+          if os.path.isfile(os.path.join(options.skypp,'p-p.%s'%i)):
+            inf=os.path.join(os.path.realpath(options.skypp),'p-p.%s'%i)
+            outf=os.path.join(options.outdir,'sky_p-p.%s'%i)
+            os.system('cp %s %s'%(inf,outf))
+            found+=1
+          else:
+            print("could not find %s\n"%os.path.join(options.skypp,'p-p.%s'%i))
+      else:
+        print("skyPPfolder %s doesn't seem to be a valid folder or cannot be read. Skipping skyPP plot\n"%os.path.realpath(options.skypp))
+
+      if found>0:
+        skypp=True
+
+    output_html(options.outdir, ks_pvalues, Ninj ,skypp=skypp )

lalsuite-7.26.2.dev20251218.data/scripts/cbcBayesPlotSpinDisk

@@ -0,0 +1,42 @@
+#!python
+# Ben Farr 2016
+
+import os
+from matplotlib import (use, rc)
+use('agg')
+
+rc('text', usetex=True)
+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)
+
+from lalinference.plot import make_disk_plot
+
+USAGE='What this does is : '
+
+if __name__=='__main__':
+  import sys
+  from optparse import OptionParser
+  from lalinference 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)

lalsuite-7.26.2.dev20251218.data/scripts/cbcBayesPosToSimBurst

@@ -0,0 +1,227 @@
+#!python
+# -*- coding: utf-8 -*-
+#       cbcBayesPosToSimBurst.py
+#       C2014 Salvatore Vitale <salvatore.vitale@ligo.org>
+#
+#       based on
+#
+#       cbcBayesPosToSimInspiral.py
+#
+#       Copyright 2013
+#       Benjamin Farr <bfarr@u.northwestern.edu>,
+#       Will M. Farr <will.farr@ligo.org>,
+#       John Veitch <john.veitch@ligo.org>
+#
+#
+#       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 2 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, write to the Free Software
+#       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+#       MA 02110-1301, USA.
+"""
+Populate a sim_inspiral table with random draws from an ASCII table.
+"""
+from optparse import Option, OptionParser
+import numpy as np
+from igwn_ligolw import ligolw
+from igwn_ligolw import lsctables
+import igwn_ligolw.utils.process
+
+# Create a datatype for all relavent fields to be filled in the sim_inspiral table
+sim_inspiral_dt = [
+        ('waveform','|S64'),
+        ('frequency', 'f8'),
+        ('q', 'f8'),
+        ('bandwidth', 'f8'),
+        ('duration', 'f8'),
+        ('hrss', 'f8'),
+        ('time_geocent_gps', 'i4'),
+        ('time_geocent_gps_ns', 'i4'),
+        ('ra','f8'),
+        ('dec', 'f8'),
+        ('pol_ellipse_angle', 'f8'),
+        ('pol_ellipse_e', 'f8'),
+        ('psi', 'f8'),
+        ('amplitude', 'f8'),
+        ('egw_over_rsquared', 'f8'),
+        ('waveform_number', 'i8'),
+]
+
+def get_input_filename(parser, args):
+    """Determine name of input: either the sole positional command line argument,
+    or /dev/stdin."""
+    if len(args) == 0:
+        infilename = '/dev/stdin'
+    elif len(args) == 1:
+        infilename = args[0]
+    else:
+        parser.error("Too many command line arguments.")
+    return infilename
+
+def standardize_param_name(params, possible_names, desired_name):
+    for name in possible_names:
+        if name in params: params[params.index(name)] = desired_name
+
+def standardize_param_names(params):
+    standardize_param_name(params, ['frequency','freq',], 'frequency')
+    standardize_param_name(params, ['q','Q','quality'], 'q')
+    standardize_param_name(params, ['duration', 'tau'], 'duration')
+    standardize_param_name(params, ['ra','longitude','rightascension'],'ra')
+    standardize_param_name(params, ['dec','latitude','declination'],'dec')
+    standardize_param_name(params, ['alpha','polar_angle','pol_ellipse_angle'], 'pol_ellipse_angle')
+    standardize_param_name(params, ['polar_eccentricity','eccentricity','pol_ellipse_e'], 'pol_ellipse_e')
+    standardize_param_name(params, ['psi', 'polarisation','polarization'],'psi')
+
+
+def compute_duration_parameterizations(samples):
+    from math import sqrt
+    params = samples.dtype.names
+    has_q = 'q' in params
+    has_dur='duration' in params
+    has_frequency = 'frequency' in params
+    if has_q:
+        q = samples['q']
+        if has_frequency:
+          duration=[i/sqrt(2)/np.pi/j for (i,j) in zip(q,samples['frequency'])]
+        else:
+          duration=np.nan
+    elif has_dur:
+        duration = samples['duration']
+        if has_frequency:
+          q=[sqrt(2)*np.pi*i*j for (i,j) in zip(duration,samples['frequency'])]
+        else:
+          q=np.nan
+    return q,duration
+
+
+if __name__ == "__main__":
+    parser = OptionParser(
+            description = __doc__,
+            usage = "%prog [options] [INPUT]",
+            option_list = [
+                Option("-o", "--output", metavar="FILE.xml",
+                    help="name of output XML file"),
+                Option("--num-of-injs", metavar="NUM", type=int, default=200,
+                    help="number of injections"),
+                Option("--approx", metavar="APPROX", default="SineGaussianF",
+                    help="approximant to be injected"),
+                Option("--taper", metavar="TAPER", default="TAPER_NONE",
+                    help="Taper methods for injections"),
+                Option("--flow", metavar="FLOW", type=float, default=None,
+                    help="Taper methods for injections"),
+            ]
+    )
+
+    opts, args = parser.parse_args()
+    infilename = get_input_filename(parser, args)
+
+    # Read in ASCII table, assuming column names are the first line
+    with open(infilename, 'r') as inp:
+        params = inp.readline().split()
+        standardize_param_names(params)
+        samples = np.loadtxt(inp, dtype=[(p, np.float) for p in params])
+
+    # Choose subset for sim_inspiral_table
+    N = opts.num_of_injs
+    selection = np.arange(N)
+    np.random.shuffle(selection)
+    samples = samples[selection]
+
+    # Create an empty structured array with names indentical to sim_inspiral fields
+    injections = np.zeros((N,), dtype=sim_inspiral_dt)
+
+    # Determine all mass parameterizations
+    q, dur = compute_duration_parameterizations(samples)
+
+    # Get cycle numbers as simulation_ids
+    ids = range(N)
+
+    # Compute polar parameters from alpha if given
+    if 'alpha' in params:
+      # LIB may use use the convention that pol_ellipse_angle=alpha).
+        injections['pol_ellipse_angle'] = samples['alpha']
+    elif 'pol_ellipse_angle' in params:
+        injections['pol_ellipse_angle'] = samples['pol_ellipse_angle']
+    else:
+        injections['pol_ellipse_angle'] = None
+
+    if 'polar_eccentricity' in params:
+        injections['pol_ellipse_e']= samples['polar_eccentricity']
+    elif 'pol_ellipse_e' in params:
+        injections['pol_ellipse_e']= samples['pol_ellipse_e']
+    else:
+        injections['pol_ellipse_e']=None
+    print(params)
+    print(samples['pol_ellipse_e'])
+    print(injections['pol_ellipse_e'])
+    if 'bandwidth' in params:
+      injections['bandwidth'] = samples['bandwidth']
+    else:
+      injections['bandwidth'] = np.nan
+    if 'time' in params:
+      injections['time_geocent_gps'] = np.modf(samples['time'])[1]
+      injections['time_geocent_gps_ns'] = np.modf(samples['time'])[0] * 10**9
+    elif 'time_min' in params and 'time_max' in params:
+      est_time=samples['time_min']+0.5*(samples['time_max']-samples['time_min'])
+      injections['time_geocent_gps'] = np.modf(est_time)[1]
+      injections['time_geocent_gps_ns'] = np.modf(est_time)[0] * 10**9
+
+    # Populate structured array
+    injections['waveform'] = [opts.approx for i in range(N)]
+    try:
+      injections['frequency'] = samples['frequency']
+    except:
+      injections['frequency']=[np.nan for i in samples['ra']]
+    injections['duration'] = dur
+    injections['q'] = q
+    try:
+      injections['hrss'] = samples['hrss']
+    except:
+      injections['hrss'] = np.exp(samples['loghrss'])
+    injections['ra'] = samples['ra']
+    injections['dec'] = samples['dec']
+    injections['psi'] = samples['psi']
+
+    # Create a new XML document
+    xmldoc = ligolw.Document()
+    xmldoc.appendChild(ligolw.LIGO_LW())
+    proc = igwn_ligolw.utils.process.register_to_xmldoc(doc, sys.argv[0], {})
+
+    #create timeslide table and set offsets to 0
+    timeslide_table = lsctables.TimeSlideTable.new()
+    timeslide_id = timeslide_table.append_offsetvector(
+        {'H1':0,'V1':0,'L1':0,'H2':0}, proc)
+
+    sim_table = lsctables.SimBurstTable.new()
+    xmldoc.childNodes[0].appendChild(timeslide_table)
+    xmldoc.childNodes[0].appendChild(sim_table)
+
+    # Add empty rows to the sim_inspiral table
+    for inj in range(N):
+        row = sim_table.RowType()
+        for slot in row.__slots__: setattr(row, slot, 0)
+        sim_table.append(row)
+
+    # Fill in IDs
+    for i,row in enumerate(sim_table):
+        row.process_id = proc.process_id
+        row.simulation_id = sim_table.get_next_id()
+        row.time_slide_id = timeslide_id
+    # Fill rows
+    for field in injections.dtype.names:
+        vals = injections[field]
+        for row, val in zip(sim_table, vals): setattr(row, field, val)
+
+    # Write file
+    output_file = open(opts.output, 'w')
+    xmldoc.write(output_file)
+    output_file.close()