lalsuite 7.22.1.dev20240408__cp312-cp312-manylinux_2_28_aarch64.whl → 7.26.2.dev20251202__cp312-cp312-manylinux_2_28_aarch64.whl

lalpulsar/knope_utils.py

@@ -14,21 +14,20 @@ __version__ = "$Revision$"
 
 import os
 import re
-from glue import pipeline
+from lal import pipeline
 import sys
 import ast
 import json
 import subprocess as sp
 import shutil
 import uuid
-from six.moves.configparser import RawConfigParser
-import six.moves.urllib.parse as urlparse
+from configparser import RawConfigParser
+import urllib.parse as urlparse
 from copy import deepcopy
 import numpy as np
 import pickle
 from scipy import optimize
 from collections import OrderedDict
-from six import string_types
 from lalpulsar import pulsarpputils as pppu
 
 # set some specific error codes and messages
@@ -3153,7 +3152,7 @@ class knopeDAG(pipeline.CondorDAG):
                 self.error_code = KNOPE_ERROR_GENERAL
                 return
             else:
-                if isinstance(self.coarse_heterodyne_channels[ifo], string_types):
+                if isinstance(self.coarse_heterodyne_channels[ifo], str):
                     # convert to list
                     self.coarse_heterodyne_channels[ifo] = [
                         self.coarse_heterodyne_channels[ifo]
@@ -4578,7 +4577,7 @@ class knopeDAG(pipeline.CondorDAG):
                 self.error_code = KNOPE_ERROR_GENERAL
                 return
             else:
-                if isinstance(frtypes[ifo], string_types):
+                if isinstance(frtypes[ifo], str):
                     for i in range(self.ndatasets[ifo]):
                         frtypelist.append(frtypes[ifo])
                 elif isinstance(frtypes[ifo], list):
@@ -4765,7 +4764,7 @@ class knopeDAG(pipeline.CondorDAG):
         for st, et in zip(sts, ets):
             # check whether there are different segment types for the different times
             if isinstance(segmenttypes[ifo], list):
-                if not isinstance(segmenttypes[ifo][sidx], string_types):
+                if not isinstance(segmenttypes[ifo][sidx], str):
                     print("Error... segment types must be a string")
                     self.error_code = KNOPE_ERROR_GENERAL
                     return
@@ -4778,7 +4777,7 @@ class knopeDAG(pipeline.CondorDAG):
                 else:
                     segmenttype = segmenttypes[ifo][sidx]
             else:
-                if not isinstance(segmenttypes[ifo], string_types):
+                if not isinstance(segmenttypes[ifo], str):
                     print("Error... segment types must be a string")
                     self.error_code = KNOPE_ERROR_GENERAL
                     return
@@ -4801,7 +4800,7 @@ class knopeDAG(pipeline.CondorDAG):
                     # check whether there are different exclusion types for the different times
                     if ifo in excludesegs:
                         if isinstance(excludesegs[ifo], list):
-                            if not isinstance(excludesegs[ifo][sidx], string_types):
+                            if not isinstance(excludesegs[ifo][sidx], str):
                                 print("Error... exclude types must be a string")
                                 self.error_code = KNOPE_ERROR_GENERAL
                                 return
@@ -4814,7 +4813,7 @@ class knopeDAG(pipeline.CondorDAG):
                             else:
                                 excludetype = excludesegs[ifo][sidx]
                         else:
-                            if not isinstance(excludesegs[ifo], string_types):
+                            if not isinstance(excludesegs[ifo], str):
                                 print("Error... exclude types must be a string")
                                 self.error_code = KNOPE_ERROR_GENERAL
                                 return

lalpulsar/piecewise_model/__init__.py

@@ -0,0 +1,7 @@
+## \defgroup lalpulsar_python_piecewise_model Piecewise Model
+## \ingroup lalpulsar_python
+"""
+Piecewise model code used by lalpulsar_PiecewiseSearch.py
+"""
+
+# Empty comment to make sure filter_py.py outputs all documentation

lalpulsar/piecewise_model/basis_functions.py

@@ -0,0 +1,156 @@
+# Copyright (C) 2019--2023 Benjamin Grace
+#
+# 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.
+
+## \file
+## \ingroup lalpulsar_python_piecewise_model
+"""
+Build the methods required for creating the basis functions of our piecewise model.
+"""
+
+import logging
+
+import numpy as np
+
+# It is worth noting here that initially conditioning of the matrices used here
+# was undertaken. Initially this was necessary as when plotting the basis
+# functions all that was returned was numerical fuzz, however many months after
+# having written these methods, I cannot recover this behaviour and the
+# conditioning used here seems to increase the condition number of the matrices
+# built here. For now the conditioning methods in this module have been
+# commented out until a later time, however for now without conditioning the
+# results produced appear to be returned accurately despite the
+# ill-conditionedness of the problem.
+
+knotslist = [0.0]
+
+# Returns the value of the ith knot. If we are using the methods in the estimating_knots module, this method should
+# simply extract the ith element from the knotslist variable above.
+def p(i):
+
+    return knotslist[i]
+
+
+# Our basis function
+def u(t, i):
+    return (t - p(i)) / (p(i + 1) - p(i))
+
+
+# Builds the W matrix whose inverse is the coefficients of our basis function
+def w(i, s):
+    try:
+        from sympy import Symbol, diff, lambdify
+    except:
+        raise ImportError("Cannot import sympy")
+
+    t = Symbol("t")
+
+    ps = p(i)
+    pe = p(i + 1)
+
+    matrixupper = []
+    matrixlower = []
+
+    thisrowderivs = [u(t, i) ** m for m in range(2 * s)]
+
+    for row in range(s):
+
+        if row != 0:
+            for j, elem in enumerate(thisrowderivs):
+                thisrowderivs[j] = diff(elem, t, 1)
+
+        thisrows = []
+        thisrowe = []
+
+        for elem in thisrowderivs:
+            thiselem = lambdify(t, elem, "numpy")
+
+            thisrows.append(thiselem(ps))
+            thisrowe.append(thiselem(pe))
+
+        matrixupper.append(thisrows)
+        matrixlower.append(thisrowe)
+
+    return np.array(matrixupper + matrixlower)
+
+
+# Returns the pseudo inverse of a list to the given power
+def listpseudoinv(lst, pwr=1):
+    invlist = []
+
+    for elem in lst:
+        if elem != 0:
+            invlist.append(elem**-pwr)
+        else:
+            invlist.append(0)
+
+    return invlist
+
+
+# Builds a diagonal matrix with elements equal to the inverse of the diagonal elements of the given matrix
+def d(mat):
+    return np.diag(listpseudoinv(np.diagonal(mat)))
+
+
+# Returns the coefficients of our basis function in a 3D list. Reference elements by [ B or C ][ k ][ specific coeff ]
+def basiscoeffs(i, s, conditioning=True):
+    wmat = w(i, s)
+
+    if conditioning:
+        dmat = d(wmat)
+        dwmat = np.matmul(dmat, wmat)
+
+    else:
+        dmat = np.identity(len(wmat))
+        dwmat = wmat
+
+    try:
+        coeffs = np.transpose(np.linalg.solve(dwmat, dmat))
+    except np.linalg.LinAlgError as error:
+        logging.error(error)
+        logging.error(
+            "Error in calculating basis functions. Using Python LSTSQ method instead"
+        )
+        coeffs = np.linalg.lstsq(dwmat, dmat)[0]
+
+    blist = coeffs[0:s]
+    clist = coeffs[s : 2 * s]
+
+    return np.array([blist, clist])
+
+
+# Returns the coefficients of all basis functions in a 4D list. Reference elements by [ int ][ B or C][ k ][ specific
+# coeff ]
+def allcoeffs(s):
+    coeffs = [basiscoeffs(i, s) for i in range(len(knotslist) - 1)]
+
+    return np.array(coeffs)
+
+
+# allcoeffs(3, 10, 10000)
+
+# Returns the value of a specified basis function given the 4D list of coefficients coeffs.
+def basisfunctionvalue(t, i, borc, s, coeffs):
+    val = 0
+
+    if t < p(i) or p(i + 1) < t:
+        return 0
+
+    thesecoeffs = coeffs[i][borc][s]
+
+    for m, coeff in enumerate(thesecoeffs):
+        val += coeff * u(t, i) ** m
+
+    return val

lalpulsar/piecewise_model/class_definitions.py

@@ -0,0 +1,323 @@
+# Copyright (C) 2019--2023 Benjamin Grace
+#
+# 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.
+
+## \file
+## \ingroup lalpulsar_python_piecewise_model
+"""
+Common classes for piecewise model module.
+"""
+
+from . import basis_functions as bf
+from . import estimating_knots as ek
+from . import gte_and_other_methods as gom
+
+HOUR = 3600
+DAY = 24 * HOUR
+
+
+class TBank:
+    name = None
+    s = None
+    fmin = None
+    fmax = None
+    nmin = None
+    nmax = None
+    Izz = None
+    ellip = None
+    radius = None
+    kmin = None
+    kmax = None
+    mismatch = None
+    dur = None
+    knotnum = None
+    knots = None
+
+    flags_bbox = []
+    flags_intbox = []
+
+    tstart = None
+
+    cosi = None
+    psi = None
+    phi0 = None
+    Alpha = None
+    Delta = None
+
+    detectors = []
+
+    noise_path = None
+    sft_path = None
+    psd_path = None
+
+    def SetTBankParams(self, args):
+
+        if args.s:
+            self.s = args.s
+        if args.fmin:
+            self.fmin = args.fmin
+        if args.fmax:
+            self.fmax = args.fmax
+        if args.nmin:
+            self.nmin = args.nmin
+        if args.nmax:
+            self.nmax = args.nmax
+        if args.Izz:
+            self.Izz = args.Izz
+        if args.ellip:
+            self.ellip = args.ellip
+        if args.radius:
+            self.radius = args.radius
+
+        self.kmin = (
+            args.kmin
+            if args.kmin is not None
+            else gom.kforGWsource(Izz=self.Izz, ellip=self.ellip, radius=self.radius)
+            * 0.1
+        )
+        self.kmax = (
+            args.kmax
+            if args.kmax is not None
+            else gom.kforGWsource(Izz=self.Izz, ellip=self.ellip, radius=self.radius)
+        )
+
+        if args.dur:
+            self.dur = args.dur
+        if args.maxmismatch:
+            self.maxmismatch = args.maxmismatch
+        if args.knotnum:
+            self.knotnum = args.knotnum
+
+        if args.flags_bbox is not []:
+            self.flags_bbox = args.flags_bbox
+        if args.flags_intbox is not []:
+            self.flags_intbox = args.flags_intbox
+
+        if args.tstart:
+            self.tstart = args.tstart
+
+        if args.cosi:
+            self.cosi = args.cosi
+        if args.psi:
+            self.psi = args.psi
+        if args.phi0:
+            self.phi0 = args.phi0
+        if args.Alpha:
+            self.Alpha = args.Alpha
+        if args.Delta:
+            self.Delta = args.Delta
+
+        if not (args.detectors == []):
+            self.detectors = args.detectors
+
+        if args.noise_path:
+            self.noise_path = args.noise_path
+        if args.sft_path:
+            self.sft_path = args.sft_path
+        if args.psd_path:
+            self.psd_path = args.psd_path
+
+    def SetDefaultGW170817(self):
+        self.name = "GW170817"
+
+        # Physical Parameters
+        self.s = 2
+        self.fmin = 999
+        self.fmax = 1000
+        self.nmin = 3
+        self.nmax = 5
+        self.Izz = 1e38  # The long transient paper uses a value of 4.34e38
+        self.ellip = 1e-4
+        self.radius = 1e4
+
+        self.kmin = (
+            gom.kforGWsource(Izz=self.Izz, ellip=self.ellip, radius=self.radius) * 0.1
+        )
+        self.kmax = gom.kforGWsource(Izz=self.Izz, ellip=self.ellip, radius=self.radius)
+
+        # Relevant to search data
+        self.maxmismatch = 0.2
+        self.Tsft = 10
+
+        # Timing
+        self.dur = 1800
+        self.knotnum = 0
+        self.knots = [0, 1800]
+        self.tstart = 1187008882
+
+        # Sky Positions and orientations
+        self.cosi = None  # 0.882948           # iota = 28 Degrees
+        self.psi = None  # 0
+        self.phi0 = None  # 0
+        self.Alpha = 3.446
+        self.Delta = -0.408
+
+        self.detectors = ["H1", "L1"]
+
+    def SetDefaultGW190425(self):
+        self.name = "GW190425"
+
+        # Physical Parameters
+        self.s = 2
+        self.fmin = 999
+        self.fmax = 1000
+        self.nmin = 3
+        self.nmax = 5
+        self.Izz = 1e38  # The long transient paper uses a value of 4.34e38
+        self.ellip = 1e-4
+        self.radius = 1e4
+
+        self.kmin = (
+            gom.kforGWsource(Izz=self.Izz, ellip=self.ellip, radius=self.radius) * 0.1
+        )
+        self.kmax = gom.kforGWsource(Izz=self.Izz, ellip=self.ellip, radius=self.radius)
+
+        # Relevant to search data
+        self.maxmismatch = 0.2
+        self.Tsft = 10
+
+        # Timing
+        self.dur = 1800
+        self.knotnum = 0
+        self.knots = [0, 1800]
+        self.tstart = 1240215503
+
+        # Sky Positions and orientations
+        self.cosi = None  # 0
+        self.psi = None  # 0
+        self.phi0 = None  # 0
+        self.Alpha = 4.218
+        self.Delta = 0.401
+
+        self.detectors = ["L1", "V1"]
+
+    def SetDefault1987A(self):
+        self.name = "1987A"
+
+        self.s = 2
+        self.fmin = 49.99
+        self.fmax = 50
+        self.nmin = 3
+        self.nmax = 5
+        self.kmin = gom.kforGWsource() * 0.1
+        self.kmax = gom.kforGWsource()
+
+        self.maxmismatch = 0.2
+        self.Tsft = 1800
+
+        self.dur = 20 * DAY
+        self.knotnum = 0
+        self.knots = [0, self.dur]
+
+    def SetDefaultCasA(self):
+        self.name = "CasA"
+
+        self.s = 2
+        self.fmin = 29.99
+        self.fmax = 30
+        self.nmin = 3
+        self.nmax = 5
+        self.kmin = gom.kforGWsource() * 0.1
+        self.kmax = gom.kforGWsource()
+
+        self.maxmismatch = 0.2
+        self.Tsft = 1800
+
+        self.dur = 20 * DAY
+        self.knotnum = 0
+        self.knots = [0, self.dur]
+
+    # Sets the knots of a TBank object to be those calculated by our knot algorithm. A duration or knot number must first be set
+    def SetKnotsByAlg(self):
+        s = self.s
+        steps = 40  # These are the number of steps used to find the maximum error in the bi-section method for calculating knots. A value of at least 30 usually gives good enough results
+        f0 = self.fmax
+        nmax = self.nmax
+        kmax = self.kmax
+        mismatch = self.maxmismatch
+        dur = self.dur
+        knotnum = self.knotnum
+
+        self.knots = ek.allidealisedknots(
+            s, dur, steps, f0, nmax, kmax, mismatch, knotnum=knotnum
+        )
+
+        if self.knotnum != 0:
+            self.knots = self.knots[0 : self.knotnum + 1]
+            self.dur = self.knots[-1] - self.knots[0]
+            self.knotnum = len(self.knots)
+
+        bf.knotslist = self.knots
+
+    # Returns a string containing all parameters for this particular TBank, excluding the knots
+    def toString(self):
+        string = self.name
+
+        tbank = TBank()
+
+        if string == "GW170817":
+            tbank.SetDefaultGW170817()
+        elif string == "GW190425":
+            tbank.SetDefaultGW190425()
+
+        tbank.fmin = -1
+        tbank.fmax = -1
+
+        original_dict = vars(self)
+        default_dict = vars(tbank)
+
+        different_variables = []
+
+        skip_variables = [
+            "name",
+            "knots",
+            "flags_bbox",
+            "flags_intbox",
+            "noise_path",
+            "sft_path",
+            "psd_path",
+        ]
+
+        for key, value in original_dict.items():
+
+            if key in skip_variables:
+                continue
+
+            if value is None:
+                continue
+
+            default_variable = default_dict[key]
+
+            if value != default_variable:
+
+                if key == "detectors":
+
+                    value_string = ""
+
+                    for det in value:
+                        value_string += det
+                        different_variables.append(value_string)
+                else:
+                    value_string = key + "-" + str(value)
+                    different_variables.append(value_string)
+
+        for diff_var in different_variables:
+            string += "_" + diff_var
+
+        return string
+
+
+class FInput:
+    pass

lalpulsar/piecewise_model/errors.py

@@ -0,0 +1,37 @@
+# Copyright (C) 2019--2023 Benjamin Grace
+#
+# 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.
+
+## \file
+## \ingroup lalpulsar_python_piecewise_model
+"""
+Error classes.
+"""
+
+
+class TooManyNegdurReductions(Exception):
+    pass
+
+
+class SegmentContainsNoSamplePoints(Exception):
+    pass
+
+
+class PointNotWithinKnotBoundaries(Exception):
+    pass
+
+
+class ValueOfSNotAccountedFor(Exception):
+    pass