lalsuite 7.26.2.dev20251206__cp312-cp312-manylinux_2_28_x86_64.whl

lalpulsar/piecewise_model/gte_and_other_methods.py

@@ -0,0 +1,189 @@
+# 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
+"""
+Implementations of the general torque equation and other useful functions.
+"""
+
+import logging
+
+import numpy as np
+
+
+# The general torque equation we have formulated
+def gte(t, f0, ngte, kgte):
+    return f0 * (1 + (ngte - 1) * f0 ** (ngte - 1) * kgte * t) ** (1 / (1 - ngte))
+
+
+# Inverse of the GTE
+def gteinv(freq, f0, ngte, kgte):
+    return ((freq / f0) ** (1 - ngte) - 1) / ((ngte - 1) * f0 ** (ngte - 1) * kgte)
+
+
+# Returns value of kgte for a purely GW (ngte=5) source. Typical values: Izz \in [1, 3] * 10^38, ellip \in [1e-4, 1e-8].
+# Izz default value is the same as that from the long transient search paper. Defaults give kgte=1.7182e-20
+def kforGWsource(Izz=4.34e38, ellip=1e-4, radius=1e4):
+    c = 299792458
+    G = 6.6743e-11
+
+    numerator = 32 * G * Izz * np.pi**4 * ellip**2
+    denominator = 5 * c**5
+
+    return numerator / denominator  # units: s^3
+
+
+# The matrix which transforms from the PW parameters to tref parameters
+def ParamTransformationMatrix(tstart, tend, reftime, s):
+
+    dt = tend - tstart
+    dref = reftime - tstart
+
+    if s == 3:
+        matrix = [
+            [
+                1
+                - (6 * dref**5) / dt**5
+                + (15 * dref**4) / dt**4
+                - (10 * dref**3) / dt**3,
+                dref
+                - (3 * dref**5) / dt**4
+                + (8 * dref**4) / dt**3
+                - (6 * dref**3) / dt**2,
+                dref**2 / 2.0
+                - dref**5 / (2.0 * dt**3)
+                + (3 * dref**4) / (2.0 * dt**2)
+                - (3 * dref**3) / (2.0 * dt),
+                (6 * dref**5) / dt**5
+                - (15 * dref**4) / dt**4
+                + (10 * dref**3) / dt**3,
+                (-3 * dref**5) / dt**4
+                + (7 * dref**4) / dt**3
+                - (4 * dref**3) / dt**2,
+                dref**5 / (2.0 * dt**3)
+                - dref**4 / dt**2
+                + dref**3 / (2.0 * dt),
+            ],
+            [
+                (-30 * dref**4) / dt**5
+                + (60 * dref**3) / dt**4
+                - (30 * dref**2) / dt**3,
+                1
+                - (15 * dref**4) / dt**4
+                + (32 * dref**3) / dt**3
+                - (18 * dref**2) / dt**2,
+                dref
+                - (5 * dref**4) / (2.0 * dt**3)
+                + (6 * dref**3) / dt**2
+                - (9 * dref**2) / (2.0 * dt),
+                (30 * dref**4) / dt**5
+                - (60 * dref**3) / dt**4
+                + (30 * dref**2) / dt**3,
+                (-15 * dref**4) / dt**4
+                + (28 * dref**3) / dt**3
+                - (12 * dref**2) / dt**2,
+                (5 * dref**4) / (2.0 * dt**3)
+                - (4 * dref**3) / dt**2
+                + (3 * dref**2) / (2.0 * dt),
+            ],
+            [
+                (-120 * dref**3) / dt**5
+                + (180 * dref**2) / dt**4
+                - (60 * dref) / dt**3,
+                (-60 * dref**3) / dt**4
+                + (96 * dref**2) / dt**3
+                - (36 * dref) / dt**2,
+                1
+                - (10 * dref**3) / dt**3
+                + (18 * dref**2) / dt**2
+                - (9 * dref) / dt,
+                (120 * dref**3) / dt**5
+                - (180 * dref**2) / dt**4
+                + (60 * dref) / dt**3,
+                (-60 * dref**3) / dt**4
+                + (84 * dref**2) / dt**3
+                - (24 * dref) / dt**2,
+                (10 * dref**3) / dt**3
+                - (12 * dref**2) / dt**2
+                + (3 * dref) / dt,
+            ],
+            [
+                (-360 * dref**2) / dt**5 + (360 * dref) / dt**4 - 60 / dt**3,
+                (-180 * dref**2) / dt**4 + (192 * dref) / dt**3 - 36 / dt**2,
+                (-30 * dref**2) / dt**3 + (36 * dref) / dt**2 - 9 / dt,
+                (360 * dref**2) / dt**5 - (360 * dref) / dt**4 + 60 / dt**3,
+                (-180 * dref**2) / dt**4 + (168 * dref) / dt**3 - 24 / dt**2,
+                (30 * dref**2) / dt**3 - (24 * dref) / dt**2 + 3 / dt,
+            ],
+            [
+                (-720 * dref) / dt**5 + 360 / dt**4,
+                (-360 * dref) / dt**4 + 192 / dt**3,
+                (-60 * dref) / dt**3 + 36 / dt**2,
+                (720 * dref) / dt**5 - 360 / dt**4,
+                (-360 * dref) / dt**4 + 168 / dt**3,
+                (60 * dref) / dt**3 - 24 / dt**2,
+            ],
+            [
+                -720 / dt**5,
+                -360 / dt**4,
+                -60 / dt**3,
+                720 / dt**5,
+                -360 / dt**4,
+                60 / dt**3,
+            ],
+        ]
+
+    elif s == 2:
+
+        matrix = [
+            [
+                1 - (3 * dref**2) / dt**2 - (2 * dref**3) / dt**3,
+                dref + (2 * dref**2) / dt + dref**3 / dt**2,
+                (3 * dref**2) / dt**2 + (2 * dref**3) / dt**3,
+                dref**2 / dt + dref**3 / dt**2,
+            ],
+            [
+                (-6 * dref) / dt**2 - (6 * dref**2) / dt**3,
+                1 + (4 * dref) / dt + (3 * dref**2) / dt**2,
+                (6 * dref) / dt**2 + (6 * dref**2) / dt**3,
+                (2 * dref) / dt + (3 * dref**2) / dt**2,
+            ],
+            [
+                -6 / dt**2 - (12 * dref) / dt**3,
+                4 / dt + (6 * dref) / dt**2,
+                6 / dt**2 + (12 * dref) / dt**3,
+                2 / dt + (6 * dref) / dt**2,
+            ],
+            [-12 / dt**3, 6 / dt**2, 12 / dt**3, 6 / dt**2],
+        ]
+
+    return matrix
+
+
+# An alternative method to transoform our PW parameters to Doppler parameters in a taylor expansion with (t - tref) terms.
+# Like the above methods, this is ill-conditioned, however less so than the above. Again similar to the above methods,
+# this method works best if the start time (bf.knotslist[0]) of your data is subtracted from all time elements, p0, p1
+# and tref. If you are using the conditioning in this method, it slows down dramatically. Good luck
+def PWParamstoTrefParams(pwparams, p0, p1, tref, s):
+
+    matrix = ParamTransformationMatrix(p0, p1, tref, s)
+
+    logging.debug(len(matrix))
+    logging.debug(len(pwparams))
+    logging.debug(pwparams)
+    # If no conditioning is required
+    return np.matmul(matrix, pwparams)

lalpulsar/piecewise_model/mols_for_gte.py

@@ -0,0 +1,269 @@
+# 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
+"""
+Method Of Least Squares (MOLS) for matching a piecewise model to the general
+torque equation (GTE).
+"""
+
+import logging
+
+import numpy as np
+from scipy import integrate
+
+from . import basis_functions as bf
+from . import gte_and_other_methods as gom
+from . import errors
+from . import sampling_methods as sm
+
+
+# Our b vector for MOLS
+def bvec(points, f0, ngte, kgte):
+    return [gom.gte(t - bf.knotslist[0], f0, ngte, kgte) for t in points]
+
+
+# Constructs an individual row of the a matrix for the sample point 'point' and the coefficients of our basis functions
+# 'coeffs'
+def rowofa(point, coeffs, s):
+    j = sm.thisint(point)
+    ints = len(bf.knotslist) - 1
+    firstzeros = [0] * j * s
+    lastzeros = [0] * (ints - 1 - j) * s
+
+    coeffsb = []
+    coeffsc = []
+
+    for thiss in range(s):
+        coeffb = bf.basisfunctionvalue(point, j, 0, thiss, coeffs)
+        coeffc = bf.basisfunctionvalue(point, j, 1, thiss, coeffs)
+
+        coeffsb.append(coeffb)
+        coeffsc.append(coeffc)
+
+    return firstzeros + coeffsb + coeffsc + lastzeros
+
+
+# Builds our a matrix
+def a(points, coeffs, s):
+    amat = []
+
+    for point in points:
+        amat.append(rowofa(point, coeffs, s))
+
+    return amat
+
+
+# Returns a diagonal matrix containing the diagonal elements of mat to power -1/2
+def pmat(mat):
+    return np.diag(bf.listpseudoinv(np.diagonal(mat), 1 / 2))
+
+
+# Returns mat multiplied by its transpose
+def ata(mat):
+    return np.matmul(np.transpose(mat), mat)
+
+
+# Returns the solutions for our LSTSQ problem
+def sols(coeffs, ppint, s, f0, ngte, kgte, conditioning=True):
+    while True:
+        try:
+            points = sm.samplepoints(ppint, f0, ngte, kgte)
+            break
+        except errors.SegmentContainsNoSamplePoints:
+            logging.debug("Reattempting MOLS fitting with greater sampling")
+            ppint *= 2
+
+    b = bvec(points, f0, ngte, kgte)
+    amat = a(points, coeffs, s)
+
+    atamat = ata(amat)
+
+    if conditioning:
+        pm = pmat(atamat)
+    else:
+        pm = np.identity(len(atamat))
+
+    lhs = np.matmul(pm, np.matmul(atamat, pm))
+    rhs = np.matmul(np.matmul(pm, np.transpose(amat)), b)
+
+    logging.debug(
+        "Condition number for matrix A  is: " + "{:.2E}".format(np.linalg.cond(amat))
+    )
+    logging.debug(
+        "Condition number for matrix A' is: " + "{:.2E}".format(np.linalg.cond(lhs))
+    )
+
+    try:
+        params = np.matmul(pm, np.linalg.solve(lhs, rhs))
+    except np.linalg.LinAlgError as error:
+        logging.debug(error)
+        logging.debug(
+            "Error in calculating MOLS parameters, using Python LSTSQ method instead"
+        )
+        params = np.matmul(pm, np.linalg.lstsq(lhs, rhs, rcond=-1)[0])
+
+    return params
+
+
+# Partitions the 1D list params into a 3D list for our parameters. Extract parameter by [ int ][ B or C ][ k ]
+def solsbyint(params, s):
+    ints = int(len(params) / s) - 1
+
+    partedsols = np.zeros((ints, 2, s))
+
+    for i in range(ints):
+        solsb = np.array(params[i * s : (i + 1) * s])
+        solsc = np.array(params[(i + 1) * s : (i + 2) * s])
+
+        partedsols[i][0] = solsb
+        partedsols[i][1] = solsc
+
+    return partedsols
+
+
+def solsbetweenknots(
+    knotnuma, knotnumb, coeffs, ppint, s, f0, ngte, kgte, conditioning=True
+):
+
+    while True:
+        try:
+            points = sm.samplepointswithinknots(
+                knotnuma, knotnumb, ppint, f0, ngte, kgte
+            )
+            break
+        except errors.SegmentContainsNoSamplePoints:
+            logging.debug("Reattempting MOLS fitting with greater sampling")
+            ppint *= 2
+
+    b = bvec(points, f0, ngte, kgte)
+    amat = a(points, coeffs, s)
+
+    for i in range(knotnuma * s):
+        [row.pop(0) for row in amat]
+
+    atamat = ata(amat)
+
+    if conditioning:
+        pm = pmat(atamat)
+    else:
+        pm = np.identity(len(atamat))
+
+    lhs = np.matmul(pm, np.matmul(atamat, pm))
+    rhs = np.matmul(np.matmul(pm, np.transpose(amat)), b)
+
+    logging.debug(
+        "Condition number for matrix A  is: " + "{:.2E}".format(np.linalg.cond(amat))
+    )
+    logging.debug(
+        "Condition number for matrix A' is: " + "{:.2E}".format(np.linalg.cond(lhs))
+    )
+
+    try:
+        params = np.matmul(pm, np.linalg.solve(lhs, rhs))
+    except np.linalg.LinAlgError as error:
+        logging.debug(error)
+        logging.debug(
+            "Error in calculating MOLS parameters, using Python LSTSQ method instead"
+        )
+        params = np.matmul(pm, np.linalg.lstsq(lhs, rhs)[0])
+
+    zerobuff = [0] * (s * knotnuma)
+    paramszerobuff = zerobuff + list(params)
+
+    return paramszerobuff
+
+
+points = []
+
+# Calculates model value at given point for basis function coeffs 'coeffs' and parameter values 'params'
+def modelvalueatpoint(point, coeffs, params, ignoreintcheck=False, singleseg=False):
+
+    s = len(params[0][0])
+
+    if ignoreintcheck:
+        try:
+            j = sm.thisint(point)
+        except errors.PointNotWithinKnotBoundaries:
+
+            t = point - bf.knotslist[0]
+
+            if t < 0:
+                f0 = params[0][0][0]
+                f1 = params[0][0][1]
+                f2 = 0
+
+                if s > 2:
+                    f2 = params[0][0][2]
+
+                return f0 + f1 * t + 1 / 2 * f2 * t**2
+            elif t > bf.knotslist[-1] - bf.knotslist[0]:
+                f0 = params[-1][1][0]
+                f1 = params[-1][1][1]
+                f2 = 0
+
+                if s > 2:
+                    f2 = params[-1][1][2]
+
+                return f0 + f1 * t + 1 / 2 * f2 * t**2
+
+            return 0
+    else:
+        j = sm.thisint(point)
+
+    # if singleseg:
+    #    j = 0
+
+    points.append(point)
+
+    s = np.shape(params)[2]
+
+    val = 0
+
+    for thiss in range(s):
+        basisfuncs = bf.basisfunctionvalue(point, j, 0, thiss, coeffs)
+        basisfunce = bf.basisfunctionvalue(point, j, 1, thiss, coeffs)
+
+        if singleseg:
+            val += params[0][0][thiss] * basisfuncs
+            val += params[0][1][thiss] * basisfunce
+        else:
+            val += params[j][0][thiss] * basisfuncs
+            val += params[j][1][thiss] * basisfunce
+
+    return val
+
+
+def phase(point, coeffs, params, ignoreintcheck=False):
+
+    model = lambda t: modelvalueatpoint(
+        t, coeffs, params, ignoreintcheck=ignoreintcheck
+    )
+    # logging.debug("Integral bounds: " + str([bf.knotslist[0], point]))
+    phasemodel = 2 * np.pi * integrate.quad(model, bf.knotslist[0], point, epsabs=0)[0]
+
+    return phasemodel
+
+
+# Returns the value of the error of our model at a given point
+def errorvalueatpoint(point, coeffs, params, f0, ngte, kgte):
+    error = np.abs(
+        modelvalueatpoint(point, coeffs, params)
+        - gom.gte(point - bf.knotslist[0], f0, ngte, kgte)
+    )
+
+    return error