PyCBC 2.6.0__tar.gz → 2.7.2__tar.gz

{PyCBC-2.6.0 → PyCBC-2.7.2}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: PyCBC
-Version: 2.6.0
+Version: 2.7.2
 Summary: Core library to analyze gravitational-wave data, find signals, and study their parameters.
 Home-page: http://pycbc.org/
-Download-URL: https://github.com/gwastro/pycbc/tarball/v2.6.0
+Download-URL: https://github.com/gwastro/pycbc/tarball/v2.7.2
 Author: The PyCBC team
 Author-email: alex.nitz@gmail.org
 Keywords: ligo,physics,gravity,signal processing,gravitational waves

{PyCBC-2.6.0 → PyCBC-2.7.2}/PyCBC.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: PyCBC
-Version: 2.6.0
+Version: 2.7.2
 Summary: Core library to analyze gravitational-wave data, find signals, and study their parameters.
 Home-page: http://pycbc.org/
-Download-URL: https://github.com/gwastro/pycbc/tarball/v2.6.0
+Download-URL: https://github.com/gwastro/pycbc/tarball/v2.7.2
 Author: The PyCBC team
 Author-email: alex.nitz@gmail.org
 Keywords: ligo,physics,gravity,signal processing,gravitational waves

{PyCBC-2.6.0 → PyCBC-2.7.2}/PyCBC.egg-info/SOURCES.txt

@@ -213,7 +213,7 @@ bin/pygrb/pycbc_pygrb_plot_null_stats
 bin/pygrb/pycbc_pygrb_plot_skygrid
 bin/pygrb/pycbc_pygrb_plot_snr_timeseries
 bin/pygrb/pycbc_pygrb_plot_stats_distribution
-bin/pygrb/pycbc_pygrb_pp_workflow
+bin/pygrb/pycbc_pygrb_results_workflow
 bin/workflow_comparisons/offline_search/pycbc_combine_injection_comparisons
 bin/workflow_comparisons/offline_search/pycbc_injection_set_comparison
 bin/workflow_comparisons/offline_search/pycbc_plot_injections_found_both_workflows
@@ -518,6 +518,7 @@ pycbc/inference/sampler/dynesty.py
 pycbc/inference/sampler/emcee.py
 pycbc/inference/sampler/emcee_pt.py
 pycbc/inference/sampler/epsie.py
+pycbc/inference/sampler/games.py
 pycbc/inference/sampler/multinest.py
 pycbc/inference/sampler/nessai.py
 pycbc/inference/sampler/ptemcee.py

{PyCBC-2.6.0 → PyCBC-2.7.2}/bin/all_sky_search/pycbc_coinc_statmap

@@ -291,9 +291,9 @@ if fore_locs.sum() > 0:
     f['foreground/ifar_exc'] = conv.sec_to_year(ifar_exc)
     f['foreground/fap_exc'] = fap_exc
 else:
-    f['foreground/ifar'] = numpy.array([])
+    f['foreground/ifar'] = ifar = numpy.array([])
     f['foreground/fap'] = numpy.array([])
-    f['foreground/ifar_exc'] = numpy.array([])
+    f['foreground/ifar_exc'] = ifar_exc = numpy.array([])
     f['foreground/fap_exc'] = numpy.array([])
 
 if 'name' in all_trigs.attrs:
@@ -331,6 +331,10 @@ else :
 #          will happen when ifar_foreground has no elements greater than
 #          the background time.
 
+# This is a workaround for the case that we have no foreground, so that the
+# while loop comparison doesnt fail straight away
+ifar_foreground = numpy.append(ifar_foreground, 0)
+
 while numpy.any(ifar_foreground >= background_time):
     # If the user wants to stop doing hierarchical removals after a set
     # number of iterations then break when that happens.

{PyCBC-2.6.0 → PyCBC-2.7.2}/bin/live/pycbc_live_collated_dq_trigger_rates

@@ -20,63 +20,124 @@ for a day of PyCBC Live triggers.
 import logging
 import argparse
 import hashlib
+import os
+import glob
 
 import numpy as np
 
+import gwdatafind
+
 import pycbc
 from pycbc.io import HFile
 
-import gwdatafind
-
 from gwpy.timeseries import TimeSeriesDict
 from gwpy.segments import Segment, DataQualityFlag
 
+
+def find_frames(ifo, frame_dir, frame_type, start, end):
+    """
+    Find the frame files for a given time range.
+    """
+    ifo_frame_type = frame_type.format(ifo=ifo)
+    ifo_pattern = f'{ifo[0]}-{ifo_frame_type}_llhoft-'
+    folder_pattern = ifo_pattern + '{supertime}'
+    path_pattern = os.path.join(
+        frame_dir,
+        ifo_frame_type,
+        folder_pattern,
+    )
+
+    start_round = int(start / 10000)
+    end_round = int(end / 10000)
+    files = []
+    for t in range(start_round, end_round + 1):
+        framedir = path_pattern.format(supertime=t)
+        files += glob.glob(os.path.join(framedir, '*.gwf'))
+
+    return files
+
+
 parser = argparse.ArgumentParser(description=__doc__)
 parser.add_argument("--trigger-file", required=True)
 parser.add_argument("--ifo", required=True)
 parser.add_argument("--gps-start-time", required=True, type=int)
 parser.add_argument("--gps-end-time", required=True, type=int)
 parser.add_argument("--template-bin-file", required=True)
-parser.add_argument("--analysis-frame-type", required=True)
+parser.add_argument("--use-gwdatafind", action='store_true',
+                    help='Use gwdatafind to find frame files. If provided, '
+                         'frame-directory argument will be ignored.')
+parser.add_argument("--frame-directory",
+                    help='Directory containing frame files. Required if '
+                         'not using gwdatafind.')
+parser.add_argument("--frame-type", required=True)
 parser.add_argument("--analysis-flag-name", required=True)
 parser.add_argument("--dq-channel", required=True)
 parser.add_argument("--dq-ok-channel", required=True)
 parser.add_argument("--dq-thresh", required=True, type=float)
+parser.add_argument("--dq-padding", type=float, default=1.0)
+parser.add_argument("--replay-offset", type=int, default=0)
 parser.add_argument("--output", required=True)
 pycbc.add_common_pycbc_options(parser)
 args = parser.parse_args()
 
 pycbc.init_logging(args.verbose)
 
+if not args.use_gwdatafind and args.frame_directory is None:
+    raise ValueError('Must provide frame-directory if not using gwdatafind.')
+
 # Get observing segs
 ar_flag_name = args.analysis_flag_name.format(ifo=args.ifo)
 day_seg = Segment(args.gps_start_time, args.gps_end_time)
 observing_flag = DataQualityFlag.query(ar_flag_name, day_seg)
+
+# shift observing flag to current time
+observing_flag = observing_flag.pad(args.replay_offset, args.replay_offset)
+
 observing_segs = observing_flag.active
 livetime = observing_flag.livetime
 logging.info(f'Found {livetime} seconds of observing time at {args.ifo}.')
 
 # for each segment, check how much time was dq flagged
 flagged_time = 0
-frame_type = args.analysis_frame_type.format(ifo=args.ifo)
 dq_channel = args.dq_channel.format(ifo=args.ifo)
 dq_ok_channel = args.dq_ok_channel.format(ifo=args.ifo)
 for seg in observing_segs:
-    frames = gwdatafind.find_urls(
-        args.ifo[0],
-        frame_type,
-        seg[0],
-        seg[1],
-    )
+    if args.use_gwdatafind:
+        frame_type = args.analysis_frame_type.format(ifo=args.ifo)
+        frames = gwdatafind.find_urls(
+            args.ifo[0],
+            frame_type,
+            seg[0],
+            seg[1],
+        )
+    else:
+        frames = find_frames(
+            args.ifo,
+            args.frame_directory,
+            args.frame_type,
+            seg[0],
+            seg[1],
+        )
+
     tsdict = TimeSeriesDict.read(
         frames,
         channels=[dq_channel, dq_ok_channel],
         start=seg[0],
         end=seg[1],
+        pad=0,
     )
+
     dq_ok_flag = (tsdict[dq_ok_channel] == 1).to_dqflag()
     dq_flag = (tsdict[dq_channel] <= args.dq_thresh).to_dqflag()
-    flagged_time += (dq_flag & dq_ok_flag).livetime
+
+    valid_bad_dq = dq_flag & dq_ok_flag
+
+    # pad flag outwards to match the padding used in the live script
+    valid_bad_dq.protract(args.dq_padding)
+    valid_bad_dq.coalesce()
+
+    flagged_time += (valid_bad_dq & observing_flag).livetime
+
 logging.info(f'Found {flagged_time} seconds of dq flagged time at {args.ifo}.')
 
 bg_livetime = livetime - flagged_time

{PyCBC-2.6.0 → PyCBC-2.7.2}/bin/live/pycbc_live_supervise_collated_trigger_fits

@@ -495,10 +495,12 @@ def daily_dq_trigger_rates(
     fname_format = daily_dq_controls['daily-dq-format']
     ddtr_out_fname = fname_format.format(date=day_str, ifo=ifo)
 
-    today = get_true_date(day_dt, daily_dq_controls)
+    start_time = get_true_date(day_dt, daily_dq_controls)
 
-    gps_start_time = gpstime.utc_to_gps(today).gpsSeconds
-    gps_end_time = gpstime.utc_to_gps(today + timedelta(days=1)).gpsSeconds
+    gps_start_time = gpstime.utc_to_gps(start_time).gpsSeconds
+    gps_end_time = gpstime.utc_to_gps(start_time + timedelta(days=1)).gpsSeconds
+
+    offset = gpstime.utc_to_gps(day_dt).gpsSeconds - gps_start_time
 
     ddtr_out_full = os.path.join(output_dir, ddtr_out_fname)
     daily_dq_args = ['pycbc_live_collated_dq_trigger_rates']
@@ -508,6 +510,7 @@ def daily_dq_trigger_rates(
 
     daily_dq_options['gps-start-time'] = f'{gps_start_time:d}'
     daily_dq_options['gps-end-time'] = f'{gps_end_time:d}'
+    daily_dq_options['replay-offset'] = f'{offset:d}'
     daily_dq_args += sv.dict_to_args(daily_dq_options)
 
     sv.run_and_error(daily_dq_args, controls)

{PyCBC-2.6.0 → PyCBC-2.7.2}/bin/pygrb/pycbc_make_offline_grb_workflow

@@ -443,7 +443,7 @@ if post_proc_method == "PYGRB_OFFLINE":
                                           sciSegs[ifo][0], full_bank_file,
                                           inspiral_files, injs,
                                           inj_insp_files, inj_tags)
-    sec_name = 'workflow-pygrb_pp_workflow'
+    sec_name = 'workflow-pygrb_results_workflow'
     if not wflow.cp.has_section(sec_name):
         msg = 'No {0} section found in configuration file.'.format(sec_name)
         logging.info(msg)

{PyCBC-2.6.0 → PyCBC-2.7.2}/bin/pygrb/pycbc_pygrb_efficiency

@@ -538,25 +538,6 @@ yerr_low_mc, yerr_high_mc, fraction_mc = efficiency_with_errs(
 yerr_low_no_mc, yerr_high_no_mc, fraction_no_mc = efficiency_with_errs(
                            found_max_bestnr['no_mc'], num_injections['no_mc'])
 
-# Calculate and save to disk the 50% sensitive distance
-eff_low = fraction_no_mc
-eff_idx = np.where(eff_low < 0.5)[0]
-if eff_idx.size == 0:
-    sens_dist = -1
-    err_msg = "Efficiency does not drop below 50%!"
-    logging.error(err_msg)
-elif eff_idx[0] == 0:
-    sens_dist = 0
-    err_msg = "Efficiency does not drop below 90%!"
-    logging.error(err_msg)
-else:
-    i = eff_idx[0]
-    d = dist_plot_vals[i]
-    d_low = dist_plot_vals[i-1]
-    e = eff_low[i]
-    e_low = eff_low[i-1]
-    sens_dist = d + (e - 0.5) * (d - d_low) / (e_low - e)
-
 # Plot efficiency using loudest background
 if opts.background_output_file:
     fig = plt.figure()
@@ -573,7 +554,7 @@ if opts.background_output_file:
     ax.legend()
     ax.grid()
     ax.set_ylim([0, 1])
-    ax.set_xlim(0, 2.*upper_dist - lower_dist)
+    ax.set_xlim(0, 1.3*upper_dist)
     ax.set_ylabel("Fraction of injections found louder than loudest background")
     ax.set_xlabel("Distance (Mpc)")
     plot_title = "Detection efficiency - "+inj_set_name
@@ -597,6 +578,8 @@ yerr_low, yerr_high, fraction_mc = \
 red_efficiency = (fraction_mc) - (yerr_low) * scipy.stats.norm.isf(0.1)
 
 # Calculate and save to disk 50% and 90% exclusion distances
+# excl_dist dictionary contains 50% and 90% exclusion distances 
+excl_dist = {}
 for percentile in [50, 90]:
     eff_idx = np.where(red_efficiency < (percentile / 100.))[0]
     if eff_idx.size == 0:
@@ -611,26 +594,23 @@ for percentile in [50, 90]:
         d_low = dist_plot_vals[i-1]
         e = excl_efficiency[i]
         e_low = excl_efficiency[i-1]
-        excl_dist = d + (e - (percentile / 100.)) * (d - d_low) /\
+        excl_dist[f"{percentile}%"] = d + (e - (percentile / 100.)) * (d - d_low) /\
             (e_low - e)
     else:
         # Warn the user if the exclusion distance cannot be established,
         # but let the workflow continue: the user will see the plot(s) and
         # repeat with more injections
-        excl_dist = 0
+        excl_dist[f"{percentile}%"] = 0
         msg = "Efficiency below %d%% in first bin!" % (percentile)
         logging.warning(msg)
 
 # Write 50% and 90% exclusion distances to JSON file
 # Also include injection set name and trial name
 if opts.exclusion_dist_output_file:
-    excl_dist_dict = {}
-    excl_dist_dict['inj_set'] = inj_set_name
-    excl_dist_dict['trial_name'] = opts.trial_name
-    excl_dist_dict['50%'] = sens_dist
-    excl_dist_dict['90%'] = excl_dist
+    excl_dist['inj_set'] = inj_set_name
+    excl_dist['trial_name'] = opts.trial_name
     with open(opts.exclusion_dist_output_file, 'w') as excl_dist_file:
-        json.dump(excl_dist_dict, excl_dist_file)
+        json.dump(excl_dist, excl_dist_file)
 
 # Plot efficiency using loudest foreground
 if opts.onsource_output_file:
@@ -655,19 +635,19 @@ if opts.onsource_output_file:
     ax.get_legend().get_frame().set_alpha(0.5)
     ax.grid()
     ax.set_ylim([0, 1])
-    ax.set_xlim(0, 2.*upper_dist - lower_dist)
+    ax.set_xlim(0, 1.3*upper_dist)
     ax.set_ylabel("Fraction of injections found louder than " +
                   "loudest foreground")
     ax.set_xlabel("Distance (Mpc)")
-    ax.plot([excl_dist], [0.9], 'gx')
+    ax.plot([excl_dist["90%"]], [0.9], 'gx')
     ax.set_ylim([0, 1])
-    ax.set_xlim(0, 2.*upper_dist - lower_dist)
+    ax.set_xlim(0, 1.3*upper_dist)
     plot_title = "Exclusion distance - "+inj_set_name
     plot_caption = "Injection recovery efficiency using "
     plot_caption += "BestNR as detection statistic.  "
     plot_caption += "Injections louder than loudest foreground trigger.\n"
-    plot_caption += f" 90%% exclusion distance: {excl_dist} Mpc\n"
-    plot_caption += f" 50%% sensitive distance: {sens_dist} Mpc"
+    plot_caption += f" 90%% exclusion distance: {excl_dist['90%']} Mpc\n"
+    plot_caption += f" 50%% sensitive distance: {excl_dist['50%']} Mpc"
     fig_path = opts.onsource_output_file
     save_fig_with_metadata(fig, fig_path, cmd=' '.join(sys.argv),
                            title=plot_title, caption=plot_caption)