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

lalpulsar/pulsarhtmlutils.py

@@ -30,22 +30,21 @@ from __future__ import print_function
 import re
 import numpy as np
 import math
-import six
 
 from lalpulsar.pulsarpputils import rad_to_dms, rad_to_hms
 
 # some parameter names for special LaTeX treatment in figures
 paramlatexdict = {
     "H0": "$h_0$",
-    "COSIOTA": "$\cos{\iota}$",
-    "PSI": "$\psi$ (rad)",
-    "PHI0": "$\phi_0$ (rad)",
+    "COSIOTA": "$\\cos{\\iota}$",
+    "PSI": "$\\psi$ (rad)",
+    "PHI0": "$\\phi_0$ (rad)",
     "RA": "$\\alpha$",
-    "DEC": "$\delta$",
+    "DEC": "$\\delta$",
     "RAJ": "$\\alpha$",
-    "DECJ": "$\delta$",
+    "DECJ": "$\\delta$",
     "F0": "$f_0$ (Hz)",
-    "F1": "$\dot{f}$ (Hz/s)",
+    "F1": "$\\dot{f}$ (Hz/s)",
     "F2": "$\\ddot{f}$ (Hz/s$^2$)",
     "F3": "$f_3$ (Hz/s$^3$)",
     "F4": "$f_4$ (Hz/s$^4$)",
@@ -55,28 +54,28 @@ paramlatexdict = {
     "F8": "$f_8$ (Hz/s$^8$)",
     "F9": "$f_9$ (Hz/s$^9$)",
     "F10": "$f_{10}$ (Hz/s$^{10}$)",
-    "LOGL": "$\log{L}$",
+    "LOGL": "$\\log{L}$",
     "PMRA": "p.m. $\\alpha$ (rad/s)",
-    "PMDEC": "p.m. $\delta$ (rad/s)",
-    "PMDC": "p.m. $\delta$ (rad/s)",
-    "PX": "$\pi$ (rad)",
-    "A1": "$a \sin{i}$ (lt s)",
-    "A1_2": "$(a \sin{i})_{2}$ (lt s)",
-    "A1_3": "$(a \sin{i})_{3}$ (lt s)",
-    "SINI": "$\sin{i}$",
+    "PMDEC": "p.m. $\\delta$ (rad/s)",
+    "PMDC": "p.m. $\\delta$ (rad/s)",
+    "PX": "$\\pi$ (rad)",
+    "A1": "$a \\sin{i}$ (lt s)",
+    "A1_2": "$(a \\sin{i})_{2}$ (lt s)",
+    "A1_3": "$(a \\sin{i})_{3}$ (lt s)",
+    "SINI": "$\\sin{i}$",
     "PB": "$P_b$ (s)",
     "PB_2": "$(P_b)_2$ (s)",
     "PB_3": "$(P_b)_3$ (s)",
     "T0": "$T_0$ (s)",
     "T0_2": "$(T_0)_2$ (s)",
     "T0_3": "$(T_0)_3$ (s)",
-    "TASC": "$T_{\\textrm{asc}}$ (s)",
-    "OM": "$\omega_0$ (rad)",
-    "OM_2": "$(\omega_0)_2$ (rad)",
-    "OM_3": "$(\omega_0)_3$ (rad)",
-    "PBDT": "$\dot{P}$ (s/s)",
-    "PBDOT": "$\dot{P}$ (s/s)",
-    "GAMMA": "$\gamma$",
+    "TASC": "$T_{\\\textrm{asc}}$ (s)",
+    "OM": "$\\omega_0$ (rad)",
+    "OM_2": "$(\\omega_0)_2$ (rad)",
+    "OM_3": "$(\\omega_0)_3$ (rad)",
+    "PBDT": "$\\dot{P}$ (s/s)",
+    "PBDOT": "$\\dot{P}$ (s/s)",
+    "GAMMA": "$\\gamma$",
     "E": "$e$",
     "ECC": "$e$",
     "ECC_2": "$e_2$",
@@ -94,38 +93,38 @@ paramlatexdict = {
     "M2": "$m_2$ (kg)",
     "MTOT": "$M$ (kg)",
     "ELL": "$\\varepsilon$",
-    "H95": "$h_0^{95\%}$",
-    "H0UL": "$h_0^{{{}\%}}$",
-    "Q22": "$Q_{22}$\,(kg\,m$^2$)",
+    "H95": "$h_0^{95\\%}$",
+    "H0UL": "$h_0^{{{}\\%}}$",
+    "Q22": "$Q_{22}$\\,(kg\\,m$^2$)",
     "SDRAT": "spin-down ratio",
-    "SDRAT95": "$h_0^{95\%}$/h_0^{\\rm sd}$",
+    "SDRAT95": "$h_0^{95\\%}$/h_0^{\\rm sd}$",
     "SDLIM": "$h_0^{\\rm sd}$",
     "F0ROT": "$f_{\\rm rot}$ (Hz)",
     "F0GW": "$f_{\\rm gw}$ (Hz)",
-    "F1ROT": "$\dot{f}_{\\rm rot}$ (Hz/s)",
-    "F1GW": "$\dot{f}_{\\rm gw}$ (Hz/s)",
-    "SDPOWRAT": "power ratio (\%)",
-    "OMDOT": "$\dot{\omega}$",
-    "OMDT": "$\dot{\omega}$",
+    "F1ROT": "$\\dot{f}_{\\rm rot}$ (Hz/s)",
+    "F1GW": "$\\dot{f}_{\\rm gw}$ (Hz/s)",
+    "SDPOWRAT": "power ratio (\\%)",
+    "OMDOT": "$\\dot{\\omega}$",
+    "OMDT": "$\\dot{\\omega}$",
     "EPS1": "$\\epsilon_1$",
     "EPS2": "$\\epsilon_2$",
     "C22": "$C_{22}$",
     "C21": "$C_{21}$",
-    "C22UL": "$C_{{22}}^{{{}\%}}$",
-    "C21UL": "$C_{{21}}^{{{}\%}}$",
-    "PHI22": "$\phi_{22}$",
-    "PHI21": "$\phi_{21}$",
+    "C22UL": "$C_{{22}}^{{{}\\%}}$",
+    "C21UL": "$C_{{21}}^{{{}\\%}}$",
+    "PHI22": "$\\phi_{22}$",
+    "PHI21": "$\\phi_{21}$",
     "I31": "$I_{31}$",
     "I21": "$I_{21}$",
-    "I31UL": "$I_{{31}}^{{{}\%}}$",
-    "I21UL": "$I_{{21}}^{{{}\%}}$",
-    "LAMBDA": "$\lambda$ (rad)",
-    "COSTHETA": "$\cos{\\theta}$",
+    "I31UL": "$I_{{31}}^{{{}\\%}}$",
+    "I21UL": "$I_{{21}}^{{{}\\%}}$",
+    "LAMBDA": "$\\lambda$ (rad)",
+    "COSTHETA": "$\\cos{\\\theta}$",
     "DIST": "distance (kpc)",
     "SNR": "$\\rho$",
-    "BSN": "$\log{}_{10}\left(B_{\\textrm{SvN}}\\right)$",
-    "BCI": "$\log{}_{10}\left(B_{\\textrm{CvI}}\\right)$",
-    "BCIN": "$\log{}_{10}\left(B_{\\textrm{CvIN}}\\right)$",
+    "BSN": "$\\log{}_{10}\\left(B_{\\\textrm{SvN}}\\right)$",
+    "BCI": "$\\log{}_{10}\\left(B_{\\\textrm{CvI}}\\right)$",
+    "BCIN": "$\\log{}_{10}\\left(B_{\\\textrm{CvIN}}\\right)$",
 }
 
 
@@ -866,7 +865,7 @@ class latextable:
         self._thisrow = -1  # the index of the current row given row additions
 
         # set the table format
-        self._tableformat = "\\begin{{table}}{{{floatval}}}\n{preamble}\caption{{{caption}\label{{{label}}}}}\n\\begin{{tabular}}{{{columnalign}}}\n{table}\n\\end{{tabular}}\n{postamble}\n\\end{{table}}"
+        self._tableformat = "\\begin{{table}}{{{floatval}}}\n{preamble}\\caption{{{caption}\\label{{{label}}}}}\n\\begin{{tabular}}{{{columnalign}}}\n{table}\n\\end{{tabular}}\n{postamble}\n\\end{{table}}"
         self._tableinfo["data"] = ""
 
     def set_ncolumns(self, ncolumns):
@@ -980,7 +979,7 @@ class latextable:
                 if "multicolumn" in data:
                     ncols += data["multicolumn"]
                     rowtxt.append(
-                        "\multicolumn{%d}{%s}{%s} "
+                        "\\multicolumn{%d}{%s}{%s} "
                         % (data["multicolumn"], data["mcalign"], val)
                     )
                 else:
@@ -991,9 +990,9 @@ class latextable:
             ):
                 raise ValueError("Error... too many or too few inputs in row '%d'." % i)
             if len(rowtxt) != 0:
-                self._tableinfo["table"] += "&".join(rowtxt) + "\\\\\n"
+                self._tableinfo["table"] += "&".join(rowtxt) + "\\\n"
             if row["underline"]:  # add horizontal rule below row
-                self._tableinfo["table"] += "\hline\n"
+                self._tableinfo["table"] += "\\hline\n"
 
         self._tabletext = self._tableformat.format(**self._tableinfo)
         return self._tabletext
@@ -1010,7 +1009,7 @@ def exp_str(f, p=1, otype="html"):
     if otype.lower() == "html":  # output html format
         return "%.*f&times;10<sup>%d</sup>" % (p, float(ssplit[0]), int(ssplit[1]))
     elif otype.lower() == "latex":  # output LaTeX format
-        return "\\ensuremath{%.*f\!\\times\!10^{%d}}" % (
+        return "\\ensuremath{%.*f\\!\\times\\!10^{%d}}" % (
             p,
             float(ssplit[0]),
             int(ssplit[1]),
@@ -1021,7 +1020,7 @@ def exp_str(f, p=1, otype="html"):
 
 # convert a right ascension string in format 'hh:mm:ss.s' to a html/LaTeX string like H^h M^m S^s.ss
 def ra_str(ra, otype="html"):
-    if isinstance(ra, six.string_types):
+    if isinstance(ra, str):
         hms = ra.split(":")
     elif isinstance(ra, float):
         hms = [str(v) for v in rad_to_hms(ra)]
@@ -1044,7 +1043,7 @@ def ra_str(ra, otype="html"):
             ss[1].zfill(2),
         )
     elif otype.lower() == "latex":  # return LaTeX string
-        return "$%s^{\\rm h}%s^{\\rm m}%s^{\\rm s}\!.%s$" % (
+        return "$%s^{\\rm h}%s^{\\rm m}%s^{\\rm s}\\!.%s$" % (
             hms[0].zfill(2),
             hms[1].zfill(2),
             ss[0].zfill(2),
@@ -1056,7 +1055,7 @@ def ra_str(ra, otype="html"):
 
 # convert a declination string in format 'dd:mm:ss.s' to a html/LaTeX string like dd^o mm' ss''.ss
 def dec_str(dec, otype="html"):
-    if isinstance(dec, six.string_types):
+    if isinstance(dec, str):
         dms = dec.split(":")
     elif isinstance(dec, float):
         dms = [str(v) for v in rad_to_dms(dec)]
@@ -1073,14 +1072,14 @@ def dec_str(dec, otype="html"):
 
     if otype.lower() == "html":  # html output
         return "%s&deg;%s'%s\".%s" % (
-            (re.sub("\+", "", dms[0])).zfill(2),
+            (re.sub(r"\+", "", dms[0])).zfill(2),
             dms[1].zfill(2),
             ss[0].zfill(2),
             ss[1].zfill(2),
         )
     elif otype.lower() == "latex":  # LaTeX output
-        return "$%s^{\circ}%s'%s''\!.%s$" % (
-            (re.sub("\+", "", dms[0])).zfill(2),
+        return "$%s^{\\circ}%s'%s''\\!.%s$" % (
+            (re.sub(r"\+", "", dms[0])).zfill(2),
             dms[1].zfill(2),
             ss[0].zfill(2),
             ss[1].zfill(2),

lalpulsar/pulsarpputils.py

@@ -37,7 +37,12 @@ import struct
 import re
 import h5py
 
-from scipy.integrate import cumtrapz
+try:
+    from scipy.integrate import trapezoid, cumulative_trapezoid
+except ImportError:
+    # FIXME: Remove this once we require scipy >=1.6.0.
+    from scipy.integrate import trapz as trapezoid, cumtrapz as cumulative_trapezoid
+
 from scipy.interpolate import interp1d
 
 try:
@@ -45,8 +50,6 @@ try:
 except ImportError:  # scipy < 0.19.0
     from scipy.misc import logsumexp
 
-from six import string_types
-
 # some common constants taken from psr_constants.py in PRESTO
 ARCSECTORAD = float("4.8481368110953599358991410235794797595635330237270e-6")
 RADTOARCSEC = float("206264.80624709635515647335733077861319665970087963")
@@ -319,7 +322,7 @@ float_keys = [
     "EPS1DOT",
     "EPS2DOT",
     "TASC",
-    "LAMBDA",
+    "LAMBDAPIN",
     "BETA",
     "RA_RAD",
     "DEC_RAD",
@@ -899,7 +902,7 @@ def plot_posterior_hist(
 
         # if upper limit is needed then integrate posterior using trapezium rule
         if upperlimit != 0:
-            ct = cumtrapz(n, bins)
+            ct = cumulative_trapezoid(n, bins)
 
             # prepend a zero to ct
             ct = np.insert(ct, 0, 0)
@@ -940,7 +943,7 @@ def upper_limit(
 
     # if upper limit is needed then integrate posterior using trapezium rule
     if upperlimit != 0:
-        ct = cumtrapz(n, bins)
+        ct = cumulative_trapezoid(n, bins)
 
         # prepend a zero to ct
         ct = np.insert(ct, 0, 0)
@@ -1232,18 +1235,18 @@ def plot_2Dhist_from_file(
         # marginalise over y-axes and produce plots
         xmarg = []
         for i in range(len(xbins)):
-            xmarg.append(np.trapz(histarr[:][i], x=ybins))
+            xmarg.append(trapezoid(histarr[:][i], x=ybins))
 
         # normalise
-        xarea = np.trapz(xmarg, x=xbins)
+        xarea = trapezoid(xmarg, x=xbins)
         xmarg = map(lambda x: x / xarea, xmarg)
 
         ymarg = []
         for i in range(len(ybins)):
-            ymarg.append(np.trapz(np.transpose(histarr)[:][i], x=xbins))
+            ymarg.append(trapezoid(np.transpose(histarr)[:][i], x=xbins))
 
         # normalise
-        yarea = np.trapz(ymarg, x=ybins)
+        yarea = trapezoid(ymarg, x=ybins)
         ymarg = map(lambda x: x / yarea, ymarg)
 
         # plot x histogram
@@ -1287,15 +1290,15 @@ def h0ul_from_prior_file(priorfile, ulval=0.95):
     # marginalise over cos(iota)
     h0marg = []
     for i in range(len(h0bins)):
-        h0marg.append(np.trapz(histarr[:][i], x=cibins))
+        h0marg.append(trapezoid(histarr[:][i], x=cibins))
 
     # normalise h0 posterior
     h0bins = h0bins - (h0bins[1] - h0bins[0]) / 2
-    h0area = np.trapz(h0marg, x=h0bins)
+    h0area = trapezoid(h0marg, x=h0bins)
     h0margnorm = map(lambda x: x / h0area, h0marg)
 
     # get cumulative probability
-    ct = cumtrapz(h0margnorm, h0bins)
+    ct = cumulative_trapezoid(h0margnorm, h0bins)
 
     # prepend a zero to ct
     ct = np.insert(ct, 0, 0)
@@ -1516,7 +1519,7 @@ def hist_norm_bounds(samples, nbins, low=float("-inf"), high=float("inf")):
         n = np.append(n, nbound)
 
     # now calculate area and normalise
-    area = np.trapz(n, x=bincentres)
+    area = trapezoid(n, x=bincentres)
 
     ns = np.array([])
     for i in range(0, len(bincentres)):
@@ -2195,9 +2198,9 @@ def convert_model_parameters(pardict):
     theta = np.arccos(costheta)
     sintheta = math.sin(theta)
     sin2theta = math.sin(2.0 * theta)
-    sinlambda = math.sin(pardict["lambda"])
-    coslambda = math.cos(pardict["lambda"])
-    sin2lambda = math.sin(2.0 * pardict["lambda"])
+    sinlambda = math.sin(pardict["lambdapin"])
+    coslambda = math.cos(pardict["lambdapin"])
+    sin2lambda = math.sin(2.0 * pardict["lambdapin"])
 
     phi0 = pardict["phi0"]
 
@@ -2235,9 +2238,9 @@ def heterodyned_pinsf_pulsar(starttime, duration, dt, detector, pardict):
     siniota = math.sin(iota)
     sintheta = math.sin(theta)
     sin2theta = math.sin(2.0 * theta)
-    sinlambda = math.sin(pardict["lambda"])
-    coslambda = math.cos(pardict["lambda"])
-    sin2lambda = math.sin(2.0 * pardict["lambda"])
+    sinlambda = math.sin(pardict["lambdapin"])
+    coslambda = math.cos(pardict["lambdapin"])
+    sin2lambda = math.sin(2.0 * pardict["lambdapin"])
 
     ePhi = cmath.exp(0.5 * pardict["phi0"] * 1j)
     e2Phi = cmath.exp(pardict["phi0"] * 1j)
@@ -2342,7 +2345,7 @@ def antenna_response(gpsTime, ra, dec, psi, det):
 
     # check if ra and dec are floats or strings (if strings in hh/dd:mm:ss.s format then convert to rads)
     if not isinstance(ra, float):
-        if isinstance(ra, string_types):
+        if isinstance(ra, str):
             try:
                 ra = ra_to_rad(ra)
             except:
@@ -2355,7 +2358,7 @@ def antenna_response(gpsTime, ra, dec, psi, det):
             )
 
     if not isinstance(dec, float):
-        if isinstance(dec, string_types):
+        if isinstance(dec, str):
             try:
                 dec = dec_to_rad(dec)
             except:
@@ -2417,7 +2420,7 @@ def inject_pulsar_signal(
     snrscale=None,
 ):
     # if detectors is just a string (i.e. one detector) then make it a list
-    if isinstance(detectors, string_types):
+    if isinstance(detectors, str):
         detectors = [detectors]
 
     # if not noise sigma's are given then generate a noise level from the given
@@ -3308,7 +3311,7 @@ def pulsar_posterior_grid(
 
     # if dets is just a single string
     if not isinstance(dets, list):
-        if isinstance(dets, string_types):
+        if isinstance(dets, str):
             dets = [dets]  # make into list
         else:
             print("Detector not, or incorrectly, set", file=sys.stderr)
@@ -3566,7 +3569,7 @@ def get_atnf_info(psr):
 
     import requests
 
-    psrname = re.sub("\+", "%2B", psr)  # switch '+' for unicode character
+    psrname = re.sub(r"\+", "%2B", psr)  # switch '+' for unicode character
 
     atnfurl = (
         "http://www.atnf.csiro.au/people/pulsar/psrcat/proc_form.php?version="

lalpulsar/simulateCW.py

@@ -16,7 +16,7 @@
 
 ## \defgroup lalpulsar_py_simulateCW SimulateCW
 ## \ingroup lalpulsar_python
-"""
+r"""
 Generate strain time series of a continuous-wave signal in the detector frame,
 given a function which computes signal phase and amplitudes as functions of time.
 
@@ -273,7 +273,9 @@ class CWSimulator(object):
         self._simulate_coherent_gw(h, noise_sqrt_Sh, noise_seed)
         return (h.epoch, h.data.data)
 
-    def get_strain_blocks(self, fs, Tblock, noise_sqrt_Sh=0, noise_seed=None):
+    def get_strain_blocks(
+        self, fs, Tblock, noise_sqrt_Sh=0, noise_seed=None, prog_bar=None
+    ):
         """
         Generate strain time series of a continuous-wave signal in the detector frame, in contiguous blocks.
 
@@ -283,6 +285,7 @@ class CWSimulator(object):
             spectral density given by this value, in Hz^(-1/2)
         @param noise_seed: use this seed for the random number generator used to create noise;
             if None, generate a random seed using os.urandom()
+        @param prog_bar: use to display a progress bar, e.g. prog_bar=tqdm
 
         @return (@b t, @b h, @b i, @b N), where:
             @b t = start of time strain time series, in GPS seconds;
@@ -312,9 +315,16 @@ class CWSimulator(object):
             while not (0 < noise_seed and noise_seed < lal.LAL_INT4_MAX - Nblock):
                 noise_seed = int.from_bytes(os.urandom(4), sys.byteorder, signed=False)
 
+        # iterate over blocks
+        blocks = range(0, Nblock)
+        if prog_bar is not None:
+
+            # wrap iterator in progress bar
+            blocks = prog_bar(blocks)
+
         # generate strain time series in blocks of length 'Tblock'
         tmin = 0
-        for iblock in range(0, Nblock):
+        for iblock in blocks:
             epoch, hoft = self.get_strain(
                 fs,
                 tmin=tmin,
@@ -326,7 +336,14 @@ class CWSimulator(object):
             tmin += Tblock
 
     def write_frame_files(
-        self, fs, Tframe, comment="simCW", out_dir=".", noise_sqrt_Sh=0, noise_seed=None
+        self,
+        fs,
+        Tframe,
+        comment="simCW",
+        out_dir=".",
+        noise_sqrt_Sh=0,
+        noise_seed=None,
+        prog_bar=None,
     ):
         """
         Write frame files [1] containing strain time series of a continuous-wave signal.
@@ -344,6 +361,7 @@ class CWSimulator(object):
             spectral density given by this value, in Hz^(-1/2)
         @param noise_seed: use this seed for the random number generator used to create noise;
             if None, generate a random seed using os.urandom()
+        @param prog_bar: use to display a progress bar, e.g. prog_bar=tqdm
 
         @return (@b file, @b i, @b N), where:
             @b file = name of frame file just written;
@@ -376,7 +394,11 @@ class CWSimulator(object):
         # generate strain time series in blocks of length 'Tframe'
         frame_h = None
         for t, h, i, N in self.get_strain_blocks(
-            fs, Tframe, noise_sqrt_Sh=noise_sqrt_Sh, noise_seed=noise_seed
+            fs,
+            Tframe,
+            noise_sqrt_Sh=noise_sqrt_Sh,
+            noise_seed=noise_seed,
+            prog_bar=prog_bar,
         ):
             # create and initialise REAL8TimeSeries to write to frame files
             if frame_h is None:
@@ -426,6 +448,8 @@ class CWSimulator(object):
         noise_seed=None,
         window="rectangular",
         window_param=0,
+        prog_bar=None,
+        fmin=0,
     ):
         """
         Generate SFTs [2] containing strain time series of a continuous-wave signal.
@@ -439,6 +463,9 @@ class CWSimulator(object):
         @param window: if not None, window the time series before performing the FFT, using
             the named window function; see XLALCreateNamedREAL8Window()
         @param window_param: parameter for the window function given by @b window, if needed
+        @param prog_bar: use to display a progress bar, e.g. prog_bar=tqdm
+        @param fmin: if >0, minimum SFT frequency, in Hz
+            (note that this only modifies the output SFT bandwidth; internally a full-band SFT is still produced by sampling at 2*fmax)
 
         @return (@b sft, @b i, @b N), where:
             @b sft = SFT;
@@ -463,7 +490,11 @@ class CWSimulator(object):
         sft_h = None
         sft_fs = 2 * fmax
         for t, h, i, N in self.get_strain_blocks(
-            sft_fs, Tsft, noise_sqrt_Sh=noise_sqrt_Sh, noise_seed=noise_seed
+            sft_fs,
+            Tsft,
+            noise_sqrt_Sh=noise_sqrt_Sh,
+            noise_seed=noise_seed,
+            prog_bar=prog_bar,
         ):
             # create and initialise REAL8TimeSeries to write to SFT files
             if sft_h is None:
@@ -480,6 +511,11 @@ class CWSimulator(object):
                 sft_h, sft_ts, window, window_param
             )
 
+            if fmin != 0:
+                sft_vect = lalpulsar.ExtractStrictBandFromSFTVector(
+                    sft_vect, fMin=fmin, Band=fmax - fmin
+                )
+
             # yield current SFT
             yield sft_vect.data[0], i, N
 
@@ -493,6 +529,8 @@ class CWSimulator(object):
         noise_seed=None,
         window="rectangular",
         window_param=0,
+        prog_bar=None,
+        fmin=0,
     ):
         """
         Write SFT files [2] containing strain time series of a continuous-wave signal.
@@ -508,6 +546,9 @@ class CWSimulator(object):
         @param window: if not None, window the time series before performing the FFT, using
             the named window function; see XLALCreateNamedREAL8Window()
         @param window_param: parameter for the window function given by @b window, if needed
+        @param prog_bar: use to display a progress bar, e.g. prog_bar=tqdm
+        @param fmin: if >0, minimum SFT frequency, in Hz
+            (note that this only modifies the output SFT bandwidth; internally a full-band SFT is still produced by sampling at 2*fmax)
 
         @return (@b file, @b i, @b N), where:
             @b file = name of SFT file just written;
@@ -547,6 +588,8 @@ class CWSimulator(object):
             noise_seed=noise_seed,
             window=window,
             window_param=window_param,
+            prog_bar=prog_bar,
+            fmin=fmin,
         ):
             # write SFT
             lalpulsar.WriteSFT2StandardFile(sft, spec, self.__origin_str)

lalpulsar/simulateHeterodynedCW.py

@@ -101,7 +101,6 @@ model = het.model(parupdate, usephase=True, updateSSB=True)
 from __future__ import division, print_function
 
 import numpy as np
-from six import string_types
 
 try:
     import lal
@@ -297,7 +296,7 @@ class HeterodynedCWSimulator(object):
             # value is already a lal.Detector
             self.__detector = det
         else:
-            if not isinstance(det, string_types):
+            if not isinstance(det, str):
                 raise TypeError("Detector name must be a string")
             else:
                 try:
@@ -402,9 +401,9 @@ class HeterodynedCWSimulator(object):
             )
 
         if self.__units == "TCB":
-            self.__units_type = lalpulsar.lalpulsar.TIMECORRECTION_TCB
+            self.__units_type = lalpulsar.TIMECORRECTION_TCB
         else:
-            self.__units_type = lalpulsar.lalpulsar.TIMECORRECTION_TDB
+            self.__units_type = lalpulsar.TIMECORRECTION_TDB
 
     def model(
         self,
@@ -489,7 +488,7 @@ class HeterodynedCWSimulator(object):
         if isinstance(par, PulsarParametersPy):
             return par
 
-        if isinstance(par, string_types):
+        if isinstance(par, str):
             try:
                 return PulsarParametersPy(par)
             except IOError:

lalsimulation/__init__.py

@@ -1,7 +1,7 @@
 # Import SWIG wrappings, if available
-from .lalsimulation import *
+from ._lalsimulation_swig import *
 
-__version__ = "5.4.0.1"
+__version__ = "6.2.0.1"
 
 ## \addtogroup lalsimulation_python
 """This package provides Python wrappings and extensions to LALSimulation"""

lalsimulation/{lalsimulation.py → _lalsimulation_swig.py}

@@ -1,5 +1,5 @@
 # This file was automatically generated by SWIG (https://www.swig.org).
-# Version 4.1.1
+# Version 4.3.1
 #
 # Do not make changes to this file unless you know what you are doing - modify
 # the SWIG interface file instead.

lalsimulation/git_version.py

@@ -20,8 +20,8 @@
 # Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA 02110-1301 USA
 
-id = "171dc16bb73611969b9d9d62cd7f27f076519294"
-date = "2024-04-4 22:38:44 +0000"
+id = "53acc0c2cd7ea2d3c83fc71a7bd88035c2861d6c"
+date = "2025-10-27 23:19:54 +0000"
 branch = "None"
 tag = "None"
 if tag == "None":
@@ -33,7 +33,7 @@ status = "CLEAN: All modifications committed"
 version = id
 verbose_msg = """Branch: None
 Tag: None
-Id: 171dc16bb73611969b9d9d62cd7f27f076519294
+Id: 53acc0c2cd7ea2d3c83fc71a7bd88035c2861d6c
 
 Builder: Unknown User <>
 Repository status: CLEAN: All modifications committed"""
@@ -54,9 +54,9 @@ def check_match(foreign_id, onmismatch="raise"):
     """
     if onmismatch not in ("raise", "warn"):
         raise ValueError(onmismatch + " is an unrecognized value of onmismatch")
-    if foreign_id == "171dc16bb73611969b9d9d62cd7f27f076519294":
+    if foreign_id == "53acc0c2cd7ea2d3c83fc71a7bd88035c2861d6c":
         return
-    msg = "Program id (171dc16bb73611969b9d9d62cd7f27f076519294) does not match given id (%s)." % foreign_id
+    msg = "Program id (53acc0c2cd7ea2d3c83fc71a7bd88035c2861d6c) does not match given id (%s)." % foreign_id
     if onmismatch == "raise":
         raise VersionMismatchError(msg)
 

lalsimulation/gwsignal/models/__init__.py

@@ -7,6 +7,8 @@ from ..core.waveform import LALCompactBinaryCoalescenceGenerator
 def gwsignal_get_waveform_generator(waveform_approximant):
     if waveform_approximant == "SEOBNRv5HM":
         wf_gen = pyseobnr_model.SEOBNRv5HM()
+    elif waveform_approximant == "SEOBNRv5EHM":
+        wf_gen = pyseobnr_model.SEOBNRv5EHM()
     elif waveform_approximant == "SEOBNRv5PHM":
         wf_gen = pyseobnr_model.SEOBNRv5PHM()
     else: