PyCBC 2.8.2__tar.gz → 2.8.4__tar.gz

{PyCBC-2.8.2 → PyCBC-2.8.4}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: PyCBC
-Version: 2.8.2
+Version: 2.8.4
 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.8.2
+Download-URL: https://github.com/gwastro/pycbc/tarball/v2.8.4
 Author: The PyCBC team
 Author-email: alex.nitz@gmail.org
 Keywords: ligo,physics,gravity,signal processing,gravitational waves

{PyCBC-2.8.2 → PyCBC-2.8.4}/PyCBC.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: PyCBC
-Version: 2.8.2
+Version: 2.8.4
 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.8.2
+Download-URL: https://github.com/gwastro/pycbc/tarball/v2.8.4
 Author: The PyCBC team
 Author-email: alex.nitz@gmail.org
 Keywords: ligo,physics,gravity,signal processing,gravitational waves

{PyCBC-2.8.2 → PyCBC-2.8.4}/PyCBC.egg-info/SOURCES.txt

@@ -318,7 +318,9 @@ examples/multi_inspiral/check_faceon_faceaway_trigs.py
 examples/multi_inspiral/check_gw170817_trigs.py
 examples/multi_inspiral/clean.sh
 examples/multi_inspiral/faceon_faceaway.sh
-examples/multi_inspiral/run.sh
+examples/multi_inspiral/gw170817_h.sh
+examples/multi_inspiral/gw170817_hl.sh
+examples/multi_inspiral/gw170817_hlv.sh
 examples/noise/frequency.py
 examples/noise/timeseries.py
 examples/psd/analytic.py

{PyCBC-2.8.2 → PyCBC-2.8.4}/PyCBC.egg-info/requires.txt

@@ -13,10 +13,11 @@ beautifulsoup4>=4.6.0
 tqdm
 setuptools
 gwdatafind
-pegasus-wms.api>=5.0.8
+pegasus-wms.api==5.0.9
+pegasus-wms.common==5.0.9
 python-ligo-lw>=1.7.0
 igwn-segments
-lalsuite!=7.2
+lalsuite==7.25.1
 lscsoft-glue>=1.59.3
 pykerr
 

{PyCBC-2.8.2 → PyCBC-2.8.4}/bin/pycbc_hdf5_splitbank

@@ -17,8 +17,9 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
 """
-The code reads in a compressed template bank and splits it up into
-smaller banks where the number of smaller banks is a user input
+The code reads in a (optionally compressed) template bank and splits it up
+into smaller banks. Either the number of banks or the (approximate) number
+of templates per bank can be specified.
 """
 
 import argparse
@@ -33,7 +34,7 @@ __author__  = "Soumi De <soumi.de@ligo.org>"
 
 parser = argparse.ArgumentParser(description=__doc__[1:])
 pycbc.add_common_pycbc_options(parser)
-parser.add_argument("--bank-file", type=str,
+parser.add_argument("--bank-file", type=str, required=True,
                     help="Bank hdf file to load.")
 outbanks = parser.add_mutually_exclusive_group(required=True)
 outbanks.add_argument("--templates-per-bank", type=int,
@@ -42,11 +43,11 @@ outbanks.add_argument("--templates-per-bank", type=int,
 outbanks.add_argument("--number-of-banks", type=int,
                       help="Number of output sub-banks. Either specify this "
                       "or --templates-per-bank, not both.")
-outbanks.add_argument("--output-filenames", nargs='*', default=None,
+outbanks.add_argument("--output-filenames", nargs='*',
                       action="store",
                       help="Directly specify the names of the output files. "
                       "The bank will be split equally between files.")
-parser.add_argument("--output-prefix", default=None,
+parser.add_argument("--output-prefix",
                     help="Prefix to add to the output template bank names, "
                     "for example 'H1L1-BANK'. Output file names would then be "
                     "'H1L1-BANK{x}.hdf' where {x} is 1,2,...")
@@ -66,14 +67,14 @@ args = parser.parse_args()
 pycbc.init_logging(args.verbose)
 
 # input checks
-if args.mchirp_sort and (args.random_seed is not None):
-    raise RuntimeError("Can't supply a random seed if not sorting randomly!")
+if args.mchirp_sort and (args.random_sort or args.random_seed is not None):
+    parser.error("Can't use random sort or random seed if using mchirp sort")
 
 if args.output_filenames is None and args.output_prefix is None:
-    raise RuntimeError("Must specify either output filenames or a prefix!")
+    parser.error("Must specify either output filenames or a prefix!")
 
 if args.output_filenames and args.output_prefix:
-    raise RuntimeError("Can't specify both output filenames and a prefix")
+    parser.error("Can't specify both output filenames and a prefix")
 
 logging.info("Loading bank")
 
@@ -81,6 +82,8 @@ tmplt_bank = bank.TemplateBank(args.bank_file)
 
 templates = tmplt_bank.table
 
+# Apply any sorting if required.
+
 if args.random_sort:
     if args.random_seed is not None:
         random.seed(args.random_seed)
@@ -94,36 +97,32 @@ if args.mchirp_sort:
     templates = templates[mcsort]
     tmplt_bank.table = templates
 
-# Split the templates in the bank taken as input into the smaller banks
+# Decide how many output banks we are going to have.
 
-# If an array of filenames
 if args.output_filenames:
-    args.number_of_banks = len(args.output_filenames)
-
-# If the number of output banks is taken as input calculate the number
-# of templates to be stored per bank
-if args.number_of_banks:
+    num_files = len(args.output_filenames)
+elif args.number_of_banks:
     num_files = args.number_of_banks
-    num_per_file = int(templates[:].size/num_files)
-
-# If the number of templates per bank is taken as input calculate the
-# number of output banks
 elif args.templates_per_bank:
-    num_per_file = args.templates_per_bank
-    num_files = int(templates[:].size / num_per_file)
+    num_files = round(templates[:].size / args.templates_per_bank)
+
+# Calculate the number of templates to be stored per bank. For an even
+# distribution, this must be a float, converted to int later in the loop.
+
+num_per_file = templates[:].size / num_files
+
+if num_per_file < 1:
+    raise ValueError("The user choices imply less than one template per bank")
 
 # Generate sub-banks
+
 logging.info("Generating the output sub-banks")
+start_idx = 0
 for ii in range(num_files):
-    start_idx = ii * num_per_file
-    # The output banks are assigned a fixed length equal to the number
-    # of templates per bank requested by the user or calculated earlier
-    # in the code except for the last bank in which the remaining
-    # templates, if any, are put.
-    if ( ii == (num_files-1)):
+    if ii == (num_files - 1):
         end_idx = templates[:].size
     else:
-        end_idx = (ii + 1) * num_per_file
+        end_idx = int((ii + 1) * num_per_file)
 
     # Assign a name to the h5py output file to store the ii'th smaller bank
     if args.output_filenames:
@@ -142,4 +141,6 @@ for ii in range(num_files):
                                      force=args.force)
     output.close()
 
+    start_idx = end_idx
+
 logging.info("finished")

{PyCBC-2.8.2 → PyCBC-2.8.4}/bin/pycbc_make_sky_grid

@@ -8,7 +8,7 @@ gravitational wave triggers and calculate the coherent SNRs and related
 statistics. 
 
 The grid is constructed following the method described in Section V of
-https://arxiv.org/abs/1410.6042.
+Williamson et al 2014, https://arxiv.org/abs/1410.6042.
 
 Please refer to help(pycbc.types.angle_as_radians) for the recommended
 configuration file syntax for angle arguments.
@@ -84,24 +84,31 @@ def make_multi_det_grid(args):
     ]
     angular_spacing = min(ang_spacings)
 
-    sky_points = np.zeros((1, 2))
+    # The first point is always exactly at the North pole
+    sky_points = [
+        [0, np.pi / 2]
+    ]
 
+    # Generate the sky grid centered at the North pole
     number_of_rings = int(args.sky_error / angular_spacing)
+    for i in range(1, number_of_rings + 1):
+        # Note: Williamson et al 2014 states that the number of points in the
+        # i-th ring is 2πi / x, with x the angular spacing. This is not correct.
+        # In the approximation where the error radius is tiny (i.e. the initial
+        # grid stays close to the North pole) the correct number is 2πi.
+        # However, here we implement the general case, correct over the whole
+        # extent of the polar angle, for which the number is instead
+        # 2π cos(π/2 - ix) / x.
+        polar_angle = np.pi / 2 - i * angular_spacing
+        number_of_points = round(
+            2 * np.pi * np.cos(polar_angle) / angular_spacing
+        )
+        sky_points += [
+            [2 * np.pi * j / number_of_points, polar_angle]
+            for j in range(number_of_points)
+        ]
 
-    # Generate the sky grid centered at the North pole
-    for i in range(number_of_rings + 1):
-        if i == 0:
-            sky_points[0][0] = 0
-            sky_points[0][1] = np.pi / 2
-        else:
-            number_of_points = int(2 * np.pi * i)
-            for j in range(number_of_points):
-                sky_points = np.row_stack(
-                    (
-                        sky_points,
-                        np.array([j / i, np.pi / 2 - i * angular_spacing]),
-                    )
-                )
+    sky_points = np.array(sky_points)
 
     # Convert spherical coordinates to cartesian coordinates
     cart = spher_to_cart(sky_points)

{PyCBC-2.8.2 → PyCBC-2.8.4}/bin/pycbc_multi_inspiral

@@ -50,28 +50,40 @@ from pycbc.vetoes import sgchisq
 from pycbc.tmpltbank.sky_grid import SkyGrid
 
 
-def slide_limiter(args):
+def slide_limiter(n_ifos, slide_shift, segment_length):
     '''
     This function computes the number of shortslides used by the coherent
-    matched filter statistic to obtain as most background triggers as
+    matched filter statistic to obtain as many background triggers as
     possible.
 
     It bounds the number of slides to avoid counting triggers more than once.
     If the data is not time slid, there is a single slide for the zero-lag.
+
+    Parameters
+    ----------
+    n_ifos: int
+        The number of detectors used in the analysis
+    slide_shift: float
+        The shift of each timeslide in seconds
+    segment_length: float
+        The duration of segments in the analysis in seconds
+
+    Returns
+    -------
+    num_slides: int
+        The number of independent timeslides
     '''
-    low, upp = 1, args.segment_length[args.instruments[0]]
-    n_ifos = len(args.instruments)
-    if args.do_shortslides and n_ifos > 1:
-        stride_dur = args.segment_length[args.instruments[0]]/2
-        num_slides = np.int32(1 +
-                              np.floor(stride_dur /
-                                       (args.slide_shift*(n_ifos-1))))
-        assert np.logical_and(num_slides >= low, num_slides <= upp), \
-               "the combination (slideshift, segment_dur)"\
-               f" = ({args.slide_shift:.2f},{stride_dur*2:.2f})"\
-               f" goes over the allowed upper bound {upp}"
-    else:
-        num_slides = 1
+    low, upp = 1, segment_length
+    if n_ifos == 1:
+        return 1
+    stride_dur = segment_length/2
+    num_slides = 1 + int(stride_dur /
+                         (slide_shift*(n_ifos-1)))
+    assert (num_slides >= low) and (num_slides <= upp), \
+           "the combination (slideshift, segment_dur)"\
+           f" = ({slide_shift:.2f},{stride_dur*2:.2f})"\
+           f" goes over the allowed upper bound {upp}"
+
     return num_slides
 
 
@@ -336,18 +348,24 @@ inject.insert_injfilterrejector_option_group_multi_ifo(parser)
 sgchisq.SingleDetSGChisq.insert_option_group(parser)
 args = parser.parse_args()
 init_logging(args.verbose)
-# Setting the number of Shortslides
-num_slides = slide_limiter(args)
+# Setting the number of shortslides
+nifo = len(args.instruments)
+num_slides = 1
+if args.do_shortslides:
+    num_slides = slide_limiter(
+        nifo,
+        args.slide_shift,
+        args.segment_length[args.instruments[0]]
+    )
 # Arrange detectors alphabetically so they are always called in the same order
 args.instruments.sort()
 # Check that the number of IFOs requested to have single SNR above threshold
 # is compatible with the number of detectors in the analysis
-if len(args.instruments) > 1 and \
-   len(args.instruments) < args.nifo_sngl_snr_threshold:
+if nifo > 1 and nifo < args.nifo_sngl_snr_threshold:
     parser.error("--nifo-sngl-snr-threshold "
                  f"({args.nifo_sngl_snr_threshold}) cannot exceed the "
                  "number of detectors in the analysis "
-                 f"({len(args.instruments)}) because this would "
+                 f"({nifo}) because this would "
                  "never yield any trigger.")
 # Use class verification methods to check whether input CLI options provided
 # by parser to pycbc.strain, pycbc.strain.StrainSegments, pycbc.psd,
@@ -382,7 +400,6 @@ with ctx:
     fft.from_cli(args)
     # Set some convenience variables: number of IFOs, lower frequency,
     # GRB time, sky positions to search (either a grid or single sky point)
-    nifo = len(args.instruments[:])
     flow = args.low_frequency_cutoff
     t_gps = args.trigger_time
     sky_positions = SkyGrid.from_cli(parser, args)
@@ -545,7 +562,7 @@ with ctx:
         'bank_chisq': None,
         'bank_chisq_dof': None,
         'auto_chisq': None,
-        'auto_chisq_dof': int,
+        'auto_chisq_dof': None,
         'slide_id': None,
     }
     ifo_names = sorted(ifo_out_vals.keys())
@@ -571,7 +588,7 @@ with ctx:
         'reweighted_snr': None,
         'slide_id': None,
     }
-    network_names = sorted(network_out_vals.keys())
+    network_names = network_out_vals.keys()
     event_mgr = EventManagerCoherent(
         args,
         args.instruments,
@@ -624,7 +641,7 @@ with ctx:
                 if not inj_filter_rejector[ifo].template_segment_checker(
                     bank, t_num, stilde[ifo]
                 ):
-                    logging.info(
+                    logging.debug(
                         "Skipping segment %d/%d with template %d/%d as no "
                         "detectable injection is present",
                         s_num + 1,
@@ -648,7 +665,11 @@ with ctx:
             if not analyse_segment:
                 continue
             logging.info(
-                "Analyzing segment %d/%d", s_num + 1, len(segments[ifo])
+                "Analyzing template %d/%d, segment %d/%d",
+                t_num + 1,
+                n_bank,
+                s_num + 1,
+                len(segments[ifo])
             )
             # The following dicts with IFOs as keys are created to store
             # copies of the matched filtering results computed below.
@@ -663,8 +684,12 @@ with ctx:
             idx = dict.fromkeys(args.instruments)
             # - The list of normalized SNR values at the trigger locations
             snr = dict.fromkeys(args.instruments)
+            # - Cache for power chi^2 and corresponding DoF for each time sample.
+            #   Typically only a tiny fraction will be populated.
+            power_chisq_arrays = dict.fromkeys(args.instruments)
+            power_chisq_dof_arrays = dict.fromkeys(args.instruments)
             for ifo in args.instruments:
-                logging.info(
+                logging.debug(
                     "Filtering template %d/%d, ifo %s", t_num + 1, n_bank, ifo
                 )
                 # The following lines unpack and store copies of the matched
@@ -688,6 +713,14 @@ with ctx:
                 # or negative
                 idx[ifo] = ind.astype(np.int32)
                 snr[ifo] = snrv * norm
+                # Initialize the cache for power chi^2
+                power_chisq_arrays[ifo] = np.full(
+                    len(snr_dict[ifo]), np.nan, dtype=np.float32
+                )
+                power_chisq_dof_arrays[ifo] = np.zeros(
+                    len(snr_dict[ifo]), dtype=np.int32
+                )
+                del snr_ts, norm, corr, ind, snrv
 
             # Move onto next segment if there are no triggers.
             n_trigs = [len(snr[ifo]) for ifo in args.instruments]
@@ -696,10 +729,10 @@ with ctx:
 
             # Loop over (short) time-slides, starting with the zero-lag
             for slide in range(num_slides):
-                logging.info("Analyzing slide %d/%d", slide, num_slides)
+                logging.debug("Analyzing slide %d/%d", slide, num_slides)
                 # Loop over sky positions
                 for position_index in range(len(sky_positions)):
-                    logging.info(
+                    logging.debug(
                         "Analyzing sky position %d/%d",
                         position_index + 1,
                         len(sky_positions),
@@ -710,7 +743,8 @@ with ctx:
                     # Indices are kept only if they do not get time shifted
                     # out of the time we are looking at, i.e., require
                     # idx[ifo] - time_delay_idx[slide][position_index][ifo]
-                    # to be in (0, len(snr_dict[ifo]))
+                    # (which applies the necessary time shift by operating on
+                    # indices) to be between 0 and len(snr_dict[ifo]).
                     idx_dict = {
                         ifo: idx[ifo][
                             np.logical_and(
@@ -723,28 +757,27 @@ with ctx:
                         ]
                         for ifo in args.instruments
                     }
-                    # Find triggers that are coincident (in geocent time) in
-                    # multiple IFOs. If a single IFO analysis then just use the
-                    # indices from that IFO, i.e., IFO 0; otherwise, this
-                    # method finds coincidences and applies the single IFO cut,
-                    # namely, triggers must have SNR >= args.sngl_snr_threshold
-                    # in at least args.nifo_sngl_snr_threshold IFOs.
-                    if nifo > 1:
-                        coinc_idx = coh.get_coinc_indexes(
-                            idx_dict, time_delay_idx[slide][position_index],
-                            args.nifo_sngl_snr_threshold
-                        )
-                    else:
-                        coinc_idx = (
-                            idx_dict[args.instruments[0]]
-                            - time_delay_idx[slide][position_index][
-                                args.instruments[0]
-                            ]
-                        )
-                    logging.info(
+                    # Find indexes (related to geocenter time) of triggers that
+                    # are coincident (in geocenter time) in multiple IFOs.
+                    # This is done by calling the method that finds coincidences
+                    # and applies the single IFO SNR cut asking for triggers to
+                    # have SNR >= args.sngl_snr_threshold in at least
+                    # args.nifo_sngl_snr_threshold IFOs; recall that idx_dict
+                    # tracks (at the geocent) triggers above threshold in
+                    # individual detectors. If only one IFO is available, then
+                    # the method returns trigger indices for that IFO. Given
+                    # that we are looping over timeslides and sky positions,
+                    # the appropriate dictionary of time delays wrt the
+                    # geocenter must be passed to operate at the geocenter.
+                    coinc_idx = coh.get_coinc_indexes(
+                        idx_dict, time_delay_idx[slide][position_index],
+                        args.nifo_sngl_snr_threshold
+                    )
+                    logging.debug(
                         "Found %d coincident triggers", len(coinc_idx)
                     )
-                    # Time delay is applied to indices to have them at the IFOs
+                    # Time delay is applied to indices at the geocenter to have
+                    # them at the IFOs (hence the + which undoes the delay).
                     coinc_idx_det_frame = {
                         ifo: (
                             coinc_idx
@@ -753,9 +786,16 @@ with ctx:
                         % len(snr_dict[ifo])
                         for ifo in args.instruments
                     }
-                    # Calculate the coincident and coherent SNR.
-                    # First check there is enough data to compute the SNRs.
-                    if len(coinc_idx) != 0 and nifo > 1:
+                    # Calculate the quadrature sum of individual detector SNRs,
+                    # regardless of how many IFOs are available.
+                    # This accounts for a coherent SNR component and an
+                    # incoherent one.  It is referred to as coincident SNR
+                    # throughout the code, even in the single IFO case.
+                    # The calculation is performed only if triggers were
+                    # gathered so far. Once again, the appropriate dictionary
+                    # of time delays wrt the geocenter must be passed to
+                    # operate at the geocenter.
+                    if len(coinc_idx) != 0:
                         # Find coinc SNR at trigger times and apply coinc SNR
                         # threshold (which depopulates coinc_idx accordingly)
                         (
@@ -768,32 +808,24 @@ with ctx:
                             args.coinc_threshold,
                             time_delay_idx[slide][position_index],
                         )
-                        logging.info(
+                        logging.debug(
                             "%d triggers above coincident SNR threshold",
                             len(coinc_idx),
                         )
                         if len(coinc_idx) != 0:
-                            logging.info(
+                            logging.debug(
                                 "With max coincident SNR = %.2f",
                                 max(rho_coinc),
                             )
-                    # If there is only one IFO, just take its triggers
-                    # and their SNRs
-                    elif len(coinc_idx) != 0 and nifo == 1:
-                        coinc_triggers = {
-                            args.instruments[0]: snr_dict[args.instruments[0]][
-                                coinc_idx_det_frame[args.instruments[0]]
-                            ]
-                        }
                     else:
                         coinc_triggers = {}
-                        logging.info("No coincident triggers were found")
+                        logging.debug("No coincident triggers were found")
                     # If there are triggers above coinc threshold and more
-                    # than 2 IFOs, then calculate the coherent statistics for
+                    # than 1 IFO, then calculate the coherent statistics for
                     # them and apply the cut on coherent SNR (with threshold
                     # equal to the coinc SNR one)
-                    if len(coinc_idx) != 0 and nifo > 2:
-                        logging.info("Calculating their coherent statistics")
+                    if len(coinc_idx) != 0 and nifo > 1:
+                        logging.debug("Calculating their coherent statistics")
                         # Plus and cross antenna pattern dictionaries
                         fp = {
                             ifo: antenna_pattern[ifo][position_index][0]
@@ -893,12 +925,12 @@ with ctx:
                                 project,
                                 rho_coinc,
                             )
-                        logging.info(
+                        logging.debug(
                             "%d triggers above coherent SNR threshold",
                             len(rho_coh),
                         )
                         if len(coinc_idx) != 0:
-                            logging.info(
+                            logging.debug(
                                 "With max coherent SNR = %.2f", max(rho_coh)
                             )
                             # Calculate the null SNR and apply the null SNR cut
@@ -918,11 +950,11 @@ with ctx:
                                 snrv=coinc_triggers,
                                 index=coinc_idx,
                             )
-                            logging.info(
+                            logging.debug(
                                 "%d triggers above null threshold", len(null)
                             )
                             if len(coinc_idx) != 0:
-                                logging.info(
+                                logging.debug(
                                     "With max null SNR = %.2f", max(null)
                                 )
                     # Now calculate the individual detector chi2 values
@@ -932,7 +964,9 @@ with ctx:
                     # (surviving) triggers in the detector frame.
                     if len(coinc_idx) != 0:
                         # Updated coinc_idx_det_frame to account for the
-                        # effect of the cuts applied to far
+                        # effect of the cuts applied so far (operate on the
+                        # time related indices with a +time_delay_idx to
+                        # transform geocenter time to IFO time).
                         coinc_idx_det_frame = {
                             ifo: (
                                 coinc_idx
@@ -953,21 +987,34 @@ with ctx:
                         chisq = {}
                         chisq_dof = {}
                         for ifo in args.instruments:
-                            chisq[ifo], chisq_dof[ifo] = power_chisq.values(
-                                corr_dict[ifo],
-                                coherent_ifo_trigs[ifo] / norm_dict[ifo],
-                                norm_dict[ifo],
-                                stilde[ifo].psd,
-                                coinc_idx_det_frame[ifo]
-                                + stilde[ifo].analyze.start,
-                                template,
+                            # Figure out which new indices we need to calculate
+                            # the chi^2 for
+                            needed_idx = coinc_idx_det_frame[ifo]
+                            unavailable_mask = np.isnan(
+                                power_chisq_arrays[ifo][needed_idx]
                             )
+                            if unavailable_mask.any():
+                                new_needed_idx = needed_idx[unavailable_mask]
+                                new_chisq, new_chisq_dof = power_chisq.values(
+                                    corr_dict[ifo],
+                                    snr_dict[ifo][new_needed_idx] / norm_dict[ifo],
+                                    norm_dict[ifo],
+                                    stilde[ifo].psd,
+                                    new_needed_idx + stilde[ifo].analyze.start,
+                                    template,
+                                )
+                                power_chisq_arrays[ifo][new_needed_idx] = new_chisq
+                                power_chisq_dof_arrays[ifo][new_needed_idx] = new_chisq_dof
+                                del new_chisq, new_chisq_dof, new_needed_idx
+                            chisq[ifo] = power_chisq_arrays[ifo][needed_idx]
+                            chisq_dof[ifo] = power_chisq_dof_arrays[ifo][needed_idx]
+                            del needed_idx, unavailable_mask
                         # Calculate network chisq value
                         network_chisq_dict = coh.network_chisq(
                             chisq, chisq_dof, coherent_ifo_trigs
                         )
                         # Calculate chisq reweighted SNR
-                        if nifo > 2:
+                        if nifo > 1:
                             reweighted_snr = ranking.newsnr(
                                 rho_coh,
                                 network_chisq_dict,
@@ -983,13 +1030,6 @@ with ctx:
                                 null_grad=args.null_grad,
                                 null_step=args.null_step,
                             )
-                        elif nifo == 2:
-                            reweighted_snr = ranking.newsnr(
-                                rho_coinc,
-                                network_chisq_dict,
-                                q=args.chisq_index,
-                                n=args.chisq_nhigh,
-                            )
                         else:
                             rho_sngl = abs(
                                 snr_dict[args.instruments[0]][
@@ -1015,8 +1055,8 @@ with ctx:
                                 template,
                                 stilde[ifo].psd,
                                 stilde[ifo],
-                                coherent_ifo_trigs[ifo] / norm_dict[ifo],
-                                norm_dict[ifo],
+                                coherent_ifo_trigs[ifo],
+                                1,  # coherent_ifo_trigs already normalized
                                 coinc_idx_det_frame[ifo]
                                 + stilde[ifo].analyze.start,
                             )
@@ -1024,11 +1064,11 @@ with ctx:
                                 ifo_out_vals['auto_chisq'],
                                 ifo_out_vals['auto_chisq_dof'],
                             ) = autochisq.values(
-                                snr_dict[ifo] / norm_dict[ifo],
+                                snr_dict[ifo],
                                 coinc_idx_det_frame[ifo],
                                 template,
                                 stilde[ifo].psd,
-                                norm_dict[ifo],
+                                1,  # snr_dict already normalized
                                 stilde=stilde[ifo],
                                 low_frequency_cutoff=flow,
                             )
@@ -1050,11 +1090,9 @@ with ctx:
                                 ifo_names,
                                 [ifo_out_vals[n] for n in ifo_names],
                             )
-                        if nifo > 2:
+                        if nifo > 1:
                             network_out_vals['coherent_snr'] = rho_coh
                             network_out_vals['null_snr'] = null
-                        elif nifo == 2:
-                            network_out_vals['coherent_snr'] = rho_coinc
                         else:
                             network_out_vals['coherent_snr'] = abs(
                                 snr_dict[args.instruments[0]][
@@ -1089,7 +1127,7 @@ with ctx:
                 cluster_window = int(template.chirp_length * sample_rate)
             # Cluster template events by slide
             for slide in range(num_slides):
-                logging.info("Clustering slide %d", slide)
+                logging.debug("Clustering slide %d", slide)
                 event_mgr.cluster_template_network_events(
                     'time_index', 'reweighted_snr', cluster_window, slide=slide
                 )