Remove old banksim/faithsim workflows add documentation/tests for new ones

.github/workflows/faithsim-bank-verifier-workflow.yml

@@ -0,0 +1,80 @@
+name: run small faithsim and bank verifier workflows using pegasus + condor
+
+on: [push, pull_request]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+    steps:
+    - uses: actions/checkout@v5
+    - name: Set up Python
+      uses: actions/setup-python@v6
+      with:
+        python-version: '3.11'
+    - name: install condor
+      run: |
+        wget -qO - https://research.cs.wisc.edu/htcondor/ubuntu/HTCondor-Release.gpg.key | sudo apt-key add -
+        echo "deb http://research.cs.wisc.edu/htcondor/ubuntu/8.9/focal focal contrib" | sudo tee -a /etc/apt/sources.list
+        echo "deb-src http://research.cs.wisc.edu/htcondor/ubuntu/8.9/focal focal contrib" | sudo tee -a /etc/apt/sources.list
+        sudo apt-get -o Acquire::Retries=3 update
+        sudo apt-get -o Acquire::Retries=3 install minihtcondor
+        sudo systemctl start condor
+        sudo systemctl enable condor
+    - name: install pegasus
+      run: |
+        wget -qO - https://download.pegasus.isi.edu/pegasus/gpg.txt | sudo apt-key add -
+        echo "deb https://download.pegasus.isi.edu/pegasus/ubuntu noble main" | sudo tee -a /etc/apt/sources.list
+        sudo apt-get -o Acquire::Retries=3 update
+        sudo apt-get -o Acquire::Retries=3 install pegasus=5.1.1-1+ubuntu24
+    - run: sudo apt-get -o Acquire::Retries=3 install *fftw3* intel-mkl*
+    - name: Install pycbc
+      run: |
+        python -m pip install --upgrade pip setuptools
+        pip install GitPython # This shouldn't really be needed!
+        pip install -r requirements.txt
+        pip install .
+    - name: generating, submitting and running faithsim workflow
+      env:
+          _CONDOR_DAGMAN_USE_STRICT: "0"
+      run: |
+        cp examples/faith/faithsim_workflow_config.ini ./
+        cp examples/faith/injection_priors.ini ./
+        bash -e examples/faith/run_workflow.sh
+        condor_status
+        cd output
+        ./status
+        python ../examples/search/check_job.py
+        find submitdir/work/ -type f -name '*.tar.gz' -delete
+        cd ..
+        mv output output_faithsim
+    - name: store faithsim log files
+      if: always()
+      uses: actions/upload-artifact@v7
+      with:
+        name: faithsim-logs
+        path: output_faithsim/submitdir/work
+    - name: generating, submitting and running bank verifier workflow
+      env:
+          _CONDOR_DAGMAN_USE_STRICT: "0"
+      run: |
+        cp examples/banksim/bank_verifier_config.ini ./
+        cp examples/banksim/injection_priors.ini ./
+        cp examples/banksim/bank0.hdf ./
+        bash -e examples/banksim/run_verifier.sh
+        condor_status
+        cd output
+        ./status
+        python ../examples/search/check_job.py
+        find submitdir/work/ -type f -name '*.tar.gz' -delete
+        cd ..
+        mv output output_bank_verifier
+    - name: store bank verifier log files
+      if: always()
+      uses: actions/upload-artifact@v7
+      with:
+        name: bank-verifier-logs
+        path: output_bank_verifier/submitdir/work

bin/pycbc_banksim

@@ -23,17 +23,14 @@ from numpy import complex64, array
 from argparse import ArgumentParser
 from math import ceil, log
 
-from igwn_ligolw import utils as ligolw_utils
-from igwn_ligolw import lsctables
-
 from pycbc.pnutils import mass1_mass2_to_mchirp_eta
 from pycbc.pnutils import mass1_mass2_to_tau0_tau3
 from pycbc.pnutils import nearest_larger_binary_number
 from pycbc.waveform import get_td_waveform, get_fd_waveform, td_approximants, fd_approximants
 from pycbc import DYN_RANGE_FAC
 from pycbc.types import FrequencySeries, TimeSeries, zeros, complex_same_precision_as
 from pycbc.filter import match, sigmasq
-from pycbc.io.ligolw import LIGOLWContentHandler
+from pycbc.inject import read_injection_table
 import pycbc.psd, pycbc.scheme, pycbc.fft, pycbc.strain
 from pycbc.detector import overhead_antenna_pattern as generate_fplus_fcross
 from pycbc.waveform import TemplateBank
@@ -133,16 +130,29 @@ def get_waveform(approximant, phase_order, amplitude_order, spin_order,
                                  f_lower=start_frequency,
                                  amplitude_order=amplitude_order)
         if hasattr(wf_params, 'taper'):
-            hp = hp.taper_timeseries(location=wf_params.taper, 
-                                     tapermethod=wf_params.get('taper_method', 'lal'), 
-                                     taper_window=wf_params.get('taper_window'))
-            hc = hc.taper_timeseries(location=wf_params.taper, 
-                                     tapermethod=wf_params.get('taper_method', 'lal'), 
-                                     taper_window=wf_params.get('taper_window'))
+            hp = hp.taper_timeseries(location=wf_params.taper,
+                                     tapermethod=getattr(wf_params, 'taper_method', 'lal'),
+                                     taper_window=getattr(wf_params, 'taper_window', None))
+            hc = hc.taper_timeseries(location=wf_params.taper,
+                                     tapermethod=getattr(wf_params, 'taper_method', 'lal'),
+                                     taper_window=getattr(wf_params, 'taper_window', None))
         hvec = generate_detector_strain(wf_params, hp, hc)
 
     return make_padded_frequency_series(hvec, filter_N, delta_f=delta_f)
 
+def describe_waveform_params(wf_params, approximant):
+    """Return a human-readable description of the parameters used to
+    generate a waveform, for use in error logging when generation fails.
+    """
+    fields = ['mass1', 'mass2', 'spin1x', 'spin1y', 'spin1z',
+             'spin2x', 'spin2y', 'spin2z', 'inclination', 'f_lower']
+    parts = ['approximant=%s' % approximant]
+    for field in fields:
+        if hasattr(wf_params, field):
+            parts.append('%s=%s' % (field, getattr(wf_params, field)))
+    return ', '.join(parts)
+
+
 aprs = sorted(list(set(td_approximants() + fd_approximants())))
 
 #File output Settings
@@ -175,8 +185,10 @@ parser.add_argument("--template-sample-rate", type=float,
 
 #Signal Settings
 parser.add_argument("--signal-file", dest="sim_file", metavar="FILE",
-                    required=True, help="SimInspiral or SnglInspiral XML file "
-                                        "containing the signal parameters")
+                    required=True, help="File specifying the signal "
+                                        "parameters, either in HDF or as a "
+                                        "SimInspiral or SnglInspiral LIGOLW "
+                                        "XML file.")
 parser.add_argument("--signal-approximant", choices=aprs, required=True,
                     help="Waveform approximant for signals")
 parser.add_argument("--signal-phase-order", default=-1, type=int,
@@ -288,12 +300,7 @@ template_table = temp_bank.table
 logging.info("  %d templates", len(template_table))
 
 logging.info('Reading simulation list')
-indoc = ligolw_utils.load_filename(options.sim_file, False,
-                                   contenthandler=LIGOLWContentHandler)
-try:
-    signal_table = lsctables.SimInspiralTable.get_table(indoc)
-except ValueError:
-    signal_table = lsctables.SnglInspiralTable.get_table(indoc)
+signal_table = read_injection_table(options.sim_file)
 logging.info("  %d signal waveforms", len(signal_table))
 
 logging.info("Matches will be written to %s", options.out_file)
@@ -323,14 +330,21 @@ with ctx:
         if not options.use_sky_location and hasattr(signal_params, 'latitude'):
             signal_params.latitude = 0.
             signal_params.longitude = 0.
-        stilde = get_waveform(options.signal_approximant,
-                              options.signal_phase_order,
-                              options.signal_amplitude_order,
-                              options.signal_spin_order,
-                              signal_params,
-                              options.signal_start_frequency,
-                              signal_sample_rate,
-                              filter_N, options.filter_sample_rate)
+        try:
+            stilde = get_waveform(options.signal_approximant,
+                                  options.signal_phase_order,
+                                  options.signal_amplitude_order,
+                                  options.signal_spin_order,
+                                  signal_params,
+                                  options.signal_start_frequency,
+                                  signal_sample_rate,
+                                  filter_N, options.filter_sample_rate)
+        except Exception:
+            logging.error("Failed to generate signal waveform %d: %s",
+                         index,
+                         describe_waveform_params(signal_params,
+                                                  options.signal_approximant))
+            raise
         s_norm = sigmasq(stilde, psd=psd,
                          low_frequency_cutoff=options.filter_low_frequency_cutoff)
         stilde /= psd
@@ -396,14 +410,22 @@ with ctx:
                     if options.total_mass_divide is not None and (template_params.mass1+template_params.mass2) >= options.total_mass_divide:
                         this_approximant = options.highmass_approximant
 
-                htilde = get_waveform(this_approximant,
-                                      options.template_phase_order,
-                                      options.template_amplitude_order,
-                                      options.template_spin_order,
-                                      template_params,
-                                      options.template_start_frequency,
-                                      template_sample_rate,
-                                      filter_N, options.filter_sample_rate)
+                try:
+                    htilde = get_waveform(this_approximant,
+                                          options.template_phase_order,
+                                          options.template_amplitude_order,
+                                          options.template_spin_order,
+                                          template_params,
+                                          options.template_start_frequency,
+                                          template_sample_rate,
+                                          filter_N, options.filter_sample_rate)
+                except Exception:
+                    logging.error(
+                        "Failed to generate template waveform %d: %s",
+                        index,
+                        describe_waveform_params(template_params,
+                                                 this_approximant))
+                    raise
 
                 h_norm = sigmasq(htilde, psd=psd, low_frequency_cutoff=f_lower)
 

bin/pycbc_banksim_match_combine

@@ -25,13 +25,11 @@ bank files, and the number of injections in each must correspond one-to-one.
 import argparse
 import numpy as np
 
-from igwn_ligolw import utils, ligolw
-
 import pycbc
 from pycbc import pnutils
 from pycbc.waveform import TemplateBank
-from pycbc.io.ligolw import LIGOLWContentHandler
 from pycbc.io.hdf import HFile
+from pycbc.inject import read_injection_table
 from pycbc import load_source
 
 __author__  = "Ian Harry <ian.harry@astro.cf.ac.uk>"
@@ -109,9 +107,9 @@ for idx, row in enumerate(res):
         btables[row['bank']] = temp_bank.table
 
     if row['sim'] not in itables:
-        indoc = utils.load_filename(row['sim'], False,
-                                    contenthandler=LIGOLWContentHandler)
-        itables[row['sim']] = ligolw.Table.get_table(indoc, "sim_inspiral") 
+        itables[row['sim']] = read_injection_table(
+            row['sim'], xml_tables=('sim_inspiral',)
+        )
 
     bt = btables[row['bank']][row['bank_i']]     
     it = itables[row['sim']][row['sim_i']]
@@ -126,7 +124,13 @@ for idx, row in enumerate(res):
             # For example spin1x is not always stored in aligned-spin banks
             bank_params[val][idx] = 0.
     for val in inj_par_list:
-        inj_params[val][idx] = getattr(it, val)
+        try:
+            inj_params[val][idx] = getattr(it, val)
+        except AttributeError:
+            # If not present set to 0.
+            # For example spin1x is not always stored for aligned-spin
+            # injection sets.
+            inj_params[val][idx] = 0.
 
 for val in bank_par_list:
     f['bank_params/{}'.format(val)] = bank_params[val] 

bin/pycbc_faithsim

@@ -28,9 +28,6 @@ from numpy import complex64
 import argparse
 import sys
 
-from igwn_ligolw import utils as ligolw_utils
-from igwn_ligolw import lsctables
-
 import pycbc.strain
 import pycbc.psd
 from pycbc.waveform import td_approximants, fd_approximants
@@ -39,7 +36,8 @@ from pycbc import DYN_RANGE_FAC
 from pycbc.types import FrequencySeries, zeros
 from pycbc.filter import match, overlap, sigma
 from pycbc.scheme import CPUScheme, CUDAScheme
-from pycbc.io.ligolw import LIGOLWContentHandler
+from pycbc.inject import read_injection_table
+
 
 def update_progress(progress):
     print('Progress: {}/{} members processed'.format(progress, 100))
@@ -84,8 +82,9 @@ parser = argparse.ArgumentParser(usage='',
     description="Calculate faithfulness for a set of waveforms.")
 pycbc.add_common_pycbc_options(parser)
 parser.add_argument("--param-file", dest="bank_file", metavar="FILE",
-                    help="Sngl or Sim Inspiral Table containing waveform "
-                         "parameters.")
+                    help="File specifying the waveform parameters, either "
+                         "in HDF or as a Sngl or Sim Inspiral Table LIGOLW "
+                         "XML file.")
 parser.add_argument("--match-file", dest="out_file", metavar="FILE",
                     help="File to output match results to.")
 
@@ -155,13 +154,12 @@ if options.cuda:
 else:
     ctx = CPUScheme()
 
-# Load in the waveform1 bank file
-indoc = ligolw_utils.load_filename(options.bank_file, False,
-                                   contenthandler=LIGOLWContentHandler)
-try :
-    waveform_table = lsctables.SnglInspiralTable.get_table(indoc)
-except ValueError:
-    waveform_table = lsctables.SimInspiralTable.get_table(indoc)
+# Load in the waveform parameter file. XML files are tried as a template
+# bank (sngl_inspiral) first, then as injections (sim_inspiral), since
+# --param-file is more often a bank in this script.
+waveform_table = read_injection_table(
+    options.bank_file, xml_tables=('sngl_inspiral', 'sim_inspiral')
+)
 
 # open the output file where the max overlaps over the bank are stored 
 fout = open(options.out_file, "w")

bin/pycbc_faithsim_collect_results

@@ -8,10 +8,8 @@ computing the match between them and creating a .dat file with the results.
 import argparse
 import numpy as np
 
-from igwn_ligolw import utils, lsctables
-
 from pycbc import add_common_pycbc_options, init_logging
-from pycbc.io.ligolw import LIGOLWContentHandler
+from pycbc.inject import read_injection_table, get_table_column
 
 parser = argparse.ArgumentParser(description=__doc__)
 add_common_pycbc_options(parser)
@@ -30,7 +28,7 @@ parser.add_argument(
 parser.add_argument("--output", required=True, help="name of the output .dat file")
 args = parser.parse_args()
 
-init_logging(options.verbose)
+init_logging(args.verbose)
 
 mfields = ("match", "overlap", "time_offset", "sigma1", "sigma2")
 bfields = (
@@ -82,16 +80,15 @@ dtypeo = {
 }
 
 btables = {}
-match_files = args.inputs_match[:]
-bank_files = args.inputs_bank[:]
+match_files = args.match_inputs[:]
+bank_files = args.bank_inputs[:]
 data = np.zeros(0, dtype=dtypeo)
 
 for i in range(len(match_files)):
     match = match_files[i]
     bname = bank_files[i]
     if bname not in btables:
-        indoc = utils.load_filename(bname, False, contenthandler=LIGOLWContentHandler)
-        btables[bname] = lsctables.SimInspiralTable.get_table(indoc)
+        btables[bname] = read_injection_table(bname)
     bt = btables[bname]
     try:
         md = np.loadtxt(match, dtype=dtypem)
@@ -106,7 +103,7 @@ for i in range(len(match_files)):
 
     for field in bfields:
         if field not in mfields:
-            pdata[field] = bt.getColumnByName(field).asarray()
+            pdata[field] = get_table_column(bt, field)
 
     data = np.append(data, pdata)