rapidtide 3.1__py3-none-any.whl → 3.1.1__py3-none-any.whl

rapidtide/workflows/happy_parser.py

@@ -17,16 +17,20 @@
 #
 #
 import argparse
-from argparse import Namespace
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from typing import Any, Optional
 
 import numpy as np
-from numpy.typing import NDArray
 
 import rapidtide.io as tide_io
 import rapidtide.multiproc as tide_multiproc
 import rapidtide.workflows.parser_funcs as pf
 
+try:
+    import tensorflow as tf
+    tensorflowpresent = True
+except ImportError:
+    tensorflowpresent = False
+
 DEFAULT_ALIASEDCORRELATIONWIDTH = 5.0
 DEFAULT_PULSATILITYSIGMA = 6.0
 DEFAULT_PULSATILITYTHRESHOLD = 0.5
@@ -73,6 +77,7 @@ def _get_parser() -> Any:
         description="Hypersampling by Analytic Phase Projection - Yay!.",
         allow_abbrev=False,
     )
+    
 
     # Required arguments
     parser.add_argument(
@@ -109,18 +114,19 @@ def _get_parser() -> Any:
         help="Disable deep learning cardiac waveform filter.  ",
         default=True,
     )
-    processing_steps.add_argument(
-        "--usesuperdangerousworkaround",
-        dest="mpfix",
-        action="store_true",
-        help=(
-            "Some versions of tensorflow seem to have some weird conflict with MKL which"
-            "I don't seem to be able to fix.  If the dl filter bombs complaining about "
-            "multiple openmp libraries, try rerunning with the secret and inadvisable "
-            "'--usesuperdangerousworkaround' flag.  Good luck! "
-        ),
-        default=False,
-    )
+    if tensorflowpresent:
+        processing_steps.add_argument(
+            "--usesuperdangerousworkaround",
+            dest="mpfix",
+            action="store_true",
+            help=(
+                "Some versions of tensorflow seem to have some weird conflict with MKL which"
+                "I don't seem to be able to fix.  If the dl filter bombs complaining about "
+                "multiple openmp libraries, try rerunning with the secret and inadvisable "
+                "'--usesuperdangerousworkaround' flag.  Good luck! "
+            ),
+            default=False,
+        )
     processing_steps.add_argument(
         "--slicetimesareinseconds",
         action="store_true",
@@ -815,13 +821,14 @@ def _get_parser() -> Any:
         help="Disable the congrid value cache completely.",
         default=True,
     )
-    debug_opts.add_argument(
-        "--usetensorflow",
-        dest="usepytorch",
-        action="store_false",
-        help=("Switch to the old style tensorflow deep learning filter"),
-        default=True,
-    )
+    if tensorflowpresent:
+        debug_opts.add_argument(
+            "--usetensorflow",
+            dest="usepytorch",
+            action="store_false",
+            help=("Switch to the old style tensorflow deep learning filter"),
+            default=True,
+        )
     debug_opts.add_argument(
         "--focaldebug",
         dest="focaldebug",
@@ -833,7 +840,7 @@ def _get_parser() -> Any:
     return parser
 
 
-def process_args(inputargs: Optional[Any] = None) -> None:
+def process_args(inputargs: Optional[Any] = None) -> Any:
     """
     Compile arguments for happy workflow.
 
@@ -871,7 +878,7 @@ def process_args(inputargs: Optional[Any] = None) -> None:
 
     # save the raw and formatted command lines
     args.commandline = " ".join(argstowrite)
-    tide_io.writevec([args.commandline], args.outputroot + "_commandline.txt")
+    tide_io.writevec(np.array([args.commandline]), args.outputroot + "_commandline.txt")
     formattedcommandline = []
     for thetoken in argstowrite[0:3]:
         formattedcommandline.append(thetoken)
@@ -890,7 +897,11 @@ def process_args(inputargs: Optional[Any] = None) -> None:
         else:
             suffix = ""
         formattedcommandline[i] = prefix + formattedcommandline[i] + suffix
-    tide_io.writevec(formattedcommandline, args.outputroot + "_formattedcommandline.txt")
+    tide_io.writevec(np.array(formattedcommandline), args.outputroot + "_formattedcommandline.txt")
+
+    if not tensorflowpresent:
+        args.usepytorch = True
+        args.mpfix = False
 
     # if user did not specify a model, set the default, depending on DL library
     if args.modelname is None:

rapidtide/workflows/pairproc.py

@@ -235,9 +235,13 @@ def pairproc(args: Any) -> None:
             desc="Voxel",
             unit="voxels",
         ):
-            temporalcorrelations[vox], temporalpvalues[vox] = pearsonr(
+            thepearsonresult = pearsonr(
                 tide_math.stdnormalize(evenims[vox, :]), tide_math.stdnormalize(oddims[vox, :])
             )
+            temporalcorrelations[vox], temporalpvalues[vox] = (
+                thepearsonresult.statistic,
+                thepearsonresult.pvalue,
+            )
         print()
 
         outarray = np.zeros((xsize, ysize, numslices), dtype=np.double)
@@ -259,10 +263,14 @@ def pairproc(args: Any) -> None:
             desc="Subject",
             unit="subjects",
         ):
-            spatialcorrelations[subject], spatialpvalues[subject] = pearsonr(
+            thepearsonresult = pearsonr(
                 tide_math.stdnormalize(evenims[:, subject]),
                 tide_math.stdnormalize(oddims[:, subject]),
             )
+            spatialcorrelations[subject], spatialpvalues[subject] = (
+                thepearsonresult.statistic,
+                thepearsonresult.pvalue,
+            )
         print()
 
         tide_io.writenpvecs(

rapidtide/workflows/pixelcomp.py

@@ -25,7 +25,6 @@ from numpy.polynomial import Polynomial
 import rapidtide.io as tide_io
 
 mpl.use("Agg")
-from argparse import Namespace
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 import matplotlib.pyplot as plt
@@ -236,7 +235,7 @@ def pairdata(input1_data: Any, input2_data: Any, totalmask: Any) -> None:
 
     Returns
     -------
-    numpy.ndarray
+    NDArray
         2D array where each row contains a pair of corresponding elements
         from input1_data and input2_data at positions where totalmask > 0.
 

rapidtide/workflows/rankimage.py

@@ -94,7 +94,7 @@ def imtopercentile(image: Any, mask: Any, debug: bool = False) -> None:
 
     Returns
     -------
-    numpy.ndarray
+    NDArray
         Array of same shape as input image containing percentile scores for
         valid voxels, with zeros for masked-out voxels
 

rapidtide/workflows/rapidtide.py

@@ -67,6 +67,9 @@ LGR = logging.getLogger("GENERAL")
 ErrorLGR = logging.getLogger("ERROR")
 TimingLGR = logging.getLogger("TIMING")
 
+global rt_floattype
+rt_floattype: np.dtype = np.float64
+
 
 def checkforzeromean(thedataset: Any) -> bool:
     """
@@ -366,25 +369,21 @@ def rapidtide_main(argparsingfunc: Any) -> None:
         tide_util.disablenumba()
 
     # set the internal precision
-    global rt_floatset, rt_floattype
+    global rt_floattype
     if optiondict["internalprecision"] == "double":
         LGR.debug("setting internal precision to double")
-        rt_floattype = "float64"
-        rt_floatset = np.float64
+        rt_floattype = np.float64
     else:
         LGR.debug("setting internal precision to single")
-        rt_floattype = "float32"
-        rt_floatset = np.float32
+        rt_floattype = np.float32
 
     # set the output precision
     if optiondict["outputprecision"] == "double":
         LGR.debug("setting output precision to double")
-        rt_outfloattype = "float64"
-        rt_outfloatset = np.float64
+        rt_outfloattype = np.float64
     else:
         LGR.debug("setting output precision to single")
-        rt_outfloattype = "float32"
-        rt_outfloatset = np.float32
+        rt_outfloattype = np.float32
 
     # set the number of worker processes if multiprocessing
     if optiondict["nprocs"] < 1:
@@ -540,8 +539,8 @@ def rapidtide_main(argparsingfunc: Any) -> None:
             )
             anatomicmasks[-1] = np.uint16(np.where(anatomicmasks[-1] > 0.1, 1, 0))
         else:
-            anatomicmasks.append(None)
-            # anatomicmasks[-1] = np.uint16(np.ones(nativespaceshape, dtype=np.uint16))
+            anatomicmasks.append(np.uint16(np.ones(nativespaceshape, dtype=np.uint16)))
+
     brainmask = anatomicmasks[0]
     graymask = anatomicmasks[1]
     whitemask = anatomicmasks[2]
@@ -793,7 +792,7 @@ def rapidtide_main(argparsingfunc: Any) -> None:
         LGR.info("moving fmri data to shared memory")
         TimingLGR.verbose("Start moving fmri_data to shared memory")
         fmri_data_valid, fmri_data_valid_shm = tide_util.numpy2shared(
-            fmri_data_valid, rt_floatset, name=f"fmri_data_valid_{optiondict['pid']}"
+            fmri_data_valid, rt_floattype, name=f"fmri_data_valid_{optiondict['pid']}"
         )
         TimingLGR.verbose("End moving fmri_data to shared memory")
 
@@ -1263,7 +1262,7 @@ def rapidtide_main(argparsingfunc: Any) -> None:
             padlen=int(inputfreq * optiondict["padseconds"]),
             debug=optiondict["debug"],
         )
-        reference_y = rt_floatset(reference_y_filt.real)
+        reference_y = (reference_y_filt.real).astype(rt_floattype)
 
     warnings.filterwarnings("ignore", "Casting*")
 
@@ -1324,11 +1323,11 @@ def rapidtide_main(argparsingfunc: Any) -> None:
     # save the factor used to normalize the input regressor
     optiondict["initialmovingregressornormfac"] = np.std(resampnonosref_y)
 
-    # prepare the temporal mask
+    # prepare the temporal masks
     if optiondict["tincludemaskname"] is not None:
         print("creating temporal include mask")
         includetmask_y = tide_mask.maketmask(
-            optiondict["tincludemaskname"], reference_x, rt_floatset(reference_y) + 0.0
+            optiondict["tincludemaskname"], reference_x, reference_y.astype(rt_floattype) + 0.0
         )
     else:
         includetmask_y = (reference_x * 0.0) + 1.0
@@ -1337,7 +1336,7 @@ def rapidtide_main(argparsingfunc: Any) -> None:
         excludetmask_y = (
             -1.0
             * tide_mask.maketmask(
-                optiondict["texcludemaskname"], reference_x, rt_floatset(reference_y) + 0.0
+                optiondict["texcludemaskname"], reference_x, reference_y.astype(rt_floattype) + 0.0
             )
             + 1.0
         )
@@ -1373,6 +1372,9 @@ def rapidtide_main(argparsingfunc: Any) -> None:
     else:
         tmaskos_y = None
 
+    # construct refine temporal masks here
+    optiondict["windowedrefinemasks"] = None
+
     (
         optiondict["kurtosis_reference_pass1"],
         optiondict["kurtosisz_reference_pass1"],
@@ -1547,7 +1549,7 @@ def rapidtide_main(argparsingfunc: Any) -> None:
     fitmask = np.zeros(internalvalidspaceshape, dtype="uint16")
     failreason = np.zeros(internalvalidspaceshape, dtype="uint32")
     R2 = np.zeros(internalvalidspaceshape, dtype=rt_floattype)
-    outmaparray = np.zeros(internalspaceshape, dtype=rt_floattype)
+    outmaparray = np.zeros((internalspaceshape), dtype=rt_floattype)
     tide_util.logmem("after main array allocation")
 
     if optiondict["similaritymetric"] == "riptide":
@@ -1563,7 +1565,6 @@ def rapidtide_main(argparsingfunc: Any) -> None:
             chunksize=optiondict["mp_chunksize"],
             nprocs=optiondict["nprocs"],
             alwaysmultiproc=optiondict["alwaysmultiproc"],
-            rt_floatset=rt_floatset,
             rt_floattype=rt_floattype,
             debug=optiondict["debug"],
         )
@@ -1589,25 +1590,25 @@ def rapidtide_main(argparsingfunc: Any) -> None:
 
     corrout, corrout_shm = tide_util.allocarray(
         internalvalidcorrshape,
-        rt_floatset,
+        rt_floattype,
         shared=optiondict["sharedmem"],
         name=f"corrout_{optiondict['pid']}",
     )
     gaussout, gaussout_shm = tide_util.allocarray(
         internalvalidcorrshape,
-        rt_floatset,
+        rt_floattype,
         shared=optiondict["sharedmem"],
         name=f"gaussout_{optiondict['pid']}",
     )
     windowout, windowout_shm = tide_util.allocarray(
         internalvalidcorrshape,
-        rt_floatset,
+        rt_floattype,
         shared=optiondict["sharedmem"],
         name=f"windowout_{optiondict['pid']}",
     )
     outcorrarray, outcorrarray_shm = tide_util.allocarray(
         internalcorrshape,
-        rt_floatset,
+        rt_floattype,
         shared=optiondict["sharedmem"],
         name=f"outcorrarray_{optiondict['pid']}",
     )
@@ -1778,7 +1779,7 @@ def rapidtide_main(argparsingfunc: Any) -> None:
             fastresamplerpadtime=optiondict["fastresamplerpadtime"],
             prewhitenregressor=False,
             prewhitenlags=optiondict["prewhitenlags"],
-            debug=optiondict["focaldebug"],
+            debug=optiondict["debug"],
         )
 
     # cycle over all voxels
@@ -1839,7 +1840,6 @@ def rapidtide_main(argparsingfunc: Any) -> None:
             interptype=optiondict["interptype"],
             showprogressbar=optiondict["showprogressbar"],
             chunksize=optiondict["mp_chunksize"],
-            rt_floatset=rt_floatset,
             rt_floattype=rt_floattype,
         )
         tide_util.enablemkl(optiondict["mklthreads"], debug=optiondict["threaddebug"])
@@ -1892,7 +1892,7 @@ def rapidtide_main(argparsingfunc: Any) -> None:
     # Preprocessing - prewhitening
     if optiondict["prewhitenregressor"]:
         resampref_y = tide_fit.prewhiten(
-            resampref_y, optiondict["prewhitenlags"], debug=optiondict["focaldebug"]
+            resampref_y, optiondict["prewhitenlags"], debug=optiondict["debug"]
         )
         tide_io.writebidstsv(
             f"{outputname}_desc-oversampledmovingregressor_timeseries",
@@ -1992,7 +1992,6 @@ def rapidtide_main(argparsingfunc: Any) -> None:
             respdelete=optiondict["respdelete"],
             debug=optiondict["debug"],
             rt_floattype=rt_floattype,
-            rt_floatset=rt_floatset,
         )
         if optiondict["debug"]:
             print(
@@ -2045,8 +2044,7 @@ def rapidtide_main(argparsingfunc: Any) -> None:
                 showprogressbar=optiondict["showprogressbar"],
                 chunksize=optiondict["mp_chunksize"],
                 permutationmethod=optiondict["permutationmethod"],
-                rt_floatset=np.float64,
-                rt_floattype="float64",
+                rt_floattype=np.float64,
             )
             tide_util.enablemkl(optiondict["mklthreads"], debug=optiondict["threaddebug"])
 
@@ -2190,7 +2188,6 @@ def rapidtide_main(argparsingfunc: Any) -> None:
             interptype=optiondict["interptype"],
             showprogressbar=optiondict["showprogressbar"],
             chunksize=optiondict["mp_chunksize"],
-            rt_floatset=rt_floatset,
             rt_floattype=rt_floattype,
             threaddebug=optiondict["threaddebug"],
             debug=optiondict["debug"],
@@ -2260,8 +2257,7 @@ def rapidtide_main(argparsingfunc: Any) -> None:
             LGR,
             TimingLGR,
             simplefit=(optiondict["similaritymetric"] == "riptide"),
-            rt_floatset=np.float64,
-            rt_floattype="float64",
+            rt_floattype=np.float64,
         )
 
         # Step 2b - refine delay (optional)
@@ -2313,7 +2309,6 @@ def rapidtide_main(argparsingfunc: Any) -> None:
                 maxdelay=optiondict["maxdelay"],
                 numpoints=optiondict["numpoints"],
                 histlen=optiondict["histlen"],
-                rt_floatset=rt_floatset,
                 rt_floattype=rt_floattype,
                 debug=optiondict["debug"],
             )
@@ -2338,7 +2333,7 @@ def rapidtide_main(argparsingfunc: Any) -> None:
                     cifti_hdr=theinputdata.cifti_hdr,
                 )
 
-        # Step 2b - make a rank order map
+        # Step 2c - make a rank order map
         timepercentile = (
             100.0 * (rankdata(lagtimes, method="dense") - 1) / (numvalidspatiallocs - 1)
         )
@@ -2380,7 +2375,7 @@ def rapidtide_main(argparsingfunc: Any) -> None:
             or optiondict["initregressorpreselect"]
             or optiondict["dofinalrefine"]
         ):
-            (resampref_y, resampnonosref_y, stoprefining, refinestopreason, genlagtc) = (
+            resampref_y, resampnonosref_y, stoprefining, refinestopreason, genlagtc = (
                 tide_refineRegressor.refineRegressor(
                     LGR,
                     TimingLGR,
@@ -2407,8 +2402,7 @@ def rapidtide_main(argparsingfunc: Any) -> None:
                     outputname,
                     nativefmrishape,
                     bidsbasedict,
-                    rt_floatset=np.float64,
-                    rt_floattype="float64",
+                    rt_floattype=np.float64,
                 )
             )
         # End of main pass loop
@@ -2475,19 +2469,19 @@ def rapidtide_main(argparsingfunc: Any) -> None:
         # now allocate the arrays needed for the coherence calculation
         coherencefunc, coherencefunc_shm = tide_util.allocarray(
             internalvalidcoherenceshape,
-            rt_outfloatset,
+            rt_outfloattype,
             shared=optiondict["sharedmem"],
             name=f"coherencefunc_{optiondict['pid']}",
         )
         coherencepeakval, coherencepeakval_shm = tide_util.allocarray(
             numvalidspatiallocs,
-            rt_outfloatset,
+            rt_outfloattype,
             shared=optiondict["sharedmem"],
             name=f"coherencepeakval_{optiondict['pid']}",
         )
         coherencepeakfreq, coherencepeakfreq_shm = tide_util.allocarray(
             numvalidspatiallocs,
-            rt_outfloatset,
+            rt_outfloattype,
             shared=optiondict["sharedmem"],
             name=f"coherencepeakfreq_{optiondict['pid']}",
         )
@@ -2551,13 +2545,13 @@ def rapidtide_main(argparsingfunc: Any) -> None:
         # now allocate the arrays needed for Wiener deconvolution
         wienerdeconv, wienerdeconv_shm = tide_util.allocarray(
             internalvalidspaceshape,
-            rt_outfloatset,
+            rt_outfloattype,
             shared=optiondict["sharedmem"],
             name=f"wienerdeconv_{optiondict['pid']}",
         )
         wpeak, wpeak_shm = tide_util.allocarray(
             internalvalidspaceshape,
-            rt_outfloatset,
+            rt_outfloattype,
             shared=optiondict["sharedmem"],
             name=f"wpeak_{optiondict['pid']}",
         )
@@ -2578,7 +2572,6 @@ def rapidtide_main(argparsingfunc: Any) -> None:
             wienerdeconv,
             wpeak,
             resampref_y,
-            rt_floatset=rt_floatset,
             rt_floattype=rt_floattype,
         )
         TimingLGR.info(
@@ -2641,7 +2634,7 @@ def rapidtide_main(argparsingfunc: Any) -> None:
 
             if optiondict["docvrmap"]:
                 # percent normalize the fmri data
-                LGR.info("normalzing data for CVR map")
+                LGR.info("normalizing data for CVR map")
                 themean = np.mean(fmri_data_valid, axis=1)
                 fmri_data_valid /= themean[:, None]
 
@@ -2662,7 +2655,7 @@ def rapidtide_main(argparsingfunc: Any) -> None:
                 TimingLGR.info("Start moving fmri_data to shared memory")
                 fmri_data_valid, fmri_data_valid_shm = tide_util.numpy2shared(
                     fmri_data_valid,
-                    rt_floatset,
+                    rt_floattype,
                     name=f"fmri_data_valid_regressionfilt_{optiondict['pid']}",
                 )
                 TimingLGR.info("End moving fmri_data to shared memory")
@@ -2778,11 +2771,56 @@ def rapidtide_main(argparsingfunc: Any) -> None:
                 maxdelay=optiondict["maxdelay"],
                 numpoints=optiondict["numpoints"],
                 histlen=optiondict["histlen"],
-                rt_floatset=rt_floatset,
                 rt_floattype=rt_floattype,
                 debug=optiondict["debug"],
             )
             lagtimesrefined = lagtimes + delayoffset
+
+            if optiondict["windowedrefinemasks"] is not None:
+                windoweddelayoffsets = []
+                for thetimemask in optiondict["windowedrefinemasks"]:
+                    (
+                        windoweddelayoffset,
+                        dummy,
+                        dummy,
+                        dummy,
+                        dummy,
+                    ) = tide_refineDelayMap.refineDelay(
+                        fmri_data_valid,
+                        initial_fmri_x,
+                        xdim,
+                        ydim,
+                        slicethickness,
+                        sLFOfiltmask,
+                        genlagtc,
+                        oversamptr,
+                        sLFOfitmean,
+                        rvalue,
+                        r2value,
+                        fitNorm,
+                        fitcoeff,
+                        lagtc,
+                        outputname,
+                        validvoxels,
+                        nativespaceshape,
+                        theinputdata,
+                        lagtimes,
+                        optiondict,
+                        LGR,
+                        TimingLGR,
+                        outputlevel=optiondict["outputlevel"],
+                        gausssigma=optiondict["delayoffsetgausssigma"],
+                        patchthresh=optiondict["delaypatchthresh"],
+                        timemask=thetimemask,
+                        mindelay=optiondict["mindelay"],
+                        maxdelay=optiondict["maxdelay"],
+                        numpoints=optiondict["numpoints"],
+                        histlen=optiondict["histlen"],
+                        rt_floattype=rt_floattype,
+                        debug=optiondict["debug"],
+                    )
+                    windoweddelayoffsets.append(windoweddelayoffset)
+
             ####################################################
             #  Delay refinement end
             ####################################################
@@ -3319,25 +3357,22 @@ def rapidtide_main(argparsingfunc: Any) -> None:
                     None,
                     "Percentage of inband variance attributable to CVR regressor",
                 ),
+                (rvalue, "CVRR", "map", None, "R value of the sLFO fit"),
+                (
+                    r2value,
+                    "CVRR2",
+                    "map",
+                    None,
+                    "Squared R value of the sLFO fit (proportion of variance explained)",
+                ),
+                (
+                    fitcoeff[:, 0],
+                    "CVR",
+                    "map",
+                    "percent",
+                    "Percent signal change due to the CVR regressor",
+                )
             ]
-            if optiondict["savenormalsLFOfiltfiles"]:
-                maplist = [
-                    (rvalue, "CVRR", "map", None, "R value of the sLFO fit"),
-                    (
-                        r2value,
-                        "CVRR2",
-                        "map",
-                        None,
-                        "Squared R value of the sLFO fit (proportion of variance explained)",
-                    ),
-                    (
-                        fitcoeff,
-                        "CVR",
-                        "map",
-                        "percent",
-                        "Percent signal change due to the CVR regressor",
-                    ),
-                ]
 
         tide_io.savemaplist(
             outputname,

rapidtide/workflows/refineDelayMap.py

@@ -51,12 +51,12 @@ def refineDelay(
     outputlevel: str = "normal",
     gausssigma: int = -1,
     patchthresh: float = 3.0,
+    timemask: NDArray | None = None,
     mindelay: float = -5.0,
     maxdelay: float = 5.0,
     numpoints: int = 501,
     histlen: int = 101,
-    rt_floatset: Any = np.float64,
-    rt_floattype: str = "float64",
+    rt_floattype: np.dtype = np.float64,
     debug: bool = False,
 ) -> None:
     """
@@ -118,6 +118,8 @@ def refineDelay(
         Sigma for Gaussian filtering, default is -1 (no filtering).
     patchthresh : float, optional
         Threshold for patch-based filtering, default is 3.0.
+    timemask : NDArray, optional
+       Mask of timepoints to include in regression filtering. Default is None.
     mindelay : float, optional
         Minimum delay value, default is -5.0.
     maxdelay : float, optional
@@ -126,10 +128,8 @@ def refineDelay(
         Number of points for delay interpolation, default is 501.
     histlen : int, optional
         Length of histogram bins, default is 101.
-    rt_floatset : Any, optional
-        Data type for real-time float operations, default is np.float64.
-    rt_floattype : str, optional
-        String representation of float type, default is "float64".
+    rt_floattype : np.dtype, optional
+        Data type for rapidtide float operations, default is np.float64.
     debug : bool, optional
         Enable debug mode, default is False.
 
@@ -190,6 +190,7 @@ def refineDelay(
         TimingLGR,
         optiondict,
         regressderivs=1,
+        timemask=timemask,
         debug=debug,
     )