PycWB 0.26.0__tar.gz → 0.27.0__tar.gz

{pycwb-0.26.0 → pycwb-0.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PycWB
-Version: 0.26.0
+Version: 0.27.0
 Summary: A Python package for coherent gravitational wave burst analysis
 Home-page: https://git.ligo.org/yumeng.xu/pycwb
 Author-email: The PycWB team <yumeng.xu@ligo.org>

{pycwb-0.26.0 → pycwb-0.27.0}/PycWB.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PycWB
-Version: 0.26.0
+Version: 0.27.0
 Summary: A Python package for coherent gravitational wave burst analysis
 Home-page: https://git.ligo.org/yumeng.xu/pycwb
 Author-email: The PycWB team <yumeng.xu@ligo.org>

{pycwb-0.26.0 → pycwb-0.27.0}/PycWB.egg-info/SOURCES.txt

@@ -175,6 +175,7 @@ examples/benchmark/input/OPBM.period
 examples/benchmark/input/OPBM_H1.frames
 examples/benchmark/input/OPBM_L1.frames
 examples/colab/pycWB_GW150914.ipynb
+examples/gwosc/user_parameters.yaml
 examples/injection/pycwb_injection.ipynb
 examples/injection/user_parameters_injection.yaml
 examples/injection/wdmXTalk/OverlapCatalog16-1024.bin
@@ -240,6 +241,7 @@ pycwb/cli/__init__.py
 pycwb/cli/batch_runner.py
 pycwb/cli/batch_setup.py
 pycwb/cli/flow.py
+pycwb/cli/gwosc.py
 pycwb/cli/merge_catalog.py
 pycwb/cli/post_process.py
 pycwb/cli/run.py
@@ -282,6 +284,8 @@ pycwb/modules/gracedb/__init__.py
 pycwb/modules/gracedb/gracedb.py
 pycwb/modules/gracedb/module.yaml
 pycwb/modules/gracedb/test_gracedb.py
+pycwb/modules/gwosc/__init__.py
+pycwb/modules/gwosc/gwosc.py
 pycwb/modules/job_segment/__init__.py
 pycwb/modules/job_segment/dq_segment.py
 pycwb/modules/job_segment/frame.py
@@ -327,6 +331,7 @@ pycwb/modules/reconstruction/__init__.py
 pycwb/modules/reconstruction/getMRAwaveform.py
 pycwb/modules/reconstruction/module.yaml
 pycwb/modules/report/__init__.py
+pycwb/modules/report/continues_poisson.py
 pycwb/modules/report/far_rho.py
 pycwb/modules/report/read_results.py
 pycwb/modules/report/report.py
@@ -395,6 +400,7 @@ pycwb/vendor/example.yaml
 pycwb/vendor/autoencoder/__init__.py
 pycwb/vendor/autoencoder/cwb_autoencoder.h5
 pycwb/vendor/lib/__init__.py
+pycwb/vendor/template/gwosc/user_parameters.yaml
 pycwb/vendor/web_viewer/event_dump.html
 pycwb/vendor/web_viewer/styles.css
 pycwb/vendor/web_viewer/viewer.html

{pycwb-0.26.0 → pycwb-0.27.0}/bin/pycwb

@@ -12,6 +12,7 @@ import pycwb.cli.batch_runner as batch_runner
 import pycwb.cli.xtalk as xtalk
 import pycwb.cli.merge_catalog as merge_catalog
 import pycwb.cli.post_process as post_process
+import pycwb.cli.gwosc as gwosc
 
 def main():
     parser = argparse.ArgumentParser(prog='pycwb')
@@ -51,6 +52,11 @@ def main():
     post_process.init_parser(post_process_parser)
     post_process_parser.set_defaults(func=post_process.command)
 
+    #gwosc subcommand
+    gwosc_parser = subparsers.add_parser('gwosc', help='Download files to run a pycwb analysis of a GW event of your choice')
+    gwosc.init_parser(gwosc_parser)
+    gwosc_parser.set_defaults(func=gwosc.command)
+        
     args = parser.parse_args()
     if hasattr(args, 'func'):
         args.func(args)

{pycwb-0.26.0 → pycwb-0.27.0}/docs/source/index.rst

@@ -124,6 +124,10 @@ You can get help by running the command with the ``-h`` option. Here are the cur
      - Setup batch run
    * - ``pycwb batch-runner``
      - Runner for batch run, used for the job submission
+   * - ``pycwb post-process``
+     - Run the post process workflow
+   * - ``pycwb gwosc``
+     - Download data from GWOSC and setup the search
    * - ``pycwb flow``
      - Run search with prefect flow
    * - ``pycwb xtalk``

pycwb-0.27.0/examples/gwosc/user_parameters.yaml

@@ -0,0 +1,89 @@
+
+outputDir: "output"
+nproc: 6
+plot_trigger: True
+plot_waveform: True
+plot_injection: True
+plot_sky_map: True
+save_sky_map: True
+save_injection: True
+save_waveform: True
+
+analysis: "2G"
+cfg_search: "r"
+
+optim: False
+
+###### network configuration ######
+ifo: ["L1","H1"]
+refIFO: "L1"
+
+inRate: 16384
+# lags
+lagSize: 1
+lagStep: 1.
+lagOff: 0
+lagMax: 0
+
+# superlags
+slagSize: 0 # number of super lags (simulation=1) - if slagSize=0 -> Standard Segments
+slagMin: 0
+slagMax: 0
+slagOff: 0
+
+# job
+segLen: 1200
+segMLS: 600
+segTHR: 200
+segEdge: 10
+
+# frequency
+fLow: 16.
+fHigh: 1024.
+
+
+levelR: 3
+l_low: 4 # low frequency resolution level		// std (sthr = 2)
+l_high: 10 # high frequency resolution level	// std (sthr = 8)
+
+wdmXTalk: "wdmXTalk/OverlapCatalog16-1024.bin"
+
+healpix: 7
+
+###### cWB production thresholds & regulators ######
+
+bpp: 0.001
+subnet: 0.5
+subcut: 0.0
+netRHO: 5.5
+netCC: 0.5
+Acore: 1.7
+Tgap: 0.2
+Fgap: 128.0
+delta: 0.5
+cfg_gamma: -1.0
+LOUD: 300
+
+pattern: 5
+
+iwindow: 30
+
+nSky: 196608
+
+# simulation
+simulation: None  #PREVIOUSLY COMMENTED
+nfactor: 1
+
+channelNamesRaw: ["L1:GWOSC-4KHZ_R1_STRAIN","H1:GWOSC-4KHZ_R1_STRAIN"]
+frFiles: ["./GW170104/input/L1_frames.in", "./GW170104/input/H1_frames.in"]
+
+DQF: [
+  [ "L1" ,"./GW170104/input/L1_cat0.txt", CWB_CAT0, 0., False, False ],
+  [ "H1" ,"./GW170104/input/H1_cat0.txt", CWB_CAT0, 0., False, False ],
+  [ "L1" ,"./GW170104/input/L1_cat1.txt", CWB_CAT1, 0., False, False ],
+  [ "H1" ,"./GW170104/input/H1_cat1.txt", CWB_CAT1, 0., False, False ],
+  [ "L1" ,"./GW170104/input/L1_cat2.txt", CWB_CAT2, 0., False, False ],
+  [ "H1" ,"./GW170104/input/H1_cat2.txt", CWB_CAT2, 0., False, False ],
+  [ "L1" ,"./GW170104/input/cwb_period.txt", CWB_CAT0, 0., False, False ],
+  [ "H1" ,"./GW170104/input/cwb_period.txt", CWB_CAT0, 0., False, False ],
+]

{pycwb-0.26.0 → pycwb-0.27.0}/prototypes/pp_workflow/simple_module.yaml

@@ -4,14 +4,14 @@ steps:
   - action: report.read_results.read_triggers
     args:
       run_dir: background
-      filters:
-        - "lag[0]>0"
+      prefilters:
+        - "shift[0] != 0 or shift[1] != 0 or lag != 0"
     output_alias: 'background'
   - action: report.read_results.read_live_time
     args:
       run_dir: background
       filters:
-        - "lag[0]>0"
+        - "shift[0] != 0 or shift[1] != 0 or lag != 0"
     output_alias: 'livetime'
   - action: report.far_rho.far_rho # this module will calculate the far_rho and pass the output to the downstream modules
     args:
@@ -24,14 +24,18 @@ steps:
   - action: report.read_results.read_triggers
     args:
       run_dir: background
-      filters:
-        - "lag[0]==0"
+      prefilters:
+        - "lag==0"
+        - "slag[0]==0"
+        - "slag[1]==0"
     output_alias: 'zero_lag'
   - action: report.read_results.read_live_time
     args:
       run_dir: background
       filters:
-        - "lag[0]==0"
+        - "lag==0"
+        - "shift[0]==0"
+        - "shift[1]==0"
     output_alias: 'livetime_zerolag'
   - action: report.report.report_zero_lag
     args:

{pycwb-0.26.0 → pycwb-0.27.0}/pycwb/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.26.0'
-__version_tuple__ = version_tuple = (0, 26, 0)
+__version__ = version = '0.27.0'
+__version_tuple__ = version_tuple = (0, 27, 0)

pycwb-0.27.0/pycwb/cli/gwosc.py

@@ -0,0 +1,84 @@
+import os
+import shutil
+import pycwb
+from pycwb.modules.gwosc.gwosc import download_frames_files
+from pycwb.modules.gwosc.gwosc import get_cat_files
+from pycwb.modules.gwosc.gwosc import analysis_period
+
+def init_parser(parser):
+
+    # Select the GW event
+    parser.add_argument('event_name',
+                        metavar='event_name',  # Corrected metavar
+                        type=str,
+                        help='The name of the GW event you want (e.g., "GW150914").')
+
+    # Time left for cWB analysis
+    parser.add_argument('--time_left',
+                        metavar='time_left',
+                        type=float,
+                        default=610, 
+                        help='The pycWB analysis interval is '
+                             '[event_gps_time - time_left; event_gps_time + time_right]. Default: 610 seconds.')
+
+    # Time right for cWB analysis
+    parser.add_argument('--time_right',
+                        metavar='time_right',
+                        type=float,
+                        default=610, 
+                        help='The pycWB analysis interval is: '
+                             '[event_gps_time - time_left; event_gps_time + time_right]. Default: 610 seconds.')
+
+    # List of detectors
+    parser.add_argument('--ifos',
+                        metavar='ifos',
+                        type=str,
+                        nargs='+', 
+                        default=['H1', 'L1'], 
+                        help='List of the detectors you want data from. For example: --ifos H1 L1. The default is H1 L1.')
+    
+    parser.add_argument('--user_parameters_path',
+                        metavar='user_parameters_path',
+                        type=str,
+                        default=None, 
+                        help='Path of the user_parameters file, default pycwb/vendor/template/gwosc/')
+    
+
+def copy_user_parameters(user_parameters_path):
+
+    
+    file_to_copy = os.path.join(user_parameters_path, 'user_parameters.yaml')  
+
+    # Check if the file exists
+    if not os.path.exists(file_to_copy):
+        raise FileNotFoundError(f"The file {file_to_copy} does not exist. The default file is {file_to_copy}")
+    
+    # Define the destination directory for the event
+    destination_dir = os.path.join(".")
+    os.makedirs(destination_dir, exist_ok=True)  # Ensure the directory exists
+
+    # Define the destination file path
+    destination_file = os.path.join(destination_dir, os.path.basename(file_to_copy))
+    
+    # Copy the file
+    shutil.copy(file_to_copy, destination_file)
+    print(f"Copied {file_to_copy} to {destination_file}")
+
+
+def command(args):
+
+    if not all(ifo in ["H1", "L1"] for ifo in args.ifos) and not args.user_parameters_path:
+        raise ValueError("Only H1 and L1 are supported in ifos with the default user_parameters file, "
+                         "please provide a custom user_parameters file")
+
+    output = './input'
+    
+    if args.user_parameters_path is None:
+        package_abs_path = os.path.dirname(os.path.abspath(pycwb.__file__))
+        args.user_parameters_path = os.path.join(package_abs_path, 'vendor/template/gwosc')
+        print(f'{args.user_parameters_path}')
+
+    download_frames_files(args.event_name, output, args.ifos)
+    get_cat_files(args.event_name, output, args.ifos)
+    analysis_period(args.event_name, output, args.time_left, args.time_right, args.ifos)
+    copy_user_parameters(args.user_parameters_path)

pycwb-0.27.0/pycwb/modules/gwosc/gwosc.py

@@ -0,0 +1,142 @@
+from gwosc.datasets import event_gps, event_detectors, event_segment
+from gwosc.locate import get_urls
+from gwosc.timeline import get_segments
+import os
+import requests
+
+def event_info(event_name, ifos):
+    """
+    Retrieve key information about the specified gravitational wave event.
+
+    Parameters:
+    -----------
+    event_name : str
+        The name of the gravitational wave event (e.g., "GW150914").
+
+    Returns:
+    --------
+    tuple :
+        - A list of detectors that observed the event, filtered to include only allowed detectors.
+        - The GPS time of the event.
+        - The start and end GPS time of the event segment.
+    """
+    allowed_cWB_detectors = ifos
+    detectors = event_detectors(event_name)  
+    detectors = [detector for detector in detectors if detector in allowed_cWB_detectors]
+    event_gps_time = event_gps(event_name)
+    start_time, end_time = event_segment(event_name)
+
+    return detectors, event_gps_time, start_time, end_time
+
+def download_frames_files(event_name, output_dir, ifos):
+    """
+    Download frame files for the given gravitational wave event and save a list of their paths.
+
+    Parameters:
+    -----------
+    event_name : str
+        The name of the gravitational wave event (e.g., "GW150914").
+    output_dir : str
+        The directory where frame files and associated lists will be saved.
+
+    Returns:
+    --------
+    None
+    """
+    os.makedirs(output_dir, exist_ok=True)
+
+    detectors, event_gps_time, start_time, end_time = event_info(event_name, ifos)
+
+    for detector in detectors:
+        urls = get_urls(detector=detector, start=start_time, end=end_time, dataset=event_name, format='gwf', sample_rate=4096)
+        
+        # Exclude files with '-32.gwf'
+        urls = [url for url in urls if "-32.gwf" not in url] 
+        
+        frame_dir = os.path.join(f"{output_dir}/frames/", f"{detector}_frames")
+        os.makedirs(frame_dir, exist_ok=True)
+
+        local_paths = []
+
+        # Download files
+        for url in urls:
+            frame_file_path = os.path.join(frame_dir, os.path.basename(url))
+            print(f"Downloading {frame_file_path} from {url}...")
+            response = requests.get(url)
+            with open(frame_file_path, 'wb') as frame_file:
+                frame_file.write(response.content)
+            local_paths.append(frame_file_path)
+
+        # Save *_frames.in file
+        frame_list_file = os.path.join(output_dir, f"{detector}_frames.in")
+        with open(frame_list_file, 'w') as f:
+            for path in local_paths:
+                f.write(path + "\n")
+
+        print(f"Frame list saved to {frame_list_file}")
+
+def get_cat_files(event_name, output_dir, ifos):
+    """
+    Generate files containing Data Quality (DQ) segments for the given gravitational wave event.
+
+    Parameters:
+    -----------
+    event_name : str
+        The name of the gravitational wave event (e.g., "GW150914").
+    output_dir : str
+        The directory where DQ segment files will be saved.
+
+    Returns:
+    --------
+    None
+    """
+    os.makedirs(output_dir, exist_ok=True)
+
+    detectors, event_gps_time, start_time, end_time = event_info(event_name, ifos)
+
+    for detector in detectors:
+        for category, cat_name in [
+            (f'{detector}_DATA', f'{detector}_cat0.txt'),
+            (f'{detector}_BURST_CAT1', f'{detector}_cat1.txt'),
+            (f'{detector}_BURST_CAT2', f'{detector}_cat2.txt'),
+        ]:
+            segments = get_segments(category, start_time, end_time)
+            cat_file_path = os.path.join(output_dir, cat_name)
+
+            with open(cat_file_path, 'w') as cat_file:
+                for segment in segments:
+                    cat_file.write(f"{segment[0]} {segment[1]}\n")
+
+            print(f"Segments saved in {cat_file_path}")
+
+def analysis_period(event_name, output_dir, time_left, time_right, ifos):
+    """
+    Calculate the analysis period for cWB based on the event GPS time and save it to a file.
+
+    This function calculates the start and end times for the cWB analysis period by subtracting
+    and adding the specified offsets (`time_left` and `time_right`) to the GPS time of the 
+    gravitational wave event. The resulting period is saved in a file named `cwb_period.txt`.
+
+    Parameters:
+    -----------
+    event_name : str
+        The name of the gravitational wave event (e.g., "GW150914").
+    time_left : int, optional
+        Time in seconds to subtract from the event GPS time to determine the start of the analysis period
+        (default is 610 seconds).
+    time_right : int, optional
+        Time in seconds to add to the event GPS time to determine the end of the analysis period
+        (default is 610 seconds).
+
+    Returns:
+    --------
+    None
+    """
+    _, event_gps_time, _, _ = event_info(event_name, ifos)
+    print(f"Event gps time: {event_gps_time}")
+    analysis_period = [event_gps_time - time_left, event_gps_time + time_right]
+
+    cwb_period_file_path = os.path.join(output_dir, "cwb_period.txt")
+    with open(cwb_period_file_path, 'w') as cwb_period_file:
+        cwb_period_file.write(f"{analysis_period[0]} {analysis_period[1]}\n")
+    print(f"cWB analysis period saved in {cwb_period_file_path}")

pycwb-0.27.0/pycwb/modules/report/continues_poisson.py

@@ -0,0 +1,129 @@
+"""
+This module is inspired by ROOT::TMath::Poisson and ROOT::TF1::GetQuantiles
+"""
+import numpy as np
+from scipy.special import gammaln
+from scipy.integrate import quad
+from scipy.interpolate import interp1d
+from numba import njit, prange
+
+
+@njit(fastmath=True,error_model='numpy',parallel=True)
+def gammaln_nr(z):
+    """Numerical Recipes 6.1"""
+    #Don't use global variables.. (They only can be changed if you recompile the function)
+    coefs = np.array([
+        57.1562356658629235, -59.5979603554754912,
+        14.1360979747417471, -0.491913816097620199,
+        .339946499848118887e-4, .465236289270485756e-4,
+        -.983744753048795646e-4, .158088703224912494e-3,
+        -.210264441724104883e-3, .217439618115212643e-3,
+        -.164318106536763890e-3, .844182239838527433e-4,
+        -.261908384015814087e-4, .368991826595316234e-5])
+
+    y = z
+    tmp = z + 5.24218750000000000
+    tmp = (z + 0.5) * np.log(tmp) - tmp
+    ser = 0.999999999999997092
+
+    n = coefs.shape[0]
+    for j in range(n):
+        y = y + 1.
+        ser = ser + coefs[j] / y
+
+    return tmp + np.log(2.5066282746310005 * ser / z)
+
+
+@njit(fastmath=True,error_model='numpy',parallel=True)
+def gammaln_nr_p(z):
+    """Numerical Recipes 6.1"""
+    #Don't use global variables.. (They only can be changed if you recompile the function)
+    coefs = np.array([
+        57.1562356658629235, -59.5979603554754912,
+        14.1360979747417471, -0.491913816097620199,
+        .339946499848118887e-4, .465236289270485756e-4,
+        -.983744753048795646e-4, .158088703224912494e-3,
+        -.210264441724104883e-3, .217439618115212643e-3,
+        -.164318106536763890e-3, .844182239838527433e-4,
+        -.261908384015814087e-4, .368991826595316234e-5])
+
+    out=np.empty(z.shape[0])
+
+
+    for i in prange(z.shape[0]):
+        y = z[i]
+        tmp = z[i] + 5.24218750000000000
+        tmp = (z[i] + 0.5) * np.log(tmp) - tmp
+        ser = 0.999999999999997092
+
+        n = coefs.shape[0]
+        for j in range(n):
+            y = y + 1.
+            ser = ser + coefs[j] / y
+
+        out[i] = tmp + np.log(2.5066282746310005 * ser / z[i])
+    return out
+
+
+@njit
+def continues_poisson(x, mu):
+    """
+    compute the Poisson distribution function for (x,mu)
+ The Poisson PDF is implemented by means of Euler's Gamma-function
+ (for the factorial), so for any x integer argument it is correct.
+ BUT for non-integer x values, it IS NOT equal to the Poisson distribution.
+
+    Parameters
+    ----------
+    x : float or array_like
+        The number of events
+    mu : float
+        The mean number of events
+
+    Returns
+    -------
+    float or array_like
+        The Poisson distribution function for (x, mu)
+    """
+    return np.exp(x * np.log(mu) - mu - gammaln_nr(x + 1))
+
+
+def get_percentiles(mu, percentiles):
+    """
+    Get the quantiles for a Poisson distribution with mean mu and given percentiles
+
+    Parameters
+    ----------
+    mu : float
+        The mean number of events
+    percentiles : float or array_like
+        The percentiles to compute the quantiles for
+
+    Returns
+    -------
+    float or array_like
+        The quantiles for the Poisson distribution with mean mu and given percentiles
+    """
+    max_val = 10 * mu if mu > 10 else 100  # Maximum range for interpolation
+    x = np.linspace(0, max_val, 1000)     # Fine grid of x-values for interpolation
+
+    # integrate the pmf to get the cdf
+    # FIXME: the integration can't reach 1 for mu <= 2
+    cdf = [quad(continues_poisson, 0, x_val, args=(mu))[0] for x_val in x]
+
+    # interpolate the cdf to get the quantiles
+    interpolate = interp1d(cdf, x, bounds_error=False, fill_value="extrapolate")
+    return interpolate(percentiles)
+
+
+def get_percentiles_ROOT(mu, prob_sum):
+    import ROOT
+
+    q = np.array([0., 0., 0., 0., 0., 0.])
+    max_val = 10 * mu if mu > 10 else 100
+    f = ROOT.TF1("poisson", "TMath::Poisson(x,[1])", 0, max_val)
+    f.SetParameter(1, mu)
+    f.SetNpx(1000)
+
+    f.GetQuantiles(6, q, prob_sum)
+    return q

{pycwb-0.26.0 → pycwb-0.27.0}/pycwb/modules/report/read_results.py

@@ -29,7 +29,7 @@ def list_dict_filter(data, conditions, name='event'):
     print(f"number of {name} after filtering: {len(filtered_events)}")
     return filtered_events
 
-def read_triggers(work_dir, run_dir, filters=None, file='catalog/catalog.json',**kwargs):
+def read_triggers(work_dir, run_dir, prefilters=None, filters=None, file='catalog/catalog.json',**kwargs):
     print(f"Reading results from {os.path.join(work_dir, run_dir, file)}")
     catalog = read_catalog(os.path.join(work_dir, run_dir, file))
 
@@ -40,6 +40,8 @@ def read_triggers(work_dir, run_dir, filters=None, file='catalog/catalog.json',*
     #         print(f"Reading event {i}/{n_events}", end='\r')
     #     event_file = os.path.join(work_dir, run_dir, f"trigger/trigger_{event['job_id']}_{event['id']}/event.json")
     #     events.append(read_event(event_file))
+    if prefilters:
+        catalog['events'] = list_dict_filter(catalog['events'], prefilters, name='catalog triggers')
 
     with ThreadPoolExecutor() as executor:
         futures = [executor.submit(read_event, os.path.join(work_dir, run_dir, f"trigger/trigger_{event['job_id']}_{event['id']}/event.json"))

{pycwb-0.26.0 → pycwb-0.27.0}/pycwb/modules/report/report.py

@@ -1,6 +1,7 @@
 import matplotlib.pyplot as plt
 import numpy as np
 from scipy.stats import poisson
+from .continues_poisson import get_percentiles, get_percentiles_ROOT
 
 
 def report(far_rho_source=None, **kwargs):
@@ -100,19 +101,28 @@ def report_zero_lag(source, livetime_key='livetime_zerolag', far_rho_source='far
 
     # Calculate the Poisson confidence intervals
     # generate the ifar range which is denser at the higher ifar
-    ifar_range = np.linspace(ifar_min, ifar_max, 100000)
+    ifar_range = np.linspace(ifar_min, ifar_max, 500)
     n_events_range = livetime_in_years / ifar_range
     sigma_levels = [1, 2, 3]
     confidence_levels = [0.6827, 0.9545, 0.9973]
-    conf_intervals = {sigma: poisson.interval(confidence, n_events_range) for sigma, confidence in zip(sigma_levels, confidence_levels)}
+    # conf_intervals = {sigma: poisson.interval(confidence, n_events_range) for sigma, confidence in zip(sigma_levels, confidence_levels)}
+    # # Plot the Poisson confidence intervals
+    # colors = ['gray', 'gray', 'gray']
+    # for sigma, color in zip(sigma_levels, colors):
+    #     lower, upper = conf_intervals[sigma]
+    precentiles = np.array([[(1 - c) / 2, 1 - (1 - c) / 2] for c in confidence_levels]).reshape(-1)
+    #conf_intervals = {sigma: poisson.interval(confidence, n_events_range) for sigma, confidence in zip(sigma_levels, confidence_levels)}
+    conf_intervals = np.array([get_percentiles_ROOT(n, precentiles).reshape((len(confidence_levels), 2)) for n in n_events_range])
     # Plot the Poisson confidence intervals
     colors = ['gray', 'gray', 'gray']
     for sigma, color in zip(sigma_levels, colors):
-        lower, upper = conf_intervals[sigma]
-        plt.fill_between(ifar_range, lower, upper, color=color, alpha=0.6 / sigma, label=f'{sigma} sigma', linewidth=0.4)
+        lower, upper = conf_intervals[:, sigma-1, 0], conf_intervals[:, sigma-1, 1]
+        plt.fill_between(ifar_range, lower, upper, color=color, alpha=0.6 / sigma, label=f'{sigma} sigma', linewidth=0.4,interpolate=True)
 
     plt.xlabel('ifar')
     plt.ylabel('n_events')
+    plt.xlim(ifar_min, ifar_max)
+    plt.ylim(8e-1, max(n_events_range))
     plt.xscale('log')
     plt.yscale('log')
     plt.legend()

{pycwb-0.26.0 → pycwb-0.27.0}/pycwb/types/network_event.py

@@ -160,7 +160,7 @@ class Event:
         self.neted = [0, 0, 0]
         self.eventID = [0, 0, 0]
         self.type = [0, 0, 0]
-        self.slag = shifts if shifts else [0, 0, 0]
+        self.slag = shifts if shifts is not None else [0, 0, 0]
 
 
         pwc = net.getwc(LAG)