rapidtide 2.9.5__py3-none-any.whl → 3.1.3__py3-none-any.whl

rapidtide/workflows/rapidtide.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #
-#   Copyright 2016-2024 Blaise Frederick
+#   Copyright 2016-2025 Blaise Frederick
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
 #   you may not use this file except in compliance with the License.
@@ -16,23 +16,18 @@
 #   limitations under the License.
 #
 #
-import bisect
-import copy
 import gc
 import logging
-import multiprocessing as mp
 import os
 import platform
 import sys
 import warnings
 from pathlib import Path
+from typing import Any, Tuple
 
 import numpy as np
-from nilearn import masking
-from scipy import ndimage
+from numpy.typing import NDArray
 from scipy.stats import rankdata
-from sklearn.decomposition import PCA
-from tqdm import tqdm
 
 import rapidtide.calccoherence as tide_calccoherence
 import rapidtide.calcnullsimfunc as tide_nullsimfunc
@@ -40,22 +35,25 @@ import rapidtide.calcsimfunc as tide_calcsimfunc
 import rapidtide.correlate as tide_corr
 import rapidtide.filter as tide_filt
 import rapidtide.fit as tide_fit
-import rapidtide.glmpass as tide_glmpass
 import rapidtide.helper_classes as tide_classes
 import rapidtide.io as tide_io
-import rapidtide.makelaggedtcs as tide_makelagged
+import rapidtide.linfitfiltpass as tide_linfitfiltpass
 import rapidtide.maskutil as tide_mask
 import rapidtide.miscmath as tide_math
 import rapidtide.multiproc as tide_multiproc
-import rapidtide.peakeval as tide_peakeval
-import rapidtide.refine_factored as tide_refine
 import rapidtide.resample as tide_resample
-import rapidtide.simfuncfit as tide_simfuncfit
+import rapidtide.simFuncClasses as tide_simFuncClasses
 import rapidtide.stats as tide_stats
 import rapidtide.util as tide_util
+import rapidtide.voxelData as tide_voxelData
 import rapidtide.wiener as tide_wiener
-import rapidtide.workflows.glmfrommaps as tide_glmfrommaps
-from rapidtide.tests.utils import mse
+import rapidtide.workflows.calcSimFuncMap as tide_calcSimFuncMap
+import rapidtide.workflows.cleanregressor as tide_cleanregressor
+import rapidtide.workflows.fitSimFuncMap as tide_fitSimFuncMap
+import rapidtide.workflows.refineDelayMap as tide_refineDelayMap
+import rapidtide.workflows.refineRegressor as tide_refineRegressor
+import rapidtide.workflows.regressfrommaps as tide_regressfrommaps
+from rapidtide.ffttools import showfftcache
 
 from .utils import setup_logger
 
@@ -66,110 +64,44 @@ try:
 except ImportError:
     mklexists = False
 
-try:
-    from memory_profiler import profile
-
-    memprofilerexists = True
-except ImportError:
-    memprofilerexists = False
-
 LGR = logging.getLogger("GENERAL")
 ErrorLGR = logging.getLogger("ERROR")
 TimingLGR = logging.getLogger("TIMING")
 
-
-def conditionalprofile():
-    def resdec(f):
-        if memprofilerexists:
-            return profile(f)
-        return f
-
-    return resdec
-
-
-@conditionalprofile()
-def memcheckpoint(message):
-    LGR.info(message)
-
-
-def getglobalsignal(
-    indata, optiondict, includemask=None, excludemask=None, pcacomponents=0.8, debug=False
-):
-    # Start with all voxels
-    themask = indata[:, 0] * 0 + 1
-
-    # modify the mask if needed
-    if includemask is not None:
-        themask = themask * includemask
-    if excludemask is not None:
-        themask = themask * (1 - excludemask)
-
-    # combine all the voxels using one of the three methods
-    global rt_floatset, rt_floattype
-    globalmean = rt_floatset(indata[0, :])
-    thesize = np.shape(themask)
-    numvoxelsused = int(np.sum(np.where(themask > 0.0, 1, 0)))
-    selectedvoxels = indata[np.where(themask > 0.0), :][0]
-    if debug:
-        print(f"getglobalsignal: {selectedvoxels.shape=}")
-    LGR.info(f"constructing global mean signal using {optiondict['globalsignalmethod']}")
-    if optiondict["globalsignalmethod"] == "sum":
-        globalmean = np.mean(selectedvoxels, axis=0)
-        globalmean -= np.mean(globalmean)
-    elif optiondict["globalsignalmethod"] == "meanscale":
-        themean = np.mean(indata, axis=1)
-        for vox in range(0, thesize[0]):
-            if themask[vox] > 0.0:
-                if themean[vox] != 0.0:
-                    globalmean += indata[vox, :] / themean[vox] - 1.0
-    elif optiondict["globalsignalmethod"] == "pca":
-        themean = np.mean(indata, axis=1)
-        thevar = np.var(indata, axis=1)
-        scaledvoxels = selectedvoxels * 0.0
-        for vox in range(0, selectedvoxels.shape[0]):
-            scaledvoxels[vox, :] = selectedvoxels[vox, :] - themean[vox]
-            if thevar[vox] > 0.0:
-                scaledvoxels[vox, :] = selectedvoxels[vox, :] / thevar[vox]
-        try:
-            thefit = PCA(n_components=pcacomponents).fit(np.transpose(scaledvoxels))
-        except ValueError:
-            if pcacomponents == "mle":
-                LGR.warning("mle estimation failed - falling back to pcacomponents=0.8")
-                thefit = PCA(n_components=0.8).fit(np.transpose(scaledvoxels))
-            else:
-                raise ValueError("unhandled math exception in PCA refinement - exiting")
-
-        varex = 100.0 * np.cumsum(thefit.explained_variance_ratio_)[len(thefit.components_) - 1]
-        thetransform = thefit.transform(np.transpose(scaledvoxels))
-        if debug:
-            print(f"getglobalsignal: {thetransform.shape=}")
-        globalmean = np.mean(thetransform, axis=0)
-        globalmean -= np.mean(globalmean)
-        if debug:
-            print(f"getglobalsignal: {varex=}")
-        LGR.info(
-            f"Using {len(thefit.components_)} component(s), accounting for "
-            f"{varex:.2f}% of the variance"
-        )
-    elif optiondict["globalsignalmethod"] == "random":
-        globalmean = np.random.standard_normal(size=len(globalmean))
-    else:
-        raise ValueError(f"illegal globalsignalmethod: {optiondict['globalsignalmethod']}")
-    LGR.info(f"used {numvoxelsused} voxels to calculate global mean signal")
-    if debug:
-        print(f"getglobalsignal: {globalmean=}")
-    return tide_math.stdnormalize(globalmean), themask
-
-
-def addmemprofiling(thefunc, memprofile, themessage):
-    if memprofile:
-        return profile(thefunc, precision=2)
-    else:
-        tide_util.logmem(themessage)
-        return thefunc
-
-
-def checkforzeromean(thedataset):
+global rt_floattype
+rt_floattype: np.dtype = np.float64
+
+
+def checkforzeromean(thedataset: Any) -> bool:
+    """
+    Check if the mean of dataset is zero.
+
+    Parameters
+    ----------
+    thedataset : array-like
+        Input dataset to check for zero mean. Should be array-like structure
+        that can be processed by numpy mean and std functions.
+
+    Returns
+    -------
+    bool
+        True if the mean of standard deviations is greater than the mean of means,
+        False otherwise.
+
+    Notes
+    -----
+    This function calculates the mean and standard deviation along axis 1,
+    then compares the means of these two arrays. The function name suggests
+    checking for zero mean, but the implementation actually compares means
+    and standard deviations rather than directly checking if mean equals zero.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> data = np.array([[1, 2, 3], [4, 5, 6]])
+    >>> checkforzeromean(data)
+    False
+    """
     themean = np.mean(thedataset, axis=1)
     thestd = np.std(thedataset, axis=1)
     if np.mean(thestd) > np.mean(themean):
@@ -178,7 +110,59 @@ def checkforzeromean(thedataset):
         return False
 
 
-def echocancel(thetimecourse, echooffset, thetimestep, outputname, padtimepoints):
+def echocancel(
+    thetimecourse: Any, echooffset: Any, thetimestep: Any, outputname: Any, padtimepoints: Any
+) -> Tuple[NDArray, NDArray, float]:
+    """
+    Perform echo cancellation on a timecourse using linear regression.
+
+    This function applies echo cancellation to a given timecourse by modeling the echo signal
+    and subtracting its contribution from the original signal. The echo is shifted in time
+    according to `echooffset` and then fitted using maximum likelihood regression. The
+    resulting filtered timecourse is saved along with the original and echo components.
+
+    Parameters
+    ----------
+    thetimecourse : array-like
+        The input timecourse data to be processed.
+    echooffset : float
+        The time offset (in seconds) of the echo signal relative to the input timecourse.
+    thetimestep : float
+        The time step (in seconds) of the input timecourse.
+    outputname : str
+        Base name for output files; used to construct filenames for saved results.
+    padtimepoints : int
+        Number of timepoints to pad during resampling of the echo signal.
+
+    Returns
+    -------
+    tuple
+        A tuple containing:
+        - `outputtimecourse`: The timecourse after echo cancellation.
+        - `echofit`: The regression coefficients from fitting the echo signal.
+        - `echoR2`: The R-squared value of the echo fit.
+
+    Notes
+    -----
+    - The function writes three separate TSV files:
+        1. Original timecourse.
+        2. Echo signal.
+        3. Filtered (echo-cancelled) timecourse.
+    - The echo signal is shifted in time using `tide_resample.timeshift`.
+    - The echo is zeroed out at the beginning up to the computed shift.
+    - The function uses `tide_fit.mlregress` for linear regression fitting.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> timecourse = np.random.rand(100)
+    >>> echo_offset = 2.0
+    >>> time_step = 1.0
+    >>> output_name = "test_output"
+    >>> pad_points = 10
+    >>> result = echocancel(timecourse, echo_offset, time_step, output_name, pad_points)
+    >>> filtered_tc, fit_coeffs, r2 = result
+    """
     tide_io.writebidstsv(
         f"{outputname}_desc-echocancellation_timeseries",
         thetimecourse,
@@ -192,7 +176,7 @@ def echocancel(thetimecourse, echooffset, thetimestep, outputname, padtimepoints
     shifttr = echooffset / thetimestep  # lagtime is in seconds
     echotc, dummy, dummy, dummy = tide_resample.timeshift(thetimecourse, shifttr, padtimepoints)
     echotc[0 : int(np.ceil(shifttr))] = 0.0
-    echofit, echoR = tide_fit.mlregress(echotc, thetimecourse)
+    echofit, echoR2 = tide_fit.mlregress(echotc, thetimecourse)
     fitcoeff = echofit[0, 1]
     outputtimecourse = thetimecourse - fitcoeff * echotc
     tide_io.writebidstsv(
@@ -215,27 +199,88 @@ def echocancel(thetimecourse, echooffset, thetimestep, outputname, padtimepoints
         },
         append=True,
     )
-    return outputtimecourse, echofit, echoR
-
-
-def disablemkl(numprocs, debug=False):
-    if mklexists:
-        if numprocs > 1:
-            if debug:
-                print("disablemkl: setting threads to 1")
-            mkl.set_num_threads(1)
-
-
-def enablemkl(numthreads, debug=False):
-    if mklexists:
-        if debug:
-            print(f"enablemkl: setting threads to {numthreads}")
-        mkl.set_num_threads(numthreads)
-
-
-def rapidtide_main(argparsingfunc):
-    threaddebug = False
+    return outputtimecourse, echofit, echoR2
+
+
+def setpassoptions(passdict: Any, optiondict: Any) -> None:
+    """
+    Copy key-value pairs from passdict to optiondict.
+
+    This function updates the optiondict with key-value pairs from passdict,
+    effectively passing options from one dictionary to another.
+
+    Parameters
+    ----------
+    passdict : Any
+        Dictionary containing options to be passed
+    optiondict : Any
+        Dictionary that will receive the options from passdict
+
+    Returns
+    -------
+    None
+        This function modifies optiondict in-place and returns None
+
+    Notes
+    -----
+    This function performs an in-place update of optiondict. Any existing keys
+    in optiondict that are also present in passdict will be overwritten with
+    the values from passdict.
+
+    Examples
+    --------
+    >>> options = {'verbose': True, 'timeout': 30}
+    >>> new_options = {'debug': False}
+    >>> setpassoptions(options, new_options)
+    >>> print(new_options)
+    {'debug': False, 'verbose': True, 'timeout': 30}
+    """
+    for key, value in passdict.items():
+        optiondict[key] = value
+
+
+def rapidtide_main(argparsingfunc: Any) -> None:
+    """
+    Process fMRI data to perform spatially localized signal-to-noise ratio (sLFO) analysis.
+
+    This function performs a comprehensive analysis of fMRI data including correlation
+    analysis, signal filtering, and various statistical computations to identify and
+    remove spatially localized noise components.
+
+    Parameters
+    ----------
+    None
+
+    Returns
+    -------
+    None
+        The function performs in-place processing and saves results to files.
+
+    Notes
+    -----
+    This function is designed to be called as part of a larger pipeline for fMRI
+    preprocessing and analysis. It handles multiple stages including:
+
+    1. Data initialization and validation
+    2. Correlation analysis across spatial locations
+    3. Signal filtering and noise removal
+    4. Statistical computations and result saving
+    5. Timing and logging management
+
+    Examples
+    --------
+    >>> process_fmri_data()
+    # Processes fMRI data and saves results to output files
+
+    See Also
+    --------
+    tide_regressfrommaps : Performs regression analysis on fMRI data
+    tide_io : Handles input/output operations for fMRI data
+    tide_util : Utility functions for processing fMRI data
+
+    """
     optiondict, theprefilter = argparsingfunc
+    optiondict["threaddebug"] = False
 
     optiondict["nodename"] = platform.node()
 
@@ -251,10 +296,16 @@ def rapidtide_main(argparsingfunc):
     optiondict["Description"] = (
         "A detailed dump of all internal variables in the program.  Useful for debugging and data provenance."
     )
-    fmrifilename = optiondict["in_file"]
+    inputdatafilename = optiondict["in_file"]
     outputname = optiondict["outputname"]
     regressorfilename = optiondict["regressorfile"]
 
+    # get the pid of the parent process
+    optiondict["pid"] = os.getpid()
+
+    # delete the old completion file, if present
+    Path(f"{outputname}_DONE.txt").unlink(missing_ok=True)
+
     # create the canary file
     Path(f"{outputname}_ISRUNNING.txt").touch()
 
@@ -265,16 +316,21 @@ def rapidtide_main(argparsingfunc):
         gc.enable()
         print("turning on garbage collection")
 
-    # if we are running in a Docker container, make sure we enforce memory limits properly
-    try:
-        testval = os.environ["IS_DOCKER_8395080871"]
-    except KeyError:
-        optiondict["runningindocker"] = False
-    else:
-        optiondict["runningindocker"] = True
-        optiondict["dockermemfree"], optiondict["dockermemswap"] = tide_util.findavailablemem()
-        if optiondict["dockermemfix"]:
-            tide_util.setmemlimit(optiondict["dockermemfree"])
+    # If running in Docker or Apptainer/Singularity, this is necessary to enforce memory limits properly
+    # otherwise likely to  error out in gzip.py or at voxelnormalize step.  But do nothing if running in CircleCI
+    # because it does NOT like you messing with the container.
+    optiondict["containertype"] = tide_util.checkifincontainer()
+    if optiondict["containertype"] is not None:
+        if optiondict["containertype"] != "CircleCI":
+            optiondict["containermemfree"], optiondict["containermemswap"] = (
+                tide_util.findavailablemem()
+            )
+            tide_util.setmemlimit(optiondict["containermemfree"])
+        else:
+            print("running in CircleCI environment - not messing with memory")
+
+    # load pyfftw wisdom
+    optiondict["pyfftw_wisdom"] = tide_util.configurepyfftw()
 
     # write out the current version of the run options
     optiondict["currentstage"] = "init"
@@ -285,7 +341,7 @@ def rapidtide_main(argparsingfunc):
         logger_filename=f"{outputname}_log.txt",
         timing_filename=f"{outputname}_runtimings.tsv",
         memory_filename=f"{outputname}_memusage.tsv",
-        verbose=optiondict["verbose"],
+        isverbose=optiondict["verbose"],
         debug=optiondict["debug"],
     )
     TimingLGR.info("Start")
@@ -317,25 +373,21 @@ def rapidtide_main(argparsingfunc):
         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.dtype(np.float64)
     else:
         LGR.debug("setting internal precision to single")
-        rt_floattype = "float32"
-        rt_floatset = np.float32
+        rt_floattype = np.dtype(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.dtype(np.float64)
     else:
         LGR.debug("setting output precision to single")
-        rt_outfloattype = "float32"
-        rt_outfloatset = np.float32
+        rt_outfloattype = np.dtype(np.float32)
 
     # set the number of worker processes if multiprocessing
     if optiondict["nprocs"] < 1:
@@ -376,100 +428,43 @@ def rapidtide_main(argparsingfunc):
     else:
         optiondict["nprocs_makelaggedtcs"] = optiondict["nprocs"]
 
-    if optiondict["singleproc_glm"]:
-        optiondict["nprocs_glm"] = 1
+    if optiondict["singleproc_regressionfilt"]:
+        optiondict["nprocs_regressionfilt"] = 1
     else:
-        optiondict["nprocs_glm"] = optiondict["nprocs"]
+        optiondict["nprocs_regressionfilt"] = optiondict["nprocs"]
 
     # set the number of MKL threads to use
     if mklexists:
         mklmaxthreads = mkl.get_max_threads()
         if not (1 <= optiondict["mklthreads"] <= mklmaxthreads):
             optiondict["mklthreads"] = mklmaxthreads
-        enablemkl(optiondict["mklthreads"], debug=threaddebug)
+        tide_util.enablemkl(optiondict["mklthreads"], debug=optiondict["threaddebug"])
         LGR.info(f"using {optiondict['mklthreads']} MKL threads")
 
     # Generate MemoryLGR output file with column names
-    if not optiondict["memprofile"]:
-        tide_util.logmem()
+    tide_util.logmem()
 
     ####################################################
     #  Read data
     ####################################################
-    # open the fmri datafile
-    tide_util.logmem("before reading in fmri data")
-    if tide_io.checkiftext(fmrifilename):
-        LGR.debug("input file is text - all I/O will be to text files")
-        optiondict["textio"] = True
-        if optiondict["gausssigma"] > 0.0:
-            optiondict["gausssigma"] = 0.0
-            LGR.info("gaussian spatial filter disabled for text input files")
-    else:
-        optiondict["textio"] = False
-
-    if optiondict["textio"]:
-        nim_data = tide_io.readvecs(fmrifilename)
-        nim_hdr = None
-        theshape = np.shape(nim_data)
-        xsize = theshape[0]
-        ysize = 1
-        numslices = 1
-        fileiscifti = False
-        timepoints = theshape[1]
-        thesizes = [0, int(xsize), 1, 1, int(timepoints)]
-        numspatiallocs = int(xsize)
-        nativespaceshape = xsize
-        cifti_hdr = None
-    else:
-        fileiscifti = tide_io.checkifcifti(fmrifilename)
-        if fileiscifti:
-            LGR.debug("input file is CIFTI")
-            (
-                cifti,
-                cifti_hdr,
-                nim_data,
-                nim_hdr,
-                thedims,
-                thesizes,
-                dummy,
-            ) = tide_io.readfromcifti(fmrifilename)
-            optiondict["isgrayordinate"] = True
-            timepoints = nim_data.shape[1]
-            numspatiallocs = nim_data.shape[0]
-            LGR.debug(f"cifti file has {timepoints} timepoints, {numspatiallocs} numspatiallocs")
-            slicesize = numspatiallocs
-            nativespaceshape = (1, 1, 1, 1, numspatiallocs)
-        else:
-            LGR.debug("input file is NIFTI")
-            nim, nim_data, nim_hdr, thedims, thesizes = tide_io.readfromnifti(fmrifilename)
-            optiondict["isgrayordinate"] = False
-            xsize, ysize, numslices, timepoints = tide_io.parseniftidims(thedims)
-            numspatiallocs = int(xsize) * int(ysize) * int(numslices)
-            cifti_hdr = None
-            nativespaceshape = (xsize, ysize, numslices)
-        xdim, ydim, slicethickness, tr = tide_io.parseniftisizes(thesizes)
-
-    # correct some fields if necessary
-    if fileiscifti:
-        fmritr = 0.72  # this is wrong and is a hack until I can parse CIFTI XML
-    else:
-        if optiondict["textio"]:
-            if optiondict["realtr"] <= 0.0:
-                raise ValueError(
-                    "for text file data input, you must use the -t option to set the timestep"
-                )
-        else:
-            if nim_hdr.get_xyzt_units()[1] == "msec":
-                fmritr = thesizes[4] / 1000.0
-            else:
-                fmritr = thesizes[4]
-    if optiondict["realtr"] > 0.0:
-        fmritr = optiondict["realtr"]
+    # read the fmri datafile
+    tide_util.logmem("before reading in input data")
+    theinputdata = tide_voxelData.VoxelData(inputdatafilename, timestep=optiondict["realtr"])
+    if optiondict["debug"]:
+        theinputdata.summarize()
+    xsize, ysize, numslices, timepoints = theinputdata.getdims()
+    thesizes = theinputdata.thesizes
+    xdim, ydim, slicethickness, fmritr = theinputdata.getsizes()
+    numspatiallocs = theinputdata.numspatiallocs
+    nativespaceshape = theinputdata.nativespaceshape
+    fmritr = theinputdata.timestep
+    optiondict["filetype"] = theinputdata.filetype
 
     # check to see if we need to adjust the oversample factor
     if optiondict["oversampfactor"] < 0:
         optiondict["oversampfactor"] = int(np.max([np.ceil(fmritr / 0.5), 1]))
         LGR.debug(f"oversample factor set to {optiondict['oversampfactor']}")
+    # optiondict["prewhitenlags"] *= optiondict["oversampfactor"]
 
     oversamptr = fmritr / optiondict["oversampfactor"]
     LGR.verbose(f"fmri data: {timepoints} timepoints, tr = {fmritr}, oversamptr = {oversamptr}")
@@ -491,6 +486,8 @@ def rapidtide_main(argparsingfunc):
         raise ValueError(
             f"magnitude of lagmax exceeds {(validend - validstart + 1) * fmritr / 2.0} - invalid"
         )
+    # trim the fmri data to the limits
+    theinputdata.setvalidtimes(validstart, validend)
 
     # determine the valid timepoints
     validtimepoints = validend - validstart + 1
@@ -513,55 +510,21 @@ def rapidtide_main(argparsingfunc):
     optiondict["simcalcoffset"] = -validsimcalcstart * fmritr
 
     ####################################################
-    #  Prepare data
+    # Calculate initial stats
     ####################################################
-    # do spatial filtering if requested
-    if fileiscifti:
-        optiondict["gausssigma"] = 0.0
-    if optiondict["gausssigma"] < 0.0 and not optiondict["textio"]:
-        # set gausssigma automatically
-        optiondict["gausssigma"] = np.mean([xdim, ydim, slicethickness]) / 2.0
-    if optiondict["gausssigma"] > 0.0:
-        LGR.info(
-            f"applying gaussian spatial filter to timepoints {validstart} "
-            f"to {validend} with sigma={optiondict['gausssigma']}"
-        )
-        for i in tqdm(
-            range(validstart, validend + 1),
-            desc="Timepoint",
-            unit="timepoints",
-            disable=(not optiondict["showprogressbar"]),
-        ):
-            nim_data[:, :, :, i] = tide_filt.ssmooth(
-                xdim,
-                ydim,
-                slicethickness,
-                optiondict["gausssigma"],
-                nim_data[:, :, :, i],
-            )
-        TimingLGR.info("End 3D smoothing")
-
-    # reshape the data and trim to a time range, if specified.  Check for special case of no trimming to save RAM
-    fmri_data = nim_data.reshape((numspatiallocs, timepoints))[:, validstart : validend + 1]
-    if optiondict["numtozero"] > 0:
-        themean = np.mean(fmri_data[:, optiondict["numtozero"] :], axis=1)
-        fmri_data[:, 0 : optiondict["numtozero"]] = themean[:, None]
-
-    # detect zero mean data
-    optiondict["dataiszeromean"] = checkforzeromean(fmri_data)
-    if optiondict["dataiszeromean"]:
-        LGR.warning(
-            "WARNING: dataset is zero mean - forcing variance masking and no refine prenormalization. "
-            "Consider specifying a global mean and correlation mask."
-        )
-        optiondict["refineprenorm"] = "None"
-        optiondict["globalmaskmethod"] = "variance"
+    init_min, init_max, init_mean, init_std, init_median, init_MAD, init_skew, init_kurtosis = (
+        tide_stats.fmristats(theinputdata.byvoxel())
+    )
 
+    ####################################################
+    #  Prepare data
+    ####################################################
     # read in the anatomic masks
     anatomiclist = [
         ["brainmaskincludename", "brainmaskincludevals", "brainmask"],
         ["graymatterincludename", "graymatterincludevals", "graymattermask"],
         ["whitematterincludename", "whitematterincludevals", "whitemattermask"],
+        ["csfincludename", "csfincludevals", "csfmask"],
     ]
     anatomicmasks = []
     for thisanatomic in anatomiclist:
@@ -569,19 +532,59 @@ def rapidtide_main(argparsingfunc):
             anatomicmasks.append(
                 tide_mask.readamask(
                     optiondict[thisanatomic[0]],
-                    nim_hdr,
+                    theinputdata.nim_hdr,
                     xsize,
-                    istext=optiondict["textio"],
+                    istext=(theinputdata.filetype == "text"),
                     valslist=optiondict[thisanatomic[1]],
                     maskname=thisanatomic[2],
                     tolerance=optiondict["spatialtolerance"],
+                    debug=optiondict["debug"],
                 )
             )
             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]
+    csfmask = anatomicmasks[3]
+
+    # do spatial filtering if requested
+    if theinputdata.filetype == "nifti":
+        unfiltmeanvalue = np.mean(
+            theinputdata.byvoxel(),
+            axis=1,
+        )
+    optiondict["gausssigma"] = theinputdata.smooth(
+        optiondict["gausssigma"],
+        brainmask=brainmask,
+        graymask=graymask,
+        whitemask=whitemask,
+        premask=optiondict["premask"],
+        premasktissueonly=optiondict["premasktissueonly"],
+        showprogressbar=optiondict["showprogressbar"],
+    )
+    if optiondict["gausssigma"] > 0.0:
+        TimingLGR.info("End 3D smoothing")
+
+    # Reshape the data and trim to a time range, if specified.  Check for special case of no trimming to save RAM
+    fmri_data = theinputdata.byvoxel()
+    print(f"{fmri_data.shape=}")
+
+    # detect zero mean data
+    if not optiondict["dataiszeromean"]:
+        # check anyway
+        optiondict["dataiszeromean"] = checkforzeromean(fmri_data)
+
+    if optiondict["dataiszeromean"]:
+        LGR.warning(
+            "WARNING: dataset is zero mean - forcing variance masking and no refine prenormalization. "
+            "Consider specifying a global mean and correlation mask."
+        )
+        optiondict["refineprenorm"] = "None"
+
+    # reformat the anatomic masks, if they exist
     if brainmask is None:
         invbrainmask = None
 
@@ -591,28 +594,29 @@ def rapidtide_main(argparsingfunc):
         invbrainmask = 1 - brainmask
         internalbrainmask = brainmask.reshape((numspatiallocs))
         internalinvbrainmask = invbrainmask.reshape((numspatiallocs))
-    graymask = anatomicmasks[1]
-    whitemask = anatomicmasks[2]
 
     # read in the optional masks
     tide_util.logmem("before setting masks")
 
-    internalglobalmeanincludemask, internalglobalmeanexcludemask, dummy = tide_mask.getmaskset(
-        "global mean",
-        optiondict["globalmeanincludename"],
-        optiondict["globalmeanincludevals"],
-        optiondict["globalmeanexcludename"],
-        optiondict["globalmeanexcludevals"],
-        nim_hdr,
-        numspatiallocs,
-        istext=optiondict["textio"],
-        tolerance=optiondict["spatialtolerance"],
+    internalinitregressorincludemask, internalinitregressorexcludemask, dummy = (
+        tide_mask.getmaskset(
+            "global mean",
+            optiondict["initregressorincludename"],
+            optiondict["initregressorincludevals"],
+            optiondict["initregressorexcludename"],
+            optiondict["initregressorexcludevals"],
+            theinputdata.nim_hdr,
+            numspatiallocs,
+            istext=(theinputdata.filetype == "text"),
+            tolerance=optiondict["spatialtolerance"],
+            debug=optiondict["debug"],
+        )
     )
     if internalinvbrainmask is not None:
-        if internalglobalmeanexcludemask is not None:
-            internalglobalmeanexcludemask *= internalinvbrainmask
+        if internalinitregressorexcludemask is not None:
+            internalinitregressorexcludemask *= internalinvbrainmask
         else:
-            internalglobalmeanexcludemask = internalinvbrainmask
+            internalinitregressorexcludemask = internalinvbrainmask
 
     internalrefineincludemask, internalrefineexcludemask, dummy = tide_mask.getmaskset(
         "refine",
@@ -620,10 +624,11 @@ def rapidtide_main(argparsingfunc):
         optiondict["refineincludevals"],
         optiondict["refineexcludename"],
         optiondict["refineexcludevals"],
-        nim_hdr,
+        theinputdata.nim_hdr,
         numspatiallocs,
-        istext=optiondict["textio"],
+        istext=(theinputdata.filetype == "text"),
         tolerance=optiondict["spatialtolerance"],
+        debug=optiondict["debug"],
     )
     if internalinvbrainmask is not None:
         if internalrefineexcludemask is not None:
@@ -637,10 +642,11 @@ def rapidtide_main(argparsingfunc):
         optiondict["offsetincludevals"],
         optiondict["offsetexcludename"],
         optiondict["offsetexcludevals"],
-        nim_hdr,
+        theinputdata.nim_hdr,
         numspatiallocs,
-        istext=optiondict["textio"],
+        istext=(theinputdata.filetype == "text"),
         tolerance=optiondict["spatialtolerance"],
+        debug=optiondict["debug"],
     )
     if internalinvbrainmask is not None:
         if internaloffsetexcludemask is not None:
@@ -656,19 +662,20 @@ def rapidtide_main(argparsingfunc):
     if optiondict["corrmaskincludename"] is not None:
         thecorrmask = tide_mask.readamask(
             optiondict["corrmaskincludename"],
-            nim_hdr,
+            theinputdata.nim_hdr,
             xsize,
-            istext=optiondict["textio"],
+            istext=(theinputdata.filetype == "text"),
             valslist=optiondict["corrmaskincludevals"],
             maskname="correlation",
             tolerance=optiondict["spatialtolerance"],
+            debug=optiondict["debug"],
         )
 
         corrmask = np.uint16(np.where(thecorrmask > 0, 1, 0).reshape(numspatiallocs))
 
         # last line sanity check - if data is 0 over all time in a voxel, force corrmask to zero.
         datarange = np.max(fmri_data, axis=1) - np.min(fmri_data, axis=1)
-        if optiondict["textio"]:
+        if theinputdata.filetype == "text":
             tide_io.writenpvecs(
                 datarange.reshape((numspatiallocs)),
                 f"{outputname}_motionr2.txt",
@@ -677,27 +684,29 @@ def rapidtide_main(argparsingfunc):
             savename = f"{outputname}_desc-datarange"
             tide_io.savetonifti(
                 datarange.reshape((xsize, ysize, numslices)),
-                nim_hdr,
+                theinputdata.nim_hdr,
                 savename,
             )
         corrmask[np.where(datarange == 0)] = 0.0
     else:
         # check to see if the data has been demeaned
-        meanim = np.mean(fmri_data, axis=1)
-        stdim = np.std(fmri_data, axis=1)
-        if fileiscifti:
-            corrmask = np.uint(nim_data[:, 0] * 0 + 1)
+        if theinputdata.filetype != "nifti":
+            corrmask = np.ones_like(theinputdata.byvoxel()[:, 0], np.uint)
         else:
-            if (np.mean(stdim) < np.mean(meanim)) and not optiondict["nirs"]:
+            if not optiondict["dataiszeromean"]:
                 LGR.verbose("generating correlation mask from mean image")
-                corrmask = np.uint16(tide_mask.makeepimask(nim).dataobj.reshape(numspatiallocs))
+                corrmask = np.uint16(
+                    tide_mask.makeepimask(theinputdata.nim).dataobj.reshape(numspatiallocs)
+                )
             else:
                 LGR.verbose("generating correlation mask from std image")
                 corrmask = np.uint16(
-                    tide_stats.makemask(stdim, threshpct=optiondict["corrmaskthreshpct"])
+                    tide_stats.makemask(
+                        np.std(fmri_data, axis=1), threshpct=optiondict["corrmaskthreshpct"]
+                    )
                 )
-    if internalbrainmask is not None:
-        corrmask *= internalbrainmask
+        if internalbrainmask is not None:
+            corrmask = internalbrainmask
     if tide_stats.getmasksize(corrmask) == 0:
         raise ValueError("ERROR: there are no voxels in the correlation mask - exiting")
 
@@ -729,19 +738,20 @@ def rapidtide_main(argparsingfunc):
         corrmask *= 0
         corrmask += 1
         threshval = -10000000.0
-    if not (fileiscifti or optiondict["textio"]):
-        theheader = copy.deepcopy(nim_hdr)
-        theheader["dim"][0] = 3
-        theheader["dim"][4] = 1
-        theheader["pixdim"][4] = 1.0
+    if theinputdata.filetype == "nifti":
+        theheader = theinputdata.copyheader(numtimepoints=1)
         savename = f"{outputname}_desc-processed_mask"
         tide_io.savetonifti(corrmask.reshape(xsize, ysize, numslices), theheader, savename)
 
-    LGR.verbose(f"image threshval = {threshval}")
+    LGR.verbose(f"image threshval = {threshval:.2f}")
     validvoxels = np.where(corrmask > 0)[0]
+    if optiondict["debug"]:
+        print(f"{validvoxels.shape=}")
+        np.savetxt(f"{outputname}_validvoxels.txt", validvoxels)
     numvalidspatiallocs = np.shape(validvoxels)[0]
     LGR.debug(f"validvoxels shape = {numvalidspatiallocs}")
-    fmri_data_valid = fmri_data[validvoxels, :] + 0.0
+    theinputdata.setvalidvoxels(validvoxels)
+    fmri_data_valid = theinputdata.validdata() + 0.0
     LGR.verbose(
         f"original size = {np.shape(fmri_data)}, trimmed size = {np.shape(fmri_data_valid)}"
     )
@@ -779,17 +789,15 @@ def rapidtide_main(argparsingfunc):
         )
     else:
         internaloffsetexcludemask_valid = None
-
     tide_util.logmem("after selecting valid voxels")
 
     # move fmri_data_valid into shared memory
     if optiondict["sharedmem"]:
         LGR.info("moving fmri data to shared memory")
         TimingLGR.verbose("Start moving fmri_data to shared memory")
-        tide_util.numpy2shared_func = addmemprofiling(
-            tide_util.numpy2shared, optiondict["memprofile"], "before fmri data move"
+        fmri_data_valid, fmri_data_valid_shm = tide_util.numpy2shared(
+            fmri_data_valid, rt_floattype, name=f"fmri_data_valid_{optiondict['pid']}"
         )
-        fmri_data_valid = tide_util.numpy2shared_func(fmri_data_valid, rt_floatset)
         TimingLGR.verbose("End moving fmri_data to shared memory")
 
     # read in any motion and/or other confound regressors here
@@ -802,7 +810,7 @@ def rapidtide_main(argparsingfunc):
             ),
             labels=["xtrans", "ytrans", "ztrans", "xrot", "yrot", "zrot"],
             deriv=optiondict["mot_deriv"],
-            order=1,
+            order=optiondict["mot_power"],
         )
         domotion = True
     else:
@@ -819,7 +827,7 @@ def rapidtide_main(argparsingfunc):
     else:
         doconfounds = False
 
-    # now actually do the filtering
+    # now actually do the confound filtering
     if domotion or doconfounds:
         LGR.info("Doing confound filtering")
         TimingLGR.verbose("Confound filtering start")
@@ -845,13 +853,20 @@ def rapidtide_main(argparsingfunc):
             append=False,
         )
 
-        disablemkl(optiondict["nprocs_confoundregress"], debug=threaddebug)
+        if optiondict["debug"]:
+            print(f"{mergedregressors.shape=}")
+            print(f"{mergedregressorlabels}")
+            print(f"{fmri_data_valid.shape=}")
+            print(f"{fmritr=}")
+            print(f"{validstart=}")
+            print(f"{validend=}")
+        tide_util.disablemkl(optiondict["nprocs_confoundregress"], debug=optiondict["threaddebug"])
         (
             mergedregressors,
             mergedregressorlabels,
             fmri_data_valid,
             confoundr2,
-        ) = tide_glmpass.confoundregress(
+        ) = tide_linfitfiltpass.confoundregress(
             mergedregressors,
             mergedregressorlabels,
             fmri_data_valid,
@@ -862,7 +877,7 @@ def rapidtide_main(argparsingfunc):
             orthogonalize=optiondict["orthogonalize"],
             showprogressbar=optiondict["showprogressbar"],
         )
-        enablemkl(optiondict["mklthreads"], debug=threaddebug)
+        tide_util.enablemkl(optiondict["mklthreads"], debug=optiondict["threaddebug"])
         if confoundr2 is None:
             print("There are no nonzero confound regressors - exiting")
             sys.exit()
@@ -875,8 +890,8 @@ def rapidtide_main(argparsingfunc):
             },
         )
         # save the confound filter R2 map
-        if not optiondict["textio"]:
-            if fileiscifti:
+        if theinputdata.filetype != "text":
+            if theinputdata.filetype == "cifti":
                 timeindex = theheader["dim"][0] - 1
                 spaceindex = theheader["dim"][0]
                 theheader["dim"][timeindex] = 1
@@ -886,7 +901,7 @@ def rapidtide_main(argparsingfunc):
                 theheader["dim"][4] = 1
                 theheader["pixdim"][4] = 1.0
         maplist = [
-            (confoundr2, "confoundfilterR2", "map", None, "R2 of the motion/confound regression")
+            (confoundr2, "confoundfilterR2", "map", None, "R2 of the motion/confound regression"),
         ]
         tide_io.savemaplist(
             outputname,
@@ -895,10 +910,9 @@ def rapidtide_main(argparsingfunc):
             nativespaceshape,
             theheader,
             bidsbasedict,
-            textio=optiondict["textio"],
-            fileiscifti=fileiscifti,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
-            cifti_hdr=cifti_hdr,
+            cifti_hdr=theinputdata.cifti_hdr,
         )
         tide_stats.makeandsavehistogram(
             confoundr2,
@@ -921,29 +935,10 @@ def rapidtide_main(argparsingfunc):
             },
             append=False,
         )
-        if optiondict["memprofile"]:
-            memcheckpoint("...done")
-        else:
-            tide_util.logmem("after confound glm filter")
+        tide_util.logmem("after confound sLFO filter")
 
         if optiondict["saveconfoundfiltered"]:
-            if not optiondict["textio"]:
-                theheader = copy.deepcopy(nim_hdr)
-                if fileiscifti:
-                    nativefmrishape = (1, 1, 1, validtimepoints, numspatiallocs)
-                    timeindex = theheader["dim"][0] - 1
-                    spaceindex = theheader["dim"][0]
-                    theheader["dim"][timeindex] = validtimepoints
-                    theheader["dim"][spaceindex] = numspatiallocs
-                else:
-                    nativefmrishape = (xsize, ysize, numslices, validtimepoints)
-                    theheader["dim"][4] = validtimepoints
-                    theheader["pixdim"][4] = fmritr
-            else:
-                nativefmrishape = (xsize, validtimepoints)
-                theheader = None
-                cifti_hdr = None
-
+            theheader = theinputdata.copyheader(numtimepoints=validtimepoints, tr=fmritr)
             maplist = [
                 (
                     fmri_data_valid,
@@ -957,21 +952,26 @@ def rapidtide_main(argparsingfunc):
                 outputname,
                 maplist,
                 validvoxels,
-                nativefmrishape,
+                theinputdata.nativefmrishape,
                 theheader,
                 bidsbasedict,
-                textio=optiondict["textio"],
-                fileiscifti=fileiscifti,
+                filetype=theinputdata.filetype,
                 rt_floattype=rt_floattype,
-                cifti_hdr=cifti_hdr,
+                cifti_hdr=theinputdata.cifti_hdr,
             )
 
     # get rid of memory we aren't using
     tide_util.logmem("before purging full sized fmri data")
     meanvalue = np.mean(
-        nim_data.reshape((numspatiallocs, timepoints))[:, validstart : validend + 1],
+        theinputdata.byvoxel(),
+        axis=1,
+    )
+    stddevvalue = np.std(
+        theinputdata.byvoxel(),
         axis=1,
     )
+    covvalue = np.where(meanvalue > 0.0, stddevvalue / meanvalue, 0.0)
+    covvalue *= corrmask
 
     ####################################################
     #  Get the moving regressor from somewhere
@@ -980,18 +980,88 @@ def rapidtide_main(argparsingfunc):
     meanfreq = 1.0 / fmritr
     meanperiod = 1.0 * fmritr
     meanstarttime = 0.0
-    meanvec, meanmask = getglobalsignal(
+    meanvec, meanmask = tide_mask.saveregionaltimeseries(
+        "initial regressor",
+        "startregressormask",
         fmri_data,
-        optiondict,
-        includemask=internalglobalmeanincludemask,
-        excludemask=internalglobalmeanexcludemask,
-        pcacomponents=optiondict["globalpcacomponents"],
-        debug=False,
+        internalinitregressorincludemask,
+        meanfreq,
+        outputname,
+        initfile=True,
+        signalgenmethod=optiondict["initregressorsignalmethod"],
+        pcacomponents=optiondict["initregressorpcacomponents"],
+        excludemask=internalinitregressorexcludemask,
+        filedesc="regionalprefilter",
+        suffix="",
+        debug=optiondict["debug"],
     )
 
+    if brainmask is not None:
+        brainvec, dummy = tide_mask.saveregionaltimeseries(
+            "whole brain",
+            "brain",
+            fmri_data,
+            internalbrainmask,
+            meanfreq,
+            outputname,
+            filedesc="regionalprefilter",
+            suffix="",
+            debug=optiondict["debug"],
+        )
+
+    if graymask is None:
+        internalgraymask = None
+    else:
+        internalgraymask = graymask.reshape((numspatiallocs))
+        grayvec, dummy = tide_mask.saveregionaltimeseries(
+            "gray matter",
+            "GM",
+            fmri_data,
+            internalgraymask,
+            meanfreq,
+            outputname,
+            excludemask=internalinvbrainmask,
+            filedesc="regionalprefilter",
+            suffix="",
+            debug=optiondict["debug"],
+        )
+
+    if whitemask is None:
+        internalwhitemask = None
+    else:
+        internalwhitemask = whitemask.reshape((numspatiallocs))
+        whitevec, dummy = tide_mask.saveregionaltimeseries(
+            "white matter",
+            "WM",
+            fmri_data,
+            internalwhitemask,
+            meanfreq,
+            outputname,
+            excludemask=internalinvbrainmask,
+            filedesc="regionalprefilter",
+            suffix="",
+            debug=optiondict["debug"],
+        )
+
+    if csfmask is None:
+        internalcsfmask = None
+    else:
+        internalcsfmask = csfmask.reshape((numspatiallocs))
+        csfvec, dummy = tide_mask.saveregionaltimeseries(
+            "CSF",
+            "CSF",
+            fmri_data,
+            internalcsfmask,
+            meanfreq,
+            outputname,
+            excludemask=internalinvbrainmask,
+            filedesc="regionalprefilter",
+            suffix="",
+            debug=optiondict["debug"],
+        )
+
     # get rid of more memory we aren't using
-    del fmri_data
-    del nim_data
+    theinputdata.unload()
     uncollected = gc.collect()
     if uncollected != 0:
         print(f"garbage collected - unable to collect {uncollected} objects")
@@ -1004,31 +1074,23 @@ def rapidtide_main(argparsingfunc):
     TimingLGR.info("Start of reference prep")
     if regressorfilename is None:
         LGR.info("no regressor file specified - will use the global mean regressor")
-        optiondict["useglobalref"] = True
+        optiondict["useinitregressorref"] = True
     else:
-        optiondict["useglobalref"] = False
+        optiondict["useinitregressorref"] = False
 
     # now set the regressor that we'll use
-    if optiondict["useglobalref"]:
+    if optiondict["useinitregressorref"]:
         LGR.verbose("using global mean as probe regressor")
         inputfreq = meanfreq
         inputperiod = meanperiod
         inputstarttime = meanstarttime
         inputvec = meanvec
-        theheader = copy.deepcopy(nim_hdr)
 
         # save the meanmask
-        if not optiondict["textio"]:
-            if fileiscifti:
-                timeindex = theheader["dim"][0] - 1
-                spaceindex = theheader["dim"][0]
-                theheader["dim"][timeindex] = 1
-                theheader["dim"][spaceindex] = numspatiallocs
-            else:
-                theheader["dim"][0] = 3
-                theheader["dim"][4] = 1
-                theheader["pixdim"][4] = 1.0
-        masklist = [(meanmask, "globalmean", "mask", None, "Voxels used to calculate global mean")]
+        theheader = theinputdata.copyheader(numtimepoints=1)
+        masklist = [
+            (meanmask, "initregressor", "mask", None, "Voxels used to calculate initial regressor")
+        ]
         tide_io.savemaplist(
             outputname,
             masklist,
@@ -1036,10 +1098,9 @@ def rapidtide_main(argparsingfunc):
             nativespaceshape,
             theheader,
             bidsbasedict,
-            textio=optiondict["textio"],
-            fileiscifti=fileiscifti,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
-            cifti_hdr=cifti_hdr,
+            cifti_hdr=theinputdata.cifti_hdr,
         )
         optiondict["preprocskip"] = 0
     else:
@@ -1077,10 +1138,10 @@ def rapidtide_main(argparsingfunc):
     )
     LGR.verbose("Input vector")
     LGR.verbose(f"length: {len(inputvec)}")
-    LGR.verbose(f"input freq: {inputfreq}")
+    LGR.verbose(f"input freq: {inputfreq:.2f}")
     LGR.verbose(f"input start time: {inputstarttime:.3f}")
 
-    if not optiondict["useglobalref"]:
+    if not optiondict["useinitregressorref"]:
         globalcorrx, globalcorry, dummy, dummy = tide_corr.arbcorr(
             meanvec, meanfreq, inputvec, inputfreq, start2=(inputstarttime)
         )
@@ -1104,59 +1165,6 @@ def rapidtide_main(argparsingfunc):
     LGR.verbose(f"the timepoint spacing is {1.0 / inputfreq}")
     LGR.verbose(f"the input timecourse start time is {inputstarttime}")
 
-    # if there is an externally specified noise regressor, read it in here
-    if optiondict["noisetimecoursespec"] is not None:
-        noisetimecoursespec = optiondict["noisetimecoursespec"]
-        LGR.info(f"using externally supplied noise regressor {noisetimecoursespec}")
-        (
-            filenoisefreq,
-            filenoisestarttime,
-            dummy,
-            noisevec,
-            dummy,
-            dummy,
-        ) = tide_io.readvectorsfromtextfile(optiondict["noisetimecoursespec"], onecol=True)
-        if optiondict["noiseinvert"]:
-            noisevec = noisevec * -1.0
-        noisefreq = optiondict["noisefreq"]
-        noisestarttime = optiondict["noisestarttime"]
-        if noisefreq is None:
-            if filenoisefreq is not None:
-                noisefreq = filenoisefreq
-            else:
-                noisefreq = 1.0 / fmritr
-            LGR.warning(f"no regressor frequency specified - defaulting to {noisefreq} (1/tr)")
-        if noisestarttime is None:
-            if filenoisestarttime is not None:
-                noisestarttime = filenoisestarttime
-            else:
-                LGR.warning("no regressor start time specified - defaulting to 0.0")
-                noisestarttime = 0.0
-        noiseperiod = 1.0 / noisefreq
-        numnoise = len(noisevec)
-        optiondict["noisefreq"] = noisefreq
-        optiondict["noisestarttime"] = noisestarttime
-        LGR.debug(
-            "Noise timecourse start time, end time, and step: {:.3f}, {:.3f}, {:.3f}".format(
-                -noisestarttime, noisestarttime + numnoise * noiseperiod, noiseperiod
-            )
-        )
-        noise_x = np.arange(0.0, numnoise) * noiseperiod - noisestarttime
-        noise_y = noisevec[0:numnoise] - np.mean(noisevec[0:numnoise])
-        # write out the noise regressor as read
-        tide_io.writebidstsv(
-            f"{outputname}_desc-initialnoiseregressor_timeseries",
-            noise_y,
-            noisefreq,
-            starttime=-noisestarttime,
-            columns=["prefilt"],
-            append=False,
-        )
-        LGR.verbose("noise vector")
-        LGR.verbose(f"length: {len(noisevec)}")
-        LGR.verbose(f"noise freq: {noisefreq}")
-        LGR.verbose(f"noise start time: {noisestarttime:.3f}")
-
     # generate the time axes
     fmrifreq = 1.0 / fmritr
     optiondict["fmrifreq"] = fmrifreq
@@ -1233,8 +1241,6 @@ def rapidtide_main(argparsingfunc):
         reference_y = -np.gradient(reference_y_classfilter)
     else:
         reference_y = reference_y_classfilter
-    if optiondict["noisetimecoursespec"] is not None:
-        noise_y = theprefilter.apply(noisefreq, noise_y)
 
     # write out the reference regressor used
     tide_io.writebidstsv(
@@ -1260,27 +1266,7 @@ def rapidtide_main(argparsingfunc):
             padlen=int(inputfreq * optiondict["padseconds"]),
             debug=optiondict["debug"],
         )
-        reference_y = rt_floatset(reference_y_filt.real)
-        if optiondict["noisetimecoursespec"] is not None:
-            noise_y_filt = tide_filt.dolptrapfftfilt(
-                noisefreq,
-                0.25 * fmrifreq,
-                0.5 * fmrifreq,
-                noise_y,
-                padlen=int(noisefreq * optiondict["padseconds"]),
-                debug=optiondict["debug"],
-            )
-            noise_y = rt_floatset(noise_y_filt.real)
-
-            # write out the noise regressor after filtering
-            tide_io.writebidstsv(
-                f"{outputname}_desc-initialnoiseregressor_timeseries",
-                noise_y,
-                noisefreq,
-                starttime=-noisestarttime,
-                columns=["postfilt"],
-                append=True,
-            )
+        reference_y = (reference_y_filt.real).astype(rt_floattype)
 
     warnings.filterwarnings("ignore", "Casting*")
 
@@ -1314,35 +1300,6 @@ def rapidtide_main(argparsingfunc):
             order=optiondict["detrendorder"],
             demean=optiondict["dodemean"],
         )
-        if optiondict["noisetimecoursespec"] is not None:
-            if optiondict["detrendorder"] > 0:
-                resampnonosnoise_y = tide_fit.detrend(
-                    tide_resample.doresample(
-                        noise_x,
-                        noise_y,
-                        initial_fmri_x,
-                        padlen=int((1.0 / fmritr) * optiondict["padseconds"]),
-                        padtype="zero",
-                        method=optiondict["interptype"],
-                        debug=optiondict["debug"],
-                    ),
-                    order=optiondict["detrendorder"],
-                    demean=optiondict["dodemean"],
-                )
-                resampnoise_y = tide_fit.detrend(
-                    tide_resample.doresample(
-                        noise_x,
-                        noise_y,
-                        os_fmri_x,
-                        padlen=int(oversampfreq * optiondict["padseconds"]),
-                        padtype="zero",
-                        method=optiondict["interptype"],
-                        debug=optiondict["debug"],
-                    ),
-                    order=optiondict["detrendorder"],
-                    demean=optiondict["dodemean"],
-                )
-
     else:
         resampnonosref_y = tide_resample.doresample(
             reference_x,
@@ -1358,23 +1315,6 @@ def rapidtide_main(argparsingfunc):
             padlen=int(oversampfreq * optiondict["padseconds"]),
             method=optiondict["interptype"],
         )
-        if optiondict["noisetimecoursespec"] is not None:
-            resampnonosnoise_y = tide_resample.doresample(
-                noise_x,
-                noise_y,
-                initial_fmri_x,
-                padlen=int((1.0 / fmritr) * optiondict["padseconds"]),
-                padtype="zero",
-                method=optiondict["interptype"],
-            )
-            resampnoise_y = tide_resample.doresample(
-                noise_x,
-                noise_y,
-                os_fmri_x,
-                padlen=int(oversampfreq * optiondict["padseconds"]),
-                padtype="zero",
-                method=optiondict["interptype"],
-            )
 
     LGR.debug(
         f"{len(os_fmri_x)} "
@@ -1387,11 +1327,33 @@ def rapidtide_main(argparsingfunc):
     # save the factor used to normalize the input regressor
     optiondict["initialmovingregressornormfac"] = np.std(resampnonosref_y)
 
-    # prepare the temporal mask
-    if optiondict["tmaskname"] is not None:
-        tmask_y = tide_mask.maketmask(
-            optiondict["tmaskname"], reference_x, rt_floatset(reference_y)
+    # prepare the temporal masks
+    if optiondict["tincludemaskname"] is not None:
+        print("creating temporal include mask")
+        includetmask_y = tide_mask.maketmask(
+            optiondict["tincludemaskname"], reference_x, reference_y.astype(rt_floattype) + 0.0
+        )
+    else:
+        includetmask_y = np.ones_like(reference_x)
+    if optiondict["texcludemaskname"] is not None:
+        print("creating temporal exclude mask")
+        excludetmask_y = (
+            -1.0
+            * tide_mask.maketmask(
+                optiondict["texcludemaskname"], reference_x, reference_y.astype(rt_floattype) + 0.0
+            )
+            + 1.0
         )
+    else:
+        excludetmask_y = np.ones_like(reference_x)
+    tmask_y = includetmask_y * excludetmask_y
+    tmask_y = np.where(tmask_y == 0.0, 0.0, 1.0)
+    if optiondict["debug"]:
+        print("after posterizing temporal mask")
+        print(tmask_y)
+    if (optiondict["tincludemaskname"] is not None) or (
+        optiondict["texcludemaskname"] is not None
+    ):
         tmaskos_y = tide_resample.doresample(
             reference_x, tmask_y, os_fmri_x, method=optiondict["interptype"]
         )
@@ -1406,27 +1368,16 @@ def rapidtide_main(argparsingfunc):
             append=False,
         )
         resampnonosref_y *= tmask_y
-        thefit, R = tide_fit.mlregress(tmask_y, resampnonosref_y)
+        thefit, R2val = tide_fit.mlregress(tmask_y, resampnonosref_y)
         resampnonosref_y -= thefit[0, 1] * tmask_y
         resampref_y *= tmaskos_y
-        thefit, R = tide_fit.mlregress(tmaskos_y, resampref_y)
+        thefit, R2val = tide_fit.mlregress(tmaskos_y, resampref_y)
         resampref_y -= thefit[0, 1] * tmaskos_y
+    else:
+        tmaskos_y = None
 
-    if optiondict["noisetimecoursespec"] is not None:
-        tide_io.writebidstsv(
-            f"{outputname}_desc-noiseregressor_timeseries",
-            tide_math.stdnormalize(resampnonosref_y),
-            1.0 / fmritr,
-            columns=["resampled"],
-            append=False,
-        )
-        tide_io.writebidstsv(
-            f"{outputname}_desc-oversamplednoiseregressor_timeseries",
-            tide_math.stdnormalize(resampref_y),
-            oversampfreq,
-            columns=["oversampled"],
-            append=False,
-        )
+    # construct refine temporal masks here
+    optiondict["windowedrefinemasks"] = None
 
     (
         optiondict["kurtosis_reference_pass1"],
@@ -1467,16 +1418,21 @@ def rapidtide_main(argparsingfunc):
     #  Set up for the delay finding/refinement passes
     ####################################################
     # initialize the Correlator
-    theCorrelator = tide_classes.Correlator(
+    theCorrelator = tide_simFuncClasses.Correlator(
         Fs=oversampfreq,
         ncprefilter=theprefilter,
         negativegradient=optiondict["negativegradient"],
         detrendorder=optiondict["detrendorder"],
+        filterinputdata=optiondict["filterinputdata"],
         windowfunc=optiondict["windowfunc"],
         corrweighting=optiondict["corrweighting"],
         corrpadding=optiondict["corrpadding"],
         debug=optiondict["debug"],
     )
+    if optiondict["debug"]:
+        print(
+            f"calling setreftc during initialization with length {optiondict['oversampfactor'] * validtimepoints}"
+        )
     theCorrelator.setreftc(
         np.zeros((optiondict["oversampfactor"] * validtimepoints), dtype=np.float64)
     )
@@ -1495,12 +1451,13 @@ def rapidtide_main(argparsingfunc):
     dummy, trimmedcorrscale, dummy = theCorrelator.getfunction()
 
     # initialize the MutualInformationator
-    theMutualInformationator = tide_classes.MutualInformationator(
+    theMutualInformationator = tide_simFuncClasses.MutualInformationator(
         Fs=oversampfreq,
         smoothingtime=optiondict["smoothingtime"],
         ncprefilter=theprefilter,
         negativegradient=optiondict["negativegradient"],
         detrendorder=optiondict["detrendorder"],
+        filterinputdata=optiondict["filterinputdata"],
         windowfunc=optiondict["windowfunc"],
         madnorm=False,
         lagmininpts=lagmininpts,
@@ -1531,6 +1488,7 @@ def rapidtide_main(argparsingfunc):
             1.0,
             starttime=0.0,
             columns=["corrtimes"],
+            extraheaderinfo={"Description": "Trimmed correlation time axis"},
             append=False,
         )
         tide_io.writebidstsv(
@@ -1539,6 +1497,7 @@ def rapidtide_main(argparsingfunc):
             1.0,
             starttime=0.0,
             columns=["mitimes"],
+            extraheaderinfo={"Description": "Trimmed cross mutual information time axis"},
             append=False,
         )
         tide_io.writebidstsv(
@@ -1547,6 +1506,7 @@ def rapidtide_main(argparsingfunc):
             1.0,
             starttime=0.0,
             columns=["corrtimes"],
+            extraheaderinfo={"Description": "Correlation time axis"},
             append=False,
         )
         tide_io.writebidstsv(
@@ -1555,12 +1515,32 @@ def rapidtide_main(argparsingfunc):
             1.0,
             starttime=0.0,
             columns=["mitimes"],
+            extraheaderinfo={"Description": "Cross mutual information time axis"},
             append=False,
         )
-        """
-        tide_io.writenpvecs(trimmedcorrscale, f"{outputname}_corrtimes.txt")
-        tide_io.writenpvecs(trimmedmiscale, f"{outputname}_mitimes.txt")
-        """
+
+    # prepare for fast resampling
+    optiondict["fastresamplerpadtime"] = (
+        max((-optiondict["lagmin"], optiondict["lagmax"]))
+        + 30.0
+        + np.abs(optiondict["offsettime"])
+    )
+    numpadtrs = int(optiondict["fastresamplerpadtime"] // fmritr)
+    optiondict["fastresamplerpadtime"] = fmritr * numpadtrs
+    LGR.info(f"setting up fast resampling with padtime = {optiondict['fastresamplerpadtime']}")
+
+    genlagtc = tide_resample.FastResampler(
+        reference_x, reference_y, padtime=optiondict["fastresamplerpadtime"]
+    )
+    genlagtc.save(f"{outputname}_desc-lagtcgenerator_timeseries")
+    if optiondict["debug"]:
+        genlagtc.info()
+    totalpadlen = validtimepoints + 2 * numpadtrs
+    paddedinitial_fmri_x = (
+        np.linspace(0.0, totalpadlen * fmritr, num=totalpadlen, endpoint=False)
+        + skiptime
+        - fmritr * numpadtrs
+    )
 
     # allocate all the data arrays
     tide_util.logmem("before main array allocation")
@@ -1573,14 +1553,36 @@ def rapidtide_main(argparsingfunc):
     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")
 
-    corroutlen = np.shape(trimmedcorrscale)[0]
-    if optiondict["textio"]:
+    if optiondict["similaritymetric"] == "riptide":
+        riptideregressorset, riptidedelays = tide_calcSimFuncMap.makeRIPTiDeRegressors(
+            initial_fmri_x,
+            optiondict["lagmin"],
+            optiondict["lagmax"],
+            genlagtc,
+            LGR,
+            targetstep=optiondict["riptidestep"],
+            edgepad=0,
+            showprogressbar=optiondict["showprogressbar"],
+            chunksize=optiondict["mp_chunksize"],
+            nprocs=optiondict["nprocs"],
+            alwaysmultiproc=optiondict["alwaysmultiproc"],
+            rt_floattype=rt_floattype,
+            debug=optiondict["debug"],
+        )
+        numriptideregressors = riptideregressorset.shape[0]
+        corroutlen = numriptideregressors
+    else:
+        riptideregressorset = None
+        riptidedelays = None
+        corroutlen = np.shape(trimmedcorrscale)[0]
+
+    if theinputdata.filetype == "text":
         nativecorrshape = (xsize, corroutlen)
     else:
-        if fileiscifti:
+        if theinputdata.filetype == "cifti":
             nativecorrshape = (1, 1, 1, corroutlen, numspatiallocs)
         else:
             nativecorrshape = (xsize, ysize, numslices, corroutlen)
@@ -1589,110 +1591,211 @@ def rapidtide_main(argparsingfunc):
     LGR.debug(
         f"allocating memory for correlation arrays {internalcorrshape} {internalvalidcorrshape}"
     )
+
+    corrout, corrout_shm = tide_util.allocarray(
+        internalvalidcorrshape,
+        rt_floattype,
+        shared=optiondict["sharedmem"],
+        name=f"corrout_{optiondict['pid']}",
+    )
+    gaussout, gaussout_shm = tide_util.allocarray(
+        internalvalidcorrshape,
+        rt_floattype,
+        shared=optiondict["sharedmem"],
+        name=f"gaussout_{optiondict['pid']}",
+    )
+    windowout, windowout_shm = tide_util.allocarray(
+        internalvalidcorrshape,
+        rt_floattype,
+        shared=optiondict["sharedmem"],
+        name=f"windowout_{optiondict['pid']}",
+    )
+    outcorrarray, outcorrarray_shm = tide_util.allocarray(
+        internalcorrshape,
+        rt_floattype,
+        shared=optiondict["sharedmem"],
+        name=f"outcorrarray_{optiondict['pid']}",
+    )
     if optiondict["sharedmem"]:
-        corrout, dummy, dummy = tide_util.allocshared(internalvalidcorrshape, rt_floatset)
-        gaussout, dummy, dummy = tide_util.allocshared(internalvalidcorrshape, rt_floatset)
-        windowout, dummy, dummy = tide_util.allocshared(internalvalidcorrshape, rt_floatset)
-        outcorrarray, dummy, dummy = tide_util.allocshared(internalcorrshape, rt_floatset)
+        ramlocation = "in shared memory"
     else:
-        corrout = np.zeros(internalvalidcorrshape, dtype=rt_floattype)
-        gaussout = np.zeros(internalvalidcorrshape, dtype=rt_floattype)
-        windowout = np.zeros(internalvalidcorrshape, dtype=rt_floattype)
-        outcorrarray = np.zeros(internalcorrshape, dtype=rt_floattype)
-    tide_util.logmem("after correlation array allocation")
+        ramlocation = "locally"
 
-    # prepare for fast resampling
-    padtime = (
-        max((-optiondict["lagmin"], optiondict["lagmax"]))
-        + 30.0
-        + np.abs(optiondict["offsettime"])
-    )
-    LGR.info(f"setting up fast resampling with padtime = {padtime}")
-    numpadtrs = int(padtime // fmritr)
-    padtime = fmritr * numpadtrs
-    genlagtc = tide_resample.FastResampler(reference_x, reference_y, padtime=padtime)
-    totalpadlen = validtimepoints + 2 * numpadtrs
-    paddedinitial_fmri_x = (
-        np.linspace(0.0, totalpadlen * fmritr, num=totalpadlen, endpoint=False)
-        + skiptime
-        - fmritr * numpadtrs
+    optiondict["totalcorrelationbytes"] = (
+        corrout.nbytes + gaussout.nbytes + windowout.nbytes + outcorrarray.nbytes
     )
+    thesize, theunit = tide_util.format_bytes(optiondict["totalcorrelationbytes"])
+    print(f"allocated {thesize:.3f} {theunit} {ramlocation} for correlation")
+    tide_util.logmem("after correlation array allocation")
 
-    if optiondict["textio"]:
+    # if there is an initial delay map, read it in
+    if optiondict["initialdelayvalue"] is not None:
+        try:
+            theinitialdelay = float(optiondict["initialdelayvalue"])
+        except ValueError:
+            (
+                initialdelay_input,
+                initialdelay,
+                initialdelay_header,
+                initialdelay_dims,
+                initialdelay_sizes,
+            ) = tide_io.readfromnifti(optiondict["initialdelayvalue"])
+            theheader = theinputdata.copyheader(numtimepoints=1)
+            if not tide_io.checkspacematch(theheader, initialdelay_header):
+                raise ValueError("fixed delay map dimensions do not match fmri dimensions")
+            theinitialdelay = initialdelay.reshape(numspatiallocs)[validvoxels]
+    else:
+        theinitialdelay = None
+
+    if theinputdata.filetype == "text":
         nativefmrishape = (xsize, np.shape(initial_fmri_x)[0])
-        nativepaddedfmrishape = (xsize, 2 * numpadtrs + np.shape(initial_fmri_x)[0])
+    elif theinputdata.filetype == "cifti":
+        nativefmrishape = (1, 1, 1, np.shape(initial_fmri_x)[0], numspatiallocs)
     else:
-        if fileiscifti:
-            nativefmrishape = (1, 1, 1, np.shape(initial_fmri_x)[0], numspatiallocs)
-            nativepaddedfmrishape = (
-                1,
-                1,
-                1,
-                2 * numpadtrs + np.shape(initial_fmri_x)[0],
-                numspatiallocs,
-            )
-        else:
-            nativefmrishape = (xsize, ysize, numslices, np.shape(initial_fmri_x)[0])
-            nativepaddedfmrishape = (
-                xsize,
-                ysize,
-                numslices,
-                2 * numpadtrs + np.shape(initial_fmri_x)[0],
-            )
+        nativefmrishape = (xsize, ysize, numslices, np.shape(initial_fmri_x)[0])
 
     internalfmrishape = (numspatiallocs, np.shape(initial_fmri_x)[0])
     internalvalidfmrishape = (numvalidspatiallocs, np.shape(initial_fmri_x)[0])
-    internalpaddedfmrishape = (numspatiallocs, 2 * numpadtrs + np.shape(initial_fmri_x)[0])
     internalvalidpaddedfmrishape = (
         numvalidspatiallocs,
         2 * numpadtrs + np.shape(initial_fmri_x)[0],
     )
 
+    # now do the arrays for delay refinement
     if (
-        optiondict["passes"] > 1
-        or optiondict["globalpreselect"]
-        or optiondict["convergencethresh"] is not None
+        optiondict["dolinfitfilt"]
+        or optiondict["docvrmap"]
+        or optiondict["refinedelay"]
+        or (optiondict["similaritymetric"] == "riptide")
     ):
-        if optiondict["sharedmem"]:
-            shiftedtcs, dummy, dummy = tide_util.allocshared(internalvalidfmrishape, rt_floatset)
-            weights, dummy, dummy = tide_util.allocshared(internalvalidfmrishape, rt_floatset)
-            paddedshiftedtcs, dummy, dummy = tide_util.allocshared(
-                internalvalidpaddedfmrishape, rt_floatset
-            )
-            paddedweights, dummy, dummy = tide_util.allocshared(
-                internalvalidpaddedfmrishape, rt_floatset
-            )
+        if optiondict["refinedelay"]:
+            derivaxissize = np.max([2, optiondict["regressderivs"] + 1])
         else:
-            shiftedtcs = np.zeros(internalvalidfmrishape, dtype=rt_floattype)
-            weights = np.zeros(internalvalidfmrishape, dtype=rt_floattype)
-            paddedshiftedtcs, dummy, dummy = tide_util.allocshared(
-                internalvalidpaddedfmrishape, rt_floatset
-            )
-            paddedweights, dummy, dummy = tide_util.allocshared(
-                internalvalidpaddedfmrishape, rt_floatset
-            )
-        tide_util.logmem("after refinement array allocation")
-    if optiondict["sharedmem"]:
-        outfmriarray, dummy, dummy = tide_util.allocshared(internalfmrishape, rt_floatset)
-        paddedoutfmriarray, dummy, dummy = tide_util.allocshared(
-            (internalpaddedfmrishape), rt_floatset
+            derivaxissize = optiondict["regressderivs"] + 1
+        internalvalidspaceshapederivs = (
+            internalvalidspaceshape,
+            derivaxissize,
         )
-    else:
-        outfmriarray = np.zeros(internalfmrishape, dtype=rt_floattype)
-        paddedoutfmriarray, dummy, dummy = tide_util.allocshared(
-            (internalpaddedfmrishape), rt_floatset
+        sLFOfitmean, sLFOfitmean_shm = tide_util.allocarray(
+            internalvalidspaceshape,
+            rt_outfloattype,
+            shared=optiondict["sharedmem"],
+            name=f"sLFOfitmean_{optiondict['pid']}",
         )
-
-        # cycle over all voxels
-    refine = True
-    LGR.verbose(f"refine is set to {refine}")
+        rvalue, rvalue_shm = tide_util.allocarray(
+            internalvalidspaceshape,
+            rt_outfloattype,
+            shared=optiondict["sharedmem"],
+            name=f"rvalue_{optiondict['pid']}",
+        )
+        r2value, r2value_shm = tide_util.allocarray(
+            internalvalidspaceshape,
+            rt_outfloattype,
+            shared=optiondict["sharedmem"],
+            name=f"r2value_{optiondict['pid']}",
+        )
+        fitNorm, fitNorm_shm = tide_util.allocarray(
+            internalvalidspaceshapederivs,
+            rt_outfloattype,
+            shared=optiondict["sharedmem"],
+            name=f"fitNorm_{optiondict['pid']}",
+        )
+        fitcoeff, fitcoeff_shm = tide_util.allocarray(
+            internalvalidspaceshapederivs,
+            rt_outfloattype,
+            shared=optiondict["sharedmem"],
+            name=f"fitcoeff_{optiondict['pid']}",
+        )
+        lagtc, lagtc_shm = tide_util.allocarray(
+            internalvalidfmrishape,
+            rt_floattype,
+            shared=optiondict["sharedmem"],
+            name=f"lagtc_{optiondict['pid']}",
+        )
+        if optiondict["sharedmem"]:
+            ramlocation = "in shared memory"
+        else:
+            ramlocation = "locally"
+
+        optiondict["totalRefineDelaybytes"] = (
+            sLFOfitmean.nbytes
+            + rvalue.nbytes
+            + r2value.nbytes
+            + fitNorm.nbytes
+            + fitcoeff.nbytes
+            + lagtc.nbytes
+        )
+        thesize, theunit = tide_util.format_bytes(optiondict["totalRefineDelaybytes"])
+        print(f"allocated {thesize:.3f} {theunit} {ramlocation} for delay refinement")
+        tide_util.logmem("after derivative delay/sLFO filter array allocation")
+    else:
+        sLFOfitmean = None
+        rvalue = None
+        r2value = None
+        fitNorm = None
+        fitcoeff = None
+        lagtc = None
+
+    # prepare for regressor refinement, if we're doing it
+    if (
+        optiondict["passes"] > 1
+        or optiondict["initregressorpreselect"]
+        or optiondict["dofinalrefine"]
+        or optiondict["convergencethresh"] is not None
+    ):
+        # we will be doing regressor refinement, so configure the refiner
+        theRegressorRefiner = tide_refineRegressor.RegressorRefiner(
+            internalvalidfmrishape,
+            internalvalidpaddedfmrishape,
+            optiondict["pid"],
+            optiondict["outputname"],
+            initial_fmri_x,
+            paddedinitial_fmri_x,
+            os_fmri_x,
+            sharedmem=optiondict["sharedmem"],
+            offsettime=optiondict["offsettime"],
+            ampthresh=optiondict["ampthresh"],
+            lagminthresh=optiondict["lagminthresh"],
+            lagmaxthresh=optiondict["lagmaxthresh"],
+            sigmathresh=optiondict["sigmathresh"],
+            cleanrefined=optiondict["cleanrefined"],
+            bipolar=optiondict["bipolar"],
+            fixdelay=optiondict["fixdelay"],
+            LGR=LGR,
+            nprocs=optiondict["nprocs_refine"],
+            detrendorder=optiondict["detrendorder"],
+            alwaysmultiproc=optiondict["alwaysmultiproc"],
+            showprogressbar=optiondict["showprogressbar"],
+            chunksize=optiondict["mp_chunksize"],
+            padtrs=numpadtrs,
+            refineprenorm=optiondict["refineprenorm"],
+            refineweighting=optiondict["refineweighting"],
+            refinetype=optiondict["refinetype"],
+            pcacomponents=optiondict["pcacomponents"],
+            windowfunc=optiondict["windowfunc"],
+            passes=optiondict["passes"],
+            maxpasses=optiondict["maxpasses"],
+            convergencethresh=optiondict["convergencethresh"],
+            interptype=optiondict["interptype"],
+            usetmask=(optiondict["tincludemaskname"] is not None),
+            tmask_y=tmask_y,
+            tmaskos_y=tmaskos_y,
+            fastresamplerpadtime=optiondict["fastresamplerpadtime"],
+            prewhitenregressor=False,
+            prewhitenlags=optiondict["prewhitenlags"],
+            debug=optiondict["debug"],
+        )
+
+    # cycle over all voxels
+    refine = True
+    LGR.verbose(f"refine is set to {refine}")
     optiondict["edgebufferfrac"] = max(
         [optiondict["edgebufferfrac"], 2.0 / np.shape(corrscale)[0]]
     )
     LGR.verbose(f"edgebufferfrac set to {optiondict['edgebufferfrac']}")
 
-    # intitialize the correlation fitter
-    thefitter = tide_classes.SimilarityFunctionFitter(
+    # initialize the correlation fitter
+    theFitter = tide_simFuncClasses.SimilarityFunctionFitter(
         lagmod=optiondict["lagmod"],
         lthreshval=optiondict["lthreshval"],
         uthreshval=optiondict["uthreshval"],
@@ -1713,11 +1816,6 @@ def rapidtide_main(argparsingfunc):
     if optiondict["echocancel"]:
         LGR.info("\n\nEcho cancellation")
         TimingLGR.info("Echo cancellation start")
-        calcsimilaritypass_func = addmemprofiling(
-            tide_calcsimfunc.correlationpass,
-            optiondict["memprofile"],
-            "before correlationpass",
-        )
 
         referencetc = tide_math.corrnormalize(
             resampref_y[osvalidsimcalcstart : osvalidsimcalcend + 1],
@@ -1725,12 +1823,12 @@ def rapidtide_main(argparsingfunc):
             windowfunc=optiondict["windowfunc"],
         )
 
-        disablemkl(optiondict["nprocs_calcsimilarity"], debug=threaddebug)
+        tide_util.disablemkl(optiondict["nprocs_calcsimilarity"], debug=optiondict["threaddebug"])
         (
             voxelsprocessed_echo,
             theglobalmaxlist,
             trimmedcorrscale,
-        ) = calcsimilaritypass_func(
+        ) = tide_calcsimfunc.correlationpass(
             fmri_data_valid[:, validsimcalcstart : validsimcalcend + 1],
             referencetc,
             theCorrelator,
@@ -1746,10 +1844,9 @@ def rapidtide_main(argparsingfunc):
             interptype=optiondict["interptype"],
             showprogressbar=optiondict["showprogressbar"],
             chunksize=optiondict["mp_chunksize"],
-            rt_floatset=rt_floatset,
             rt_floattype=rt_floattype,
         )
-        enablemkl(optiondict["mklthreads"], debug=threaddebug)
+        tide_util.enablemkl(optiondict["mklthreads"], debug=optiondict["threaddebug"])
 
         for i in range(len(theglobalmaxlist)):
             theglobalmaxlist[i] = corrscale[theglobalmaxlist[i]] - optiondict["simcalcoffset"]
@@ -1770,13 +1867,13 @@ def rapidtide_main(argparsingfunc):
         # Now find and regress out the echo
         echooffset, echoratio = tide_stats.echoloc(np.asarray(theglobalmaxlist), len(corrscale))
         LGR.info(f"Echooffset, echoratio: {echooffset} {echoratio}")
-        echoremovedtc, echofit, echoR = echocancel(
+        echoremovedtc, echofit, echoR2 = echocancel(
             resampref_y, echooffset, oversamptr, outputname, numpadtrs
         )
         optiondict["echooffset"] = echooffset
         optiondict["echoratio"] = echoratio
         optiondict["echofit"] = [echofit[0, 0], echofit[0, 1]]
-        optiondict["echofitR"] = echoR
+        optiondict["echofitR2"] = echoR2
         resampref_y = echoremovedtc
         TimingLGR.info(
             "Echo cancellation calculation end",
@@ -1785,6 +1882,32 @@ def rapidtide_main(argparsingfunc):
                 "message3": "voxels",
             },
         )
+        tide_io.writebidstsv(
+            f"{outputname}_desc-oversampledmovingregressor_timeseries",
+            tide_math.stdnormalize(resampref_y),
+            oversampfreq,
+            columns=["pass1_echocancel"],
+            extraheaderinfo={
+                "Description": "The probe regressor used in each pass, at the time resolution used for calculating the similarity function"
+            },
+            append=True,
+        )
+
+    # Preprocessing - prewhitening
+    if optiondict["prewhitenregressor"]:
+        resampref_y = tide_fit.prewhiten(
+            resampref_y, optiondict["prewhitenlags"], debug=optiondict["debug"]
+        )
+        tide_io.writebidstsv(
+            f"{outputname}_desc-oversampledmovingregressor_timeseries",
+            tide_math.stdnormalize(resampref_y),
+            oversampfreq,
+            columns=["pass1_prewhiten"],
+            extraheaderinfo={
+                "Description": "The probe regressor used in each pass, at the time resolution used for calculating the similarity function"
+            },
+            append=True,
+        )
 
     # --------------------- Main pass loop ---------------------
     # loop over all passes
@@ -1799,6 +1922,19 @@ def rapidtide_main(argparsingfunc):
     optiondict["currentstage"] = "preprocessingdone"
     tide_io.writedicttojson(optiondict, f"{outputname}_desc-runoptions_info.json")
 
+    # set up the pass options array
+    optiondict["passoptions"] = []
+    """optiondict["passoptions"].append(
+        {
+            "similaritymetric": "riptide"
+        }
+    )
+    optiondict["passoptions"].append(
+        {
+            "similaritymetric": optiondict["similaritymetric"]
+        }
+    )"""
+
     ####################################################
     #  Start the iterative fit and refinement
     ####################################################
@@ -1811,6 +1947,10 @@ def rapidtide_main(argparsingfunc):
             LGR.info("\n\n*********************")
             LGR.info(f"Pass number {thepass}")
 
+        # fetch the pass options
+        if len(optiondict["passoptions"]) >= thepass:
+            setpassoptions(optiondict["passoptions"][thepass - 1], optiondict)
+
         referencetc = tide_math.corrnormalize(
             resampref_y[osvalidsimcalcstart : osvalidsimcalcend + 1],
             detrendorder=optiondict["detrendorder"],
@@ -1818,245 +1958,56 @@ def rapidtide_main(argparsingfunc):
         )
 
         # Step -1 - check the regressor for periodic components in the passband
-        dolagmod = True
-        doreferencenotch = True
-        if optiondict["respdelete"]:
-            resptracker = tide_classes.FrequencyTracker(nperseg=64)
-            thetimes, thefreqs = resptracker.track(resampref_y, 1.0 / oversamptr)
-            tide_io.writevec(thefreqs, f"{outputname}_peakfreaks_pass{thepass}.txt")
-            resampref_y = resptracker.clean(resampref_y, 1.0 / oversamptr, thetimes, thefreqs)
-            tide_io.writevec(resampref_y, f"{outputname}_respfilt_pass{thepass}.txt")
-            referencetc = tide_math.corrnormalize(
-                resampref_y[osvalidsimcalcstart : osvalidsimcalcend + 1],
-                detrendorder=optiondict["detrendorder"],
-                windowfunc=optiondict["windowfunc"],
-            )
-        if optiondict["noisetimecoursespec"] is not None:
-            # align the noise signal with referencetc
-            (
-                shiftednoise,
-                optiondict[f"noisedelay_pass{thepass}"],
-                optiondict[f"noisecorr_pass{thepass}"],
-                thisfailreason,
-            ) = tide_corr.aligntcwithref(
-                resampref_y,
-                resampnoise_y,
-                oversampfreq,
-                zerooutbadfit=False,
-                verbose=True,
-            )
-            LGR.info(
-                "Maximum correlation amplitude with noise regressor is "
-                + str(optiondict[f"noisecorr_pass{thepass}"])
-                + " at "
-                + str(optiondict[f"noisedelay_pass{thepass}"])
-            )
-
-            # regress out
-            resampref_y, datatoremove, R, coffs = tide_fit.glmfilt(
-                resampref_y, shiftednoise, debug=True
-            )
-
-            # save
-            tide_io.writebidstsv(
-                f"{outputname}_desc-regressornoiseremoval_timeseries",
-                shiftednoise,
-                1.0 / oversamptr,
-                starttime=0.0,
-                columns=[f"shiftednoise_pass{thepass}"],
-                append=(thepass > 1),
-            )
-            tide_io.writebidstsv(
-                f"{outputname}_desc-regressornoiseremoval_timeseries",
-                datatoremove,
-                1.0 / oversamptr,
-                starttime=0.0,
-                columns=[f"removed_pass{thepass}"],
-                append=True,
-            )
-            tide_io.writebidstsv(
-                f"{outputname}_desc-regressornoiseremoval_timeseries",
-                resampref_y,
-                1.0 / oversamptr,
-                starttime=0.0,
-                columns=[f"filtered_pass{thepass}"],
-                append=True,
-            )
-
-        if optiondict["check_autocorrelation"]:
-            LGR.info("checking reference regressor autocorrelation properties")
-            optiondict["lagmod"] = 1000.0
-            lagindpad = corrorigin - 2 * np.max((lagmininpts, lagmaxinpts))
-            acmininpts = lagmininpts + lagindpad
-            acmaxinpts = lagmaxinpts + lagindpad
-            theCorrelator.setreftc(referencetc)
-            theCorrelator.setlimits(acmininpts, acmaxinpts)
-            thexcorr, accheckcorrscale, dummy = theCorrelator.run(
-                resampref_y[osvalidsimcalcstart : osvalidsimcalcend + 1]
-            )
-            thefitter.setcorrtimeaxis(accheckcorrscale)
-            (
-                maxindex,
-                maxlag,
-                maxval,
-                acwidth,
-                maskval,
-                peakstart,
-                peakend,
-                thisfailreason,
-            ) = tide_simfuncfit.onesimfuncfit(
-                thexcorr,
-                thefitter,
-                despeckle_thresh=optiondict["despeckle_thresh"],
-                lthreshval=optiondict["lthreshval"],
-                fixdelay=optiondict["fixdelay"],
-                rt_floatset=rt_floatset,
-                rt_floattype=rt_floattype,
-            )
-            outputarray = np.asarray([accheckcorrscale, thexcorr])
-            tide_io.writebidstsv(
-                f"{outputname}_desc-autocorr_timeseries",
-                thexcorr,
-                1.0 / (accheckcorrscale[1] - accheckcorrscale[0]),
-                starttime=accheckcorrscale[0],
-                extraheaderinfo={
-                    "Description": "Autocorrelation of the probe regressor for each pass"
-                },
-                columns=[f"pass{thepass}"],
-                append=(thepass > 1),
-            )
-            thelagthresh = np.max((abs(optiondict["lagmin"]), abs(optiondict["lagmax"])))
-            theampthresh = 0.1
-            LGR.info(
-                f"searching for sidelobes with amplitude > {theampthresh} "
-                f"with abs(lag) < {thelagthresh} s"
-            )
-            sidelobetime, sidelobeamp = tide_corr.check_autocorrelation(
-                accheckcorrscale,
-                thexcorr,
-                acampthresh=theampthresh,
-                aclagthresh=thelagthresh,
-                detrendorder=optiondict["detrendorder"],
-            )
-            optiondict["acwidth"] = acwidth + 0.0
-            optiondict["absmaxsigma"] = acwidth * 10.0
-            passsuffix = "_pass" + str(thepass)
-            if sidelobetime is not None:
-                optiondict["acsidelobelag" + passsuffix] = sidelobetime
-                optiondict["despeckle_thresh"] = np.max(
-                    [optiondict["despeckle_thresh"], sidelobetime / 2.0]
-                )
-                optiondict["acsidelobeamp" + passsuffix] = sidelobeamp
-                LGR.warning(
-                    f"\n\nWARNING: check_autocorrelation found bad sidelobe at {sidelobetime} "
-                    f"seconds ({1.0 / sidelobetime} Hz)..."
-                )
-                # bidsify
-                """tide_io.writebidstsv(
-                    f"{outputname}_desc-movingregressor_timeseries",
-                    tide_math.stdnormalize(resampnonosref_y),
-                    1.0 / fmritr,
-                    columns=["pass1"],
-                    append=False,
-                )"""
-                tide_io.writenpvecs(
-                    np.array([sidelobetime]),
-                    f"{outputname}_autocorr_sidelobetime" + passsuffix + ".txt",
-                )
-                if optiondict["fix_autocorrelation"]:
-                    LGR.info("Removing sidelobe")
-                    if dolagmod:
-                        LGR.info("subjecting lag times to modulus")
-                        optiondict["lagmod"] = sidelobetime / 2.0
-                    if doreferencenotch:
-                        LGR.info("removing spectral component at sidelobe frequency")
-                        acstopfreq = 1.0 / sidelobetime
-                        acfixfilter = tide_filt.NoncausalFilter(
-                            debug=optiondict["debug"],
-                        )
-                        acfixfilter.settype("arb_stop")
-                        acfixfilter.setfreqs(
-                            acstopfreq * 0.9,
-                            acstopfreq * 0.95,
-                            acstopfreq * 1.05,
-                            acstopfreq * 1.1,
-                        )
-                        cleaned_resampref_y = tide_math.corrnormalize(
-                            acfixfilter.apply(1.0 / oversamptr, resampref_y),
-                            windowfunc="None",
-                            detrendorder=optiondict["detrendorder"],
-                        )
-                        cleaned_referencetc = tide_math.corrnormalize(
-                            cleaned_resampref_y,
-                            detrendorder=optiondict["detrendorder"],
-                            windowfunc=optiondict["windowfunc"],
-                        )
-                        cleaned_nonosreferencetc = tide_math.stdnormalize(
-                            acfixfilter.apply(fmrifreq, resampnonosref_y)
-                        )
-                        tide_io.writebidstsv(
-                            f"{outputname}_desc-cleanedreferencefmrires_info",
-                            cleaned_nonosreferencetc,
-                            fmrifreq,
-                            columns=[f"pass{thepass}"],
-                            append=(thepass > 1),
-                        )
-                        tide_io.writebidstsv(
-                            f"{outputname}_desc-cleanedreference_info",
-                            cleaned_referencetc,
-                            1.0 / oversamptr,
-                            columns=[f"pass{thepass}"],
-                            append=(thepass > 1),
-                        )
-                        tide_io.writebidstsv(
-                            f"{outputname}_desc-cleanedresamprefy_info",
-                            cleaned_resampref_y,
-                            1.0 / oversamptr,
-                            columns=[f"pass{thepass}"],
-                            append=(thepass > 1),
-                        )
-                else:
-                    cleaned_resampref_y = 1.0 * tide_math.corrnormalize(
-                        resampref_y,
-                        windowfunc="None",
-                        detrendorder=optiondict["detrendorder"],
-                    )
-                    cleaned_referencetc = 1.0 * referencetc
-                    cleaned_nonosreferencetc = 1.0 * resampnonosref_y
-            else:
-                LGR.info("no sidelobes found in range")
-                cleaned_resampref_y = 1.0 * tide_math.corrnormalize(
-                    resampref_y,
-                    windowfunc="None",
-                    detrendorder=optiondict["detrendorder"],
-                )
-                cleaned_referencetc = 1.0 * referencetc
-                cleaned_nonosreferencetc = 1.0 * resampnonosref_y
-        else:
-            cleaned_resampref_y = 1.0 * tide_math.corrnormalize(
-                resampref_y, windowfunc="None", detrendorder=optiondict["detrendorder"]
+        passsuffix = "_pass" + str(thepass)
+        (
+            cleaned_resampref_y,
+            cleaned_referencetc,
+            cleaned_nonosreferencetc,
+            optiondict["despeckle_thresh"],
+            optiondict["acsidelobeamp" + passsuffix],
+            optiondict["acsidelobelag" + passsuffix],
+            optiondict["lagmod"],
+            optiondict["acwidth"],
+            optiondict["absmaxsigma"],
+        ) = tide_cleanregressor.cleanregressor(
+            outputname,
+            thepass,
+            referencetc,
+            resampref_y,
+            resampnonosref_y,
+            fmrifreq,
+            oversampfreq,
+            osvalidsimcalcstart,
+            osvalidsimcalcend,
+            lagmininpts,
+            lagmaxinpts,
+            theFitter,
+            theCorrelator,
+            optiondict["lagmin"],
+            optiondict["lagmax"],
+            LGR=LGR,
+            check_autocorrelation=optiondict["check_autocorrelation"],
+            fix_autocorrelation=optiondict["fix_autocorrelation"],
+            despeckle_thresh=optiondict["despeckle_thresh"],
+            lthreshval=optiondict["lthreshval"],
+            fixdelay=optiondict["fixdelay"],
+            detrendorder=optiondict["detrendorder"],
+            windowfunc=optiondict["windowfunc"],
+            respdelete=optiondict["respdelete"],
+            debug=optiondict["debug"],
+            rt_floattype=rt_floattype,
+        )
+        if optiondict["debug"]:
+            print(
+                f"after cleanregressor: {len(referencetc)=}, {len(cleaned_referencetc)=}, {osvalidsimcalcstart=}, {osvalidsimcalcend=}, {lagmininpts=}, {lagmaxinpts=}"
             )
-            cleaned_referencetc = 1.0 * referencetc
-            cleaned_nonosreferencetc = 1.0 * resampnonosref_y
 
         # Step 0 - estimate significance
         if optiondict["numestreps"] > 0:
             TimingLGR.info(f"Significance estimation start, pass {thepass}")
             LGR.info(f"\n\nSignificance estimation, pass {thepass}")
-            getNullDistributionData_func = addmemprofiling(
-                tide_nullsimfunc.getNullDistributionDatax,
-                optiondict["memprofile"],
-                "before getnulldistristributiondata",
-            )
             if optiondict["checkpoint"]:
                 # bidsify
-                """tide_io.writebidstsv(
-                    f"{outputname}_desc-movingregressor_timeseries",
-                    tide_math.stdnormalize(resampnonosref_y),
-                    1.0 / fmritr,
-                    columns=["pass1"],
-                    append=False,
-                )"""
                 tide_io.writenpvecs(
                     cleaned_referencetc,
                     f"{outputname}_cleanedreference_pass" + str(thepass) + ".txt",
@@ -2070,34 +2021,36 @@ def rapidtide_main(argparsingfunc):
                     f"{outputname}_options_pregetnull_pass" + str(thepass) + ".json",
                 )
             theCorrelator.setlimits(lagmininpts, lagmaxinpts)
+            if optiondict["debug"]:
+                print(
+                    f"calling setreftc prior to significance estimation with length {len(cleaned_resampref_y)}"
+                )
             theCorrelator.setreftc(cleaned_resampref_y)
             theMutualInformationator.setlimits(lagmininpts, lagmaxinpts)
             theMutualInformationator.setreftc(cleaned_resampref_y)
             dummy, trimmedcorrscale, dummy = theCorrelator.getfunction()
-            thefitter.setcorrtimeaxis(trimmedcorrscale)
-            # add parallel path for mutualinformationator BBF
+            theFitter.setcorrtimeaxis(trimmedcorrscale)
+
+            # parallel path for mutual information
             if optiondict["similaritymetric"] == "mutualinfo":
                 theSimFunc = theMutualInformationator
             else:
                 theSimFunc = theCorrelator
-            disablemkl(optiondict["nprocs_getNullDist"], debug=threaddebug)
-            simdistdata = getNullDistributionData_func(
-                cleaned_resampref_y,
+            tide_util.disablemkl(optiondict["nprocs_getNullDist"], debug=optiondict["threaddebug"])
+            simdistdata = tide_nullsimfunc.getNullDistributionData(
                 oversampfreq,
                 theSimFunc,
-                thefitter,
+                theFitter,
+                LGR,
                 numestreps=optiondict["numestreps"],
                 nprocs=optiondict["nprocs_getNullDist"],
                 alwaysmultiproc=optiondict["alwaysmultiproc"],
                 showprogressbar=optiondict["showprogressbar"],
                 chunksize=optiondict["mp_chunksize"],
                 permutationmethod=optiondict["permutationmethod"],
-                fixdelay=optiondict["fixdelay"],
-                fixeddelayvalue=optiondict["fixeddelayvalue"],
-                rt_floatset=np.float64,
-                rt_floattype="float64",
+                rt_floattype=np.float64,
             )
-            enablemkl(optiondict["mklthreads"], debug=threaddebug)
+            tide_util.enablemkl(optiondict["mklthreads"], debug=optiondict["threaddebug"])
 
             tide_io.writebidstsv(
                 f"{outputname}_desc-simdistdata_info",
@@ -2136,22 +2089,22 @@ def rapidtide_main(argparsingfunc):
                 similaritymetric=optiondict["similaritymetric"],
                 twotail=optiondict["bipolar"],
                 nozero=optiondict["nohistzero"],
-                dosighistfit=optiondict["dosighistfit"],
             )
+            if sigfit is None:
+                optiondict["ampthreshfromsig"] = False
             if pcts is not None:
                 for i in range(len(thepvalnames)):
                     optiondict[
                         "p_lt_" + thepvalnames[i] + "_pass" + str(thepass) + "_thresh.txt"
                     ] = pcts[i]
-                    if optiondict["dosighistfit"]:
-                        optiondict[
-                            "p_lt_" + thepvalnames[i] + "_pass" + str(thepass) + "_fitthresh"
-                        ] = pcts_fit[i]
-                        optiondict["sigfit"] = sigfit
+                    optiondict[
+                        "p_lt_" + thepvalnames[i] + "_pass" + str(thepass) + "_fitthresh"
+                    ] = pcts_fit[i]
+                    optiondict["sigfit"] = sigfit
                 if optiondict["ampthreshfromsig"]:
                     if pcts is not None:
                         LGR.info(
-                            f"setting ampthresh to the p < {1.0 - thepercentiles[0]:.3f} threshhold"
+                            f"setting ampthresh to the p < {1.0 - thepercentiles[0]:.3f} threshold"
                         )
                         optiondict["ampthresh"] = pcts[0]
                         tide_stats.printthresholds(
@@ -2159,25 +2112,24 @@ def rapidtide_main(argparsingfunc):
                             thepercentiles,
                             "Crosscorrelation significance thresholds from data:",
                         )
-                        if optiondict["dosighistfit"]:
-                            tide_stats.printthresholds(
-                                pcts_fit,
-                                thepercentiles,
-                                "Crosscorrelation significance thresholds from fit:",
-                            )
-                            namesuffix = "_desc-nullsimfunc_hist"
-                            tide_stats.makeandsavehistogram(
-                                simdistdata,
-                                optiondict["sighistlen"],
-                                0,
-                                outputname + namesuffix,
-                                displaytitle="Null correlation histogram",
-                                refine=False,
-                                dictvarname="nullsimfunchist_pass" + str(thepass),
-                                therange=(0.0, 1.0),
-                                append=(thepass > 1),
-                                thedict=optiondict,
-                            )
+                        tide_stats.printthresholds(
+                            pcts_fit,
+                            thepercentiles,
+                            "Crosscorrelation significance thresholds from fit:",
+                        )
+                        namesuffix = "_desc-nullsimfunc_hist"
+                        tide_stats.makeandsavehistogram(
+                            simdistdata,
+                            optiondict["sighistlen"],
+                            0,
+                            outputname + namesuffix,
+                            displaytitle="Null correlation histogram",
+                            refine=False,
+                            dictvarname="nullsimfunchist_pass" + str(thepass),
+                            therange=(0.0, 1.0),
+                            append=(thepass > 1),
+                            thedict=optiondict,
+                        )
                     else:
                         LGR.info("leaving ampthresh unchanged")
                 else:
@@ -2191,347 +2143,207 @@ def rapidtide_main(argparsingfunc):
                     "message3": "repetitions",
                 },
             )
-
         # write out the current version of the run options
         optiondict["currentstage"] = f"precorrelation_pass{thepass}"
         tide_io.writedicttojson(optiondict, f"{outputname}_desc-runoptions_info.json")
 
-        # Step 1 - Correlation step
-        if optiondict["similaritymetric"] == "mutualinfo":
-            similaritytype = "Mutual information"
-        elif optiondict["similaritymetric"] == "correlation":
-            similaritytype = "Correlation"
-        else:
-            similaritytype = "MI enhanced correlation"
-        LGR.info(f"\n\n{similaritytype} calculation, pass {thepass}")
-        TimingLGR.info(f"{similaritytype} calculation start, pass {thepass}")
-        calcsimilaritypass_func = addmemprofiling(
-            tide_calcsimfunc.correlationpass,
-            optiondict["memprofile"],
-            "before correlationpass",
+        # Step 1a - do the initial delay estimation
+        similaritytype = tide_calcSimFuncMap.calcSimFunc(
+            numvalidspatiallocs,
+            fmri_data_valid,
+            validsimcalcstart,
+            validsimcalcend,
+            osvalidsimcalcstart,
+            osvalidsimcalcend,
+            initial_fmri_x,
+            os_fmri_x,
+            theCorrelator,
+            theMutualInformationator,
+            cleaned_referencetc,
+            corrout,
+            riptideregressorset,
+            riptidedelays,
+            sLFOfitmean,
+            r2value,
+            fitcoeff,
+            fitNorm,
+            meanval,
+            corrscale,
+            outputname,
+            outcorrarray,
+            validvoxels,
+            nativecorrshape,
+            theinputdata,
+            theheader,
+            lagmininpts,
+            lagmaxinpts,
+            thepass,
+            optiondict,
+            LGR,
+            TimingLGR,
+            similaritymetric=optiondict["similaritymetric"],
+            simcalcoffset=optiondict["simcalcoffset"],
+            echocancel=optiondict["echocancel"],
+            checkpoint=optiondict["checkpoint"],
+            mklthreads=optiondict["mklthreads"],
+            nprocs=optiondict["nprocs_calcsimilarity"],
+            alwaysmultiproc=optiondict["alwaysmultiproc"],
+            oversampfactor=optiondict["oversampfactor"],
+            interptype=optiondict["interptype"],
+            showprogressbar=optiondict["showprogressbar"],
+            chunksize=optiondict["mp_chunksize"],
+            rt_floattype=rt_floattype,
+            threaddebug=optiondict["threaddebug"],
+            debug=optiondict["debug"],
         )
-
-        disablemkl(optiondict["nprocs_calcsimilarity"], debug=threaddebug)
-        if optiondict["similaritymetric"] == "mutualinfo":
-            theMutualInformationator.setlimits(lagmininpts, lagmaxinpts)
-            (
-                voxelsprocessed_cp,
-                theglobalmaxlist,
-                trimmedcorrscale,
-            ) = calcsimilaritypass_func(
-                fmri_data_valid[:, validsimcalcstart : validsimcalcend + 1],
-                cleaned_referencetc,
-                theMutualInformationator,
-                initial_fmri_x[validsimcalcstart : validsimcalcend + 1],
-                os_fmri_x[osvalidsimcalcstart : osvalidsimcalcend + 1],
-                lagmininpts,
-                lagmaxinpts,
-                corrout,
-                meanval,
-                nprocs=optiondict["nprocs_calcsimilarity"],
-                alwaysmultiproc=optiondict["alwaysmultiproc"],
-                oversampfactor=optiondict["oversampfactor"],
-                interptype=optiondict["interptype"],
-                showprogressbar=optiondict["showprogressbar"],
-                chunksize=optiondict["mp_chunksize"],
-                rt_floatset=rt_floatset,
-                rt_floattype=rt_floattype,
-            )
+        if optiondict["similaritymetric"] == "riptide":
+            optiondict["despeckle_passes"] = 0
+            fitcorrscale = riptidedelays
         else:
-            (
-                voxelsprocessed_cp,
-                theglobalmaxlist,
-                trimmedcorrscale,
-            ) = calcsimilaritypass_func(
-                fmri_data_valid[:, validsimcalcstart : validsimcalcend + 1],
-                cleaned_referencetc,
-                theCorrelator,
-                initial_fmri_x[validsimcalcstart : validsimcalcend + 1],
-                os_fmri_x[osvalidsimcalcstart : osvalidsimcalcend + 1],
-                lagmininpts,
-                lagmaxinpts,
-                corrout,
-                meanval,
-                nprocs=optiondict["nprocs_calcsimilarity"],
-                alwaysmultiproc=optiondict["alwaysmultiproc"],
-                oversampfactor=optiondict["oversampfactor"],
-                interptype=optiondict["interptype"],
-                showprogressbar=optiondict["showprogressbar"],
-                chunksize=optiondict["mp_chunksize"],
-                rt_floatset=rt_floatset,
-                rt_floattype=rt_floattype,
-            )
-        enablemkl(optiondict["mklthreads"], debug=threaddebug)
+            fitcorrscale = trimmedcorrscale
 
-        for i in range(len(theglobalmaxlist)):
-            theglobalmaxlist[i] = corrscale[theglobalmaxlist[i]] - optiondict["simcalcoffset"]
-        namesuffix = "_desc-globallag_hist"
-        tide_stats.makeandsavehistogram(
-            np.asarray(theglobalmaxlist),
-            len(corrscale),
-            0,
-            outputname + namesuffix,
-            displaytitle="Histogram of lag times from global lag calculation",
-            therange=(corrscale[0], corrscale[-1]),
-            refine=False,
-            dictvarname="globallaghist_pass" + str(thepass),
-            append=(optiondict["echocancel"] or (thepass > 1)),
-            thedict=optiondict,
-        )
-
-        if optiondict["checkpoint"]:
-            outcorrarray[:, :] = 0.0
-            outcorrarray[validvoxels, :] = corrout[:, :]
-            if optiondict["textio"]:
-                tide_io.writenpvecs(
-                    outcorrarray.reshape(nativecorrshape),
-                    f"{outputname}_corrout_prefit_pass" + str(thepass) + ".txt",
-                )
-            else:
-                savename = f"{outputname}_desc-corroutprefit_pass-" + str(thepass)
-                tide_io.savetonifti(outcorrarray.reshape(nativecorrshape), theheader, savename)
-
-        TimingLGR.info(
-            f"{similaritytype} calculation end, pass {thepass}",
-            {
-                "message2": voxelsprocessed_cp,
-                "message3": "voxels",
-            },
-        )
-
-        # Step 1b.  Do a peak prefit
-        if optiondict["similaritymetric"] == "hybrid":
-            LGR.info(f"\n\nPeak prefit calculation, pass {thepass}")
-            TimingLGR.info(f"Peak prefit calculation start, pass {thepass}")
-            peakevalpass_func = addmemprofiling(
-                tide_peakeval.peakevalpass,
-                optiondict["memprofile"],
-                "before peakevalpass",
-            )
-
-            disablemkl(optiondict["nprocs_peakeval"], debug=threaddebug)
-            voxelsprocessed_pe, thepeakdict = peakevalpass_func(
-                fmri_data_valid[:, validsimcalcstart : validsimcalcend + 1],
-                cleaned_referencetc,
-                initial_fmri_x[validsimcalcstart : validsimcalcend + 1],
-                os_fmri_x[osvalidsimcalcstart : osvalidsimcalcend + 1],
-                theMutualInformationator,
-                trimmedcorrscale,
-                corrout,
-                nprocs=optiondict["nprocs_peakeval"],
-                alwaysmultiproc=optiondict["alwaysmultiproc"],
-                bipolar=optiondict["bipolar"],
-                oversampfactor=optiondict["oversampfactor"],
-                interptype=optiondict["interptype"],
-                showprogressbar=optiondict["showprogressbar"],
-                chunksize=optiondict["mp_chunksize"],
-                rt_floatset=rt_floatset,
+        if optiondict["saveintermediatemaps"]:
+            theheader = theinputdata.copyheader(numtimepoints=1)
+            bidspasssuffix = f"_intermediatedata-pass{thepass}"
+            maplist = [
+                (lagtimes, "maxtimecoarse", "map", "second", "Lag time in seconds"),
+                (lagstrengths, "maxcorrcoarse", "map", None, "Maximum correlation strength"),
+            ]
+            tide_io.savemaplist(
+                f"{outputname}{bidspasssuffix}",
+                maplist,
+                validvoxels,
+                nativespaceshape,
+                theheader,
+                bidsbasedict,
+                filetype=theinputdata.filetype,
                 rt_floattype=rt_floattype,
+                cifti_hdr=theinputdata.cifti_hdr,
             )
-            enablemkl(optiondict["mklthreads"], debug=threaddebug)
-
-            TimingLGR.info(
-                f"Peak prefit end, pass {thepass}",
-                {
-                    "message2": voxelsprocessed_pe,
-                    "message3": "voxels",
-                },
-            )
-            mipeaks = lagtimes * 0.0
-            for i in range(numvalidspatiallocs):
-                if len(thepeakdict[str(i)]) > 0:
-                    mipeaks[i] = thepeakdict[str(i)][0][0]
-        else:
-            thepeakdict = None
 
-        # Step 2 - similarity function fitting and time lag estimation
-        # write out the current version of the run options
-        optiondict["currentstage"] = f"presimfuncfit_pass{thepass}"
-        tide_io.writedicttojson(optiondict, f"{outputname}_desc-runoptions_info.json")
-        LGR.info(f"\n\nTime lag estimation pass {thepass}")
-        TimingLGR.info(f"Time lag estimation start, pass {thepass}")
-        fitcorr_func = addmemprofiling(
-            tide_simfuncfit.fitcorr, optiondict["memprofile"], "before fitcorr"
-        )
-        thefitter.setfunctype(optiondict["similaritymetric"])
-        thefitter.setcorrtimeaxis(trimmedcorrscale)
-
-        # use initial lags if this is a hybrid fit
-        if optiondict["similaritymetric"] == "hybrid" and thepeakdict is not None:
-            initlags = mipeaks
-        else:
-            initlags = None
-
-        disablemkl(optiondict["nprocs_fitcorr"], debug=threaddebug)
-        voxelsprocessed_fc = fitcorr_func(
-            trimmedcorrscale,
-            thefitter,
+        # Step 2a - fit the delay function
+        internaldespeckleincludemask = tide_fitSimFuncMap.fitSimFunc(
+            fmri_data_valid,
+            validsimcalcstart,
+            validsimcalcend,
+            osvalidsimcalcstart,
+            osvalidsimcalcend,
+            initial_fmri_x,
+            os_fmri_x,
+            theMutualInformationator,
+            cleaned_referencetc,
             corrout,
+            outputname,
+            validvoxels,
+            nativespaceshape,
+            bidsbasedict,
+            numspatiallocs,
+            gaussout,
+            theinitialdelay,
+            windowout,
+            R2,
+            thesizes,
+            internalspaceshape,
+            numvalidspatiallocs,
+            theinputdata,
+            theheader,
+            theFitter,
             fitmask,
-            failreason,
             lagtimes,
             lagstrengths,
             lagsigma,
-            gaussout,
-            windowout,
-            R2,
-            despeckling=False,
-            peakdict=thepeakdict,
-            nprocs=optiondict["nprocs_fitcorr"],
-            alwaysmultiproc=optiondict["alwaysmultiproc"],
-            fixdelay=optiondict["fixdelay"],
-            showprogressbar=optiondict["showprogressbar"],
-            chunksize=optiondict["mp_chunksize"],
-            despeckle_thresh=optiondict["despeckle_thresh"],
-            initiallags=initlags,
-            rt_floatset=rt_floatset,
-            rt_floattype=rt_floattype,
+            failreason,
+            outmaparray,
+            fitcorrscale,
+            similaritytype,
+            thepass,
+            optiondict,
+            LGR,
+            TimingLGR,
+            simplefit=(optiondict["similaritymetric"] == "riptide"),
+            rt_floattype=np.float64,
         )
-        enablemkl(optiondict["mklthreads"], debug=threaddebug)
 
-        TimingLGR.info(
-            f"Time lag estimation end, pass {thepass}",
-            {
-                "message2": voxelsprocessed_fc,
-                "message3": "voxels",
-            },
-        )
+        # Step 2b - refine delay (optional)
+        if optiondict["refinedelayeachpass"]:
+            if optiondict["delayoffsetgausssigma"] < 0.0 and theinputdata.filetype != "text":
+                # set gausssigma automatically
+                optiondict["delayoffsetgausssigma"] = np.mean([xdim, ydim, slicethickness]) / 2.0
 
-        # Step 2b - Correlation time despeckle
-        if optiondict["despeckle_passes"] > 0:
-            LGR.info(f"\n\n{similaritytype} despeckling pass {thepass}")
-            LGR.info(f"\tUsing despeckle_thresh = {optiondict['despeckle_thresh']:.3f}")
-            TimingLGR.info(f"{similaritytype} despeckle start, pass {thepass}")
-
-            # find lags that are very different from their neighbors, and refit starting at the median lag for the point
-            voxelsprocessed_fc_ds = 0
-            despecklingdone = False
-            for despecklepass in range(optiondict["despeckle_passes"]):
-                LGR.info(f"\n\n{similaritytype} despeckling subpass {despecklepass + 1}")
-                outmaparray *= 0.0
-                outmaparray[validvoxels] = eval("lagtimes")[:]
-                medianlags = ndimage.median_filter(
-                    outmaparray.reshape(nativespaceshape), 3
-                ).reshape(numspatiallocs)
-                # voxels that we're happy with have initlags set to -1000000.0
-                initlags = np.where(
-                    np.abs(outmaparray - medianlags) > optiondict["despeckle_thresh"],
-                    medianlags,
-                    -1000000.0,
-                )[validvoxels]
-                if len(initlags) > 0:
-                    if len(np.where(initlags != -1000000.0)[0]) > 0:
-                        disablemkl(optiondict["nprocs_fitcorr"], debug=threaddebug)
-                        voxelsprocessed_thispass = fitcorr_func(
-                            trimmedcorrscale,
-                            thefitter,
-                            corrout,
-                            fitmask,
-                            failreason,
-                            lagtimes,
-                            lagstrengths,
-                            lagsigma,
-                            gaussout,
-                            windowout,
-                            R2,
-                            despeckling=True,
-                            peakdict=thepeakdict,
-                            nprocs=optiondict["nprocs_fitcorr"],
-                            alwaysmultiproc=optiondict["alwaysmultiproc"],
-                            fixdelay=optiondict["fixdelay"],
-                            showprogressbar=optiondict["showprogressbar"],
-                            chunksize=optiondict["mp_chunksize"],
-                            despeckle_thresh=optiondict["despeckle_thresh"],
-                            initiallags=initlags,
-                            rt_floatset=rt_floatset,
-                            rt_floattype=rt_floattype,
-                        )
-                        enablemkl(optiondict["mklthreads"], debug=threaddebug)
-
-                        voxelsprocessed_fc_ds += voxelsprocessed_thispass
-                        optiondict[
-                            "despecklemasksize_pass" + str(thepass) + "_d" + str(despecklepass + 1)
-                        ] = voxelsprocessed_thispass
-                        optiondict[
-                            "despecklemaskpct_pass" + str(thepass) + "_d" + str(despecklepass + 1)
-                        ] = (100.0 * voxelsprocessed_thispass / optiondict["corrmasksize"])
-                    else:
-                        despecklingdone = True
-                else:
-                    despecklingdone = True
-                if despecklingdone:
-                    LGR.info("Nothing left to do! Terminating despeckling")
-                    break
-
-            internaldespeckleincludemask = np.where(
-                np.abs(outmaparray - medianlags) > optiondict["despeckle_thresh"],
-                medianlags,
-                0.0,
+            if optiondict["sLFOfiltmask"]:
+                sLFOfiltmask = fitmask + 0.0
+            else:
+                sLFOfiltmask = np.ones_like(fitmask)
+
+            optiondict["regressfiltthreshval"] = 0.0
+
+            (
+                delayoffset,
+                regressderivratios,
+                medfiltregressderivratios,
+                filteredregressderivratios,
+                optiondict["delayoffsetMAD"],
+            ) = 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"],
+                mindelay=optiondict["mindelay"],
+                maxdelay=optiondict["maxdelay"],
+                numpoints=optiondict["numpoints"],
+                histlen=optiondict["histlen"],
+                rt_floattype=rt_floattype,
+                debug=optiondict["debug"],
             )
-            if optiondict["savedespecklemasks"] and (optiondict["despeckle_passes"] > 0):
-                despecklesavemask = np.where(
-                    internaldespeckleincludemask[validvoxels] == 0.0, 0, 1
+            lagtimes[:] = lagtimes + delayoffset
+
+            if optiondict["saveintermediatemaps"]:
+                theheader = theinputdata.copyheader(numtimepoints=1)
+                bidspasssuffix = f"_intermediatedata-pass{thepass}"
+                maplist = [
+                    (lagtimes, "maxtimerefined", "map", "second", "Lag time in seconds"),
+                    (lagstrengths, "maxcorrrefined", "map", None, "Maximum correlation strength"),
+                ]
+                tide_io.savemaplist(
+                    f"{outputname}{bidspasssuffix}",
+                    maplist,
+                    validvoxels,
+                    nativespaceshape,
+                    theheader,
+                    bidsbasedict,
+                    filetype=theinputdata.filetype,
+                    rt_floattype=rt_floattype,
+                    cifti_hdr=theinputdata.cifti_hdr,
                 )
-                if thepass == optiondict["passes"]:
-                    if not optiondict["textio"]:
-                        if fileiscifti:
-                            timeindex = theheader["dim"][0] - 1
-                            spaceindex = theheader["dim"][0]
-                            theheader["dim"][timeindex] = 1
-                            theheader["dim"][spaceindex] = numspatiallocs
-                        else:
-                            theheader["dim"][0] = 3
-                            theheader["dim"][4] = 1
-                            theheader["pixdim"][4] = 1.0
-                    masklist = [
-                        (
-                            despecklesavemask,
-                            "despeckle",
-                            "mask",
-                            None,
-                            "Voxels that underwent despeckling in the final pass",
-                        )
-                    ]
-                    tide_io.savemaplist(
-                        outputname,
-                        masklist,
-                        validvoxels,
-                        nativespaceshape,
-                        theheader,
-                        bidsbasedict,
-                        textio=optiondict["textio"],
-                        fileiscifti=fileiscifti,
-                        rt_floattype=rt_floattype,
-                        cifti_hdr=cifti_hdr,
-                    )
-            LGR.info(
-                f"\n\n{voxelsprocessed_fc_ds} voxels despeckled in "
-                f"{optiondict['despeckle_passes']} passes"
-            )
-            TimingLGR.info(
-                f"{similaritytype} despeckle end, pass {thepass}",
-                {
-                    "message2": voxelsprocessed_fc_ds,
-                    "message3": "voxels",
-                },
-            )
+
         # Step 2c - make a rank order map
         timepercentile = (
             100.0 * (rankdata(lagtimes, method="dense") - 1) / (numvalidspatiallocs - 1)
         )
 
         if optiondict["saveintermediatemaps"]:
-            if not optiondict["textio"]:
-                theheader = copy.deepcopy(nim_hdr)
-                if fileiscifti:
-                    timeindex = theheader["dim"][0] - 1
-                    spaceindex = theheader["dim"][0]
-                    theheader["dim"][timeindex] = 1
-                    theheader["dim"][spaceindex] = numspatiallocs
-                else:
-                    theheader["dim"][0] = 3
-                    theheader["dim"][4] = 1
-                    theheader["pixdim"][4] = 1.0
+            theheader = theinputdata.copyheader(numtimepoints=1)
             bidspasssuffix = f"_intermediatedata-pass{thepass}"
             maplist = [
                 (lagtimes, "maxtime", "map", "second", "Lag time in seconds"),
@@ -2552,10 +2364,9 @@ def rapidtide_main(argparsingfunc):
                 nativespaceshape,
                 theheader,
                 bidsbasedict,
-                textio=optiondict["textio"],
-                fileiscifti=fileiscifti,
+                filetype=theinputdata.filetype,
                 rt_floattype=rt_floattype,
-                cifti_hdr=cifti_hdr,
+                cifti_hdr=theinputdata.cifti_hdr,
             )
 
         # Step 3 - regressor refinement for next pass
@@ -2565,376 +2376,67 @@ def rapidtide_main(argparsingfunc):
         if (
             thepass < optiondict["passes"]
             or optiondict["convergencethresh"] is not None
-            or optiondict["globalpreselect"]
+            or optiondict["initregressorpreselect"]
+            or optiondict["dofinalrefine"]
         ):
-            LGR.info(f"\n\nRegressor refinement, pass {thepass}")
-            TimingLGR.info(f"Regressor refinement start, pass {thepass}")
-            if optiondict["refineoffset"]:
-                # check that we won't end up excluding all voxels from offset calculation before accepting mask
-                offsetmask = np.uint16(fitmask)
-                if internaloffsetincludemask_valid is not None:
-                    offsetmask[np.where(internaloffsetincludemask_valid == 0)] = 0
-                if internaloffsetexcludemask_valid is not None:
-                    offsetmask[np.where(internaloffsetexcludemask_valid != 0.0)] = 0
-                if tide_stats.getmasksize(offsetmask) == 0:
-                    LGR.warning(
-                        "NB: cannot exclude voxels from offset calculation mask - including for this pass"
-                    )
-                    offsetmask = fitmask
-
-                peaklag, peakheight, peakwidth = tide_stats.gethistprops(
-                    lagtimes[np.where(offsetmask > 0)],
-                    optiondict["histlen"],
-                    pickleft=optiondict["pickleft"],
-                    peakthresh=optiondict["pickleftthresh"],
-                )
-                optiondict["offsettime"] = peaklag
-                optiondict["offsettime_total"] += peaklag
-                optiondict[f"offsettime_pass{thepass}"] = optiondict["offsettime"]
-                optiondict[f"offsettime_total_pass{thepass}"] = optiondict["offsettime_total"]
-                LGR.info(
-                    f"offset time set to {optiondict['offsettime']:.3f}, "
-                    f"total is {optiondict['offsettime_total']:.3f}"
-                )
-
-            if optiondict["refinedespeckled"] or (optiondict["despeckle_passes"] == 0):
-                # if refinedespeckled is true, or there is no despeckling, masks are unaffected
-                thisinternalrefineexcludemask_valid = internalrefineexcludemask_valid
-            else:
-                # if refinedespeckled is false and there is despeckling, need to make a proper mask
-                if internalrefineexcludemask_valid is None:
-                    # if there is currently no exclude mask, set exclude mask = despeckle mask
-                    thisinternalrefineexcludemask_valid = np.where(
-                        internaldespeckleincludemask[validvoxels] == 0.0, 0, 1
-                    )
-                else:
-                    # if there is a current exclude mask, add any voxels that are being despeckled
-                    thisinternalrefineexcludemask_valid = np.where(
-                        internalrefineexcludemask_valid > 0, 1, 0
-                    )
-                    thisinternalrefineexcludemask_valid[
-                        np.where(internaldespeckleincludemask[validvoxels] != 0.0)
-                    ] = 1
-
-                # now check that we won't end up excluding all voxels from refinement before accepting mask
-                overallmask = np.uint16(fitmask)
-                if internalrefineincludemask_valid is not None:
-                    overallmask[np.where(internalrefineincludemask_valid == 0)] = 0
-                if thisinternalrefineexcludemask_valid is not None:
-                    overallmask[np.where(thisinternalrefineexcludemask_valid != 0.0)] = 0
-                if tide_stats.getmasksize(overallmask) == 0:
-                    LGR.warning(
-                        "NB: cannot exclude despeckled voxels from refinement - including for this pass"
-                    )
-                    thisinternalrefineexcludemask_valid = internalrefineexcludemask_valid
-
-            # regenerate regressor for next pass
-            # create the refinement mask
-            LGR.info("making refine mask")
-            (
-                voxelsprocessed_rrm,
-                refinemask,
-                locationfails,
-                ampfails,
-                lagfails,
-                sigmafails,
-                numinmask,
-            ) = tide_refine.makerefinemask(
-                lagstrengths,
-                lagtimes,
-                lagsigma,
-                fitmask,
-                offsettime=optiondict["offsettime"],
-                ampthresh=optiondict["ampthresh"],
-                lagmaskside=optiondict["lagmaskside"],
-                lagminthresh=optiondict["lagminthresh"],
-                lagmaxthresh=optiondict["lagmaxthresh"],
-                sigmathresh=optiondict["sigmathresh"],
-                cleanrefined=optiondict["cleanrefined"],
-                bipolar=optiondict["bipolar"],
-                includemask=internalrefineincludemask_valid,
-                excludemask=thisinternalrefineexcludemask_valid,
-            )
-
-            if numinmask == 0:
-                LGR.critical("No voxels in refine mask - adjust thresholds or external masks")
-                sys.exit()
-
-            # align timecourses to prepare for refinement
-            alignvoxels_func = addmemprofiling(
-                tide_refine.alignvoxels,
-                optiondict["memprofile"],
-                "before aligning voxel timecourses",
-            )
-            LGR.info("aligning timecourses")
-            disablemkl(optiondict["nprocs_refine"], debug=threaddebug)
-            voxelsprocessed_rra = alignvoxels_func(
-                fmri_data_valid,
-                fmritr,
-                shiftedtcs,
-                weights,
-                paddedshiftedtcs,
-                paddedweights,
-                lagtimes,
-                refinemask,
-                nprocs=optiondict["nprocs_refine"],
-                detrendorder=optiondict["detrendorder"],
-                offsettime=optiondict["offsettime"],
-                alwaysmultiproc=optiondict["alwaysmultiproc"],
-                showprogressbar=optiondict["showprogressbar"],
-                chunksize=optiondict["mp_chunksize"],
-                padtrs=numpadtrs,
-                rt_floatset=rt_floatset,
-                rt_floattype=rt_floattype,
-            )
-            enablemkl(optiondict["mklthreads"], debug=threaddebug)
-            LGR.info(f"align complete: {voxelsprocessed_rra=}")
-
-            LGR.info("prenormalizing timecourses")
-            tide_refine.prenorm(
-                paddedshiftedtcs,
-                refinemask,
-                lagtimes,
-                optiondict["lagmaxthresh"],
-                lagstrengths,
-                R2,
-                optiondict["refineprenorm"],
-                optiondict["refineweighting"],
-            )
-
-            (
-                voxelsprocessed_rr,
-                paddedoutputdata,
-            ) = tide_refine.dorefine(
-                paddedshiftedtcs,
-                refinemask,
-                weights,
-                theprefilter,
-                fmritr,
-                thepass,
-                lagstrengths,
-                lagtimes,
-                optiondict["refinetype"],
-                optiondict["fmrifreq"],
-                optiondict["outputname"],
-                detrendorder=optiondict["detrendorder"],
-                pcacomponents=optiondict["pcacomponents"],
-                dodispersioncalc=optiondict["dodispersioncalc"],
-                dispersioncalc_lower=optiondict["dispersioncalc_lower"],
-                dispersioncalc_upper=optiondict["dispersioncalc_upper"],
-                dispersioncalc_step=optiondict["dispersioncalc_step"],
-                windowfunc=optiondict["windowfunc"],
-                cleanrefined=optiondict["cleanrefined"],
-                bipolar=optiondict["bipolar"],
-                debug=optiondict["debug"],
-                rt_floatset=rt_floatset,
-                rt_floattype=rt_floattype,
-            )
-            optiondict["refinemasksize_pass" + str(thepass)] = voxelsprocessed_rr
-            optiondict["refinemaskpct_pass" + str(thepass)] = (
-                100.0 * voxelsprocessed_rr / optiondict["corrmasksize"]
-            )
-            optiondict["refinelocationfails_pass" + str(thepass)] = locationfails
-            optiondict["refineampfails_pass" + str(thepass)] = ampfails
-            optiondict["refinelagfails_pass" + str(thepass)] = lagfails
-            optiondict["refinesigmafails_pass" + str(thepass)] = sigmafails
-            if voxelsprocessed_rr > 0:
-                paddednormoutputdata = tide_math.stdnormalize(
-                    theprefilter.apply(fmrifreq, paddedoutputdata)
-                )
-                outputdata = paddedoutputdata[numpadtrs:-numpadtrs]
-                normoutputdata = tide_math.stdnormalize(theprefilter.apply(fmrifreq, outputdata))
-                normunfilteredoutputdata = tide_math.stdnormalize(outputdata)
-                tide_io.writebidstsv(
-                    f"{outputname}_desc-refinedmovingregressor_timeseries",
-                    normunfilteredoutputdata,
-                    1.0 / fmritr,
-                    columns=["unfiltered_pass" + str(thepass)],
-                    extraheaderinfo={
-                        "Description": "The raw and filtered probe regressor produced by the refinement procedure, at the time resolution of the data"
-                    },
-                    append=(thepass > 1),
-                )
-                tide_io.writebidstsv(
-                    f"{outputname}_desc-refinedmovingregressor_timeseries",
-                    normoutputdata,
-                    1.0 / fmritr,
-                    columns=["filtered_pass" + str(thepass)],
-                    extraheaderinfo={
-                        "Description": "The raw and filtered probe regressor produced by the refinement procedure, at the time resolution of the data"
-                    },
-                    append=True,
-                )
-
-                # check for convergence
-                regressormse = mse(normoutputdata, previousnormoutputdata)
-                optiondict["regressormse_pass" + str(thepass).zfill(2)] = regressormse
-                LGR.info(f"regressor difference at end of pass {thepass:d} is {regressormse:.6f}")
-                if optiondict["convergencethresh"] is not None:
-                    if thepass >= optiondict["maxpasses"]:
-                        LGR.info("refinement ended (maxpasses reached)")
-                        stoprefining = True
-                        refinestopreason = "maxpassesreached"
-                    elif regressormse < optiondict["convergencethresh"]:
-                        LGR.info("refinement ended (refinement has converged")
-                        stoprefining = True
-                        refinestopreason = "convergence"
-                    else:
-                        stoprefining = False
-                elif thepass >= optiondict["passes"]:
-                    stoprefining = True
-                    refinestopreason = "passesreached"
-                else:
-                    stoprefining = False
-
-                if optiondict["detrendorder"] > 0:
-                    resampnonosref_y = tide_fit.detrend(
-                        tide_resample.doresample(
-                            paddedinitial_fmri_x,
-                            paddednormoutputdata,
-                            initial_fmri_x,
-                            method=optiondict["interptype"],
-                        ),
-                        order=optiondict["detrendorder"],
-                        demean=optiondict["dodemean"],
-                    )
-                    resampref_y = tide_fit.detrend(
-                        tide_resample.doresample(
-                            paddedinitial_fmri_x,
-                            paddednormoutputdata,
-                            os_fmri_x,
-                            method=optiondict["interptype"],
-                        ),
-                        order=optiondict["detrendorder"],
-                        demean=optiondict["dodemean"],
-                    )
-                else:
-                    resampnonosref_y = tide_resample.doresample(
-                        paddedinitial_fmri_x,
-                        paddednormoutputdata,
-                        initial_fmri_x,
-                        method=optiondict["interptype"],
-                    )
-                    resampref_y = tide_resample.doresample(
-                        paddedinitial_fmri_x,
-                        paddednormoutputdata,
-                        os_fmri_x,
-                        method=optiondict["interptype"],
-                    )
-                if optiondict["tmaskname"] is not None:
-                    resampnonosref_y *= tmask_y
-                    thefit, R = tide_fit.mlregress(tmask_y, resampnonosref_y)
-                    resampnonosref_y -= thefit[0, 1] * tmask_y
-                    resampref_y *= tmaskos_y
-                    thefit, R = tide_fit.mlregress(tmaskos_y, resampref_y)
-                    resampref_y -= thefit[0, 1] * tmaskos_y
-
-                # reinitialize genlagtc for resampling
-                previousnormoutputdata = normoutputdata + 0.0
-                genlagtc = tide_resample.FastResampler(
-                    paddedinitial_fmri_x, paddednormoutputdata, padtime=padtime
-                )
-                genlagtc.save(f"{outputname}_desc-lagtcgenerator_timeseries")
-                (
-                    optiondict[f"kurtosis_reference_pass{thepass + 1}"],
-                    optiondict[f"kurtosisz_reference_pass{thepass + 1}"],
-                    optiondict[f"kurtosisp_reference_pass{thepass + 1}"],
-                ) = tide_stats.kurtosisstats(resampref_y)
-                (
-                    optiondict[f"skewness_reference_pass{thepass + 1}"],
-                    optiondict[f"skewnessz_reference_pass{thepass + 1}"],
-                    optiondict[f"skewnessp_reference_pass{thepass + 1}"],
-                ) = tide_stats.skewnessstats(resampref_y)
-                if not stoprefining:
-                    tide_io.writebidstsv(
-                        f"{outputname}_desc-movingregressor_timeseries",
-                        tide_math.stdnormalize(resampnonosref_y),
-                        1.0 / fmritr,
-                        columns=["pass" + str(thepass + 1)],
-                        extraheaderinfo={
-                            "Description": "The probe regressor used in each pass, at the time resolution of the data"
-                        },
-                        append=True,
-                    )
-                    tide_io.writebidstsv(
-                        f"{outputname}_desc-oversampledmovingregressor_timeseries",
-                        tide_math.stdnormalize(resampref_y),
-                        oversampfreq,
-                        columns=["pass" + str(thepass + 1)],
-                        extraheaderinfo={
-                            "Description": "The probe regressor used in each pass, at the time resolution used for calculating the similarity function"
-                        },
-                        append=True,
-                    )
-            else:
-                LGR.warning(f"refinement failed - terminating at end of pass {thepass}")
-                stoprefining = True
-                refinestopreason = "emptymask"
-
-            TimingLGR.info(
-                f"Regressor refinement end, pass {thepass}",
-                {
-                    "message2": voxelsprocessed_rr,
-                    "message3": "voxels",
-                },
-            )
-        if optiondict["saveintermediatemaps"]:
-            if not optiondict["textio"]:
-                theheader = copy.deepcopy(nim_hdr)
-                if fileiscifti:
-                    timeindex = theheader["dim"][0] - 1
-                    spaceindex = theheader["dim"][0]
-                    theheader["dim"][timeindex] = 1
-                    theheader["dim"][spaceindex] = numspatiallocs
-                else:
-                    theheader["dim"][0] = 3
-                    theheader["dim"][4] = 1
-                    theheader["pixdim"][4] = 1.0
-            bidspasssuffix = f"_intermediatedata-pass{thepass}"
-            maplist = [
-                (fitmask, "corrfit", "mask", None, "Voxels where correlation value was fit"),
-                (
-                    failreason,
-                    "corrfitfailreason",
-                    "info",
-                    None,
-                    "Result codes for correlation fit",
-                ),
-            ]
-            if optiondict["savedespecklemasks"] and (optiondict["despeckle_passes"] > 0):
-                maplist.append(
-                    (
-                        despecklesavemask,
-                        "despecklemask",
-                        "map",
-                        None,
-                        "Voxels that underwent despeckling",
-                    )
-                )
-            if thepass < optiondict["passes"]:
-                maplist.append(
-                    (refinemask, "refinemask", "map", None, "Voxels used for regressor refinement")
+            resampref_y, resampnonosref_y, stoprefining, refinestopreason, genlagtc = (
+                tide_refineRegressor.refineRegressor(
+                    LGR,
+                    TimingLGR,
+                    thepass,
+                    optiondict,
+                    fitmask,
+                    internaloffsetincludemask_valid,
+                    internaloffsetexcludemask_valid,
+                    internalrefineincludemask_valid,
+                    internalrefineexcludemask_valid,
+                    internaldespeckleincludemask,
+                    validvoxels,
+                    theRegressorRefiner,
+                    lagtimes,
+                    lagstrengths,
+                    lagsigma,
+                    fmri_data_valid,
+                    fmritr,
+                    R2,
+                    theprefilter,
+                    previousnormoutputdata,
+                    theinputdata,
+                    numpadtrs,
+                    outputname,
+                    nativefmrishape,
+                    bidsbasedict,
+                    rt_floattype=np.float64,
                 )
-            tide_io.savemaplist(
-                f"{outputname}{bidspasssuffix}",
-                maplist,
-                validvoxels,
-                nativespaceshape,
-                theheader,
-                bidsbasedict,
-                textio=optiondict["textio"],
-                fileiscifti=fileiscifti,
-                rt_floattype=rt_floattype,
-                cifti_hdr=cifti_hdr,
             )
+        # End of main pass loop
 
-    # We are done with refinement.
     if optiondict["convergencethresh"] is None:
         optiondict["actual_passes"] = optiondict["passes"]
     else:
         optiondict["actual_passes"] = thepass - 1
     optiondict["refinestopreason"] = refinestopreason
 
+    # calculate the sLFO growth
+    (
+        filtrms,
+        filtrmslinfit,
+        optiondict["sLFO_startamp"],
+        optiondict["sLFO_endamp"],
+        optiondict["sLFO_changepct"],
+        optiondict["sLFO_changerate"],
+    ) = tide_math.noiseamp(resampref_y, 1.0 / oversamptr, optiondict["sLFOnoiseampwindow"])
+    tide_io.writebidstsv(
+        f"{outputname}_desc-sLFOamplitude_timeseries",
+        np.vstack((filtrms, filtrmslinfit)),
+        oversampfreq,
+        columns=["filteredRMS", "linearfit"],
+        extraheaderinfo={
+            "Description": "Filtered RMS amplitude of the probe regressor, and a linear fit"
+        },
+        append=False,
+    )
+
     # Post refinement step -1 - Coherence calculation
     if optiondict["calccoherence"]:
         TimingLGR.info("Coherence calculation start")
@@ -2958,42 +2460,47 @@ def rapidtide_main(argparsingfunc):
             coherencefreqstep,
             coherencefreqaxissize,
         ) = theCoherer.getaxisinfo()
-        if optiondict["textio"]:
+        if theinputdata.filetype == "text":
             nativecoherenceshape = (xsize, coherencefreqaxissize)
         else:
-            if fileiscifti:
+            if theinputdata.filetype == "cifti":
                 nativecoherenceshape = (1, 1, 1, coherencefreqaxissize, numspatiallocs)
             else:
                 nativecoherenceshape = (xsize, ysize, numslices, coherencefreqaxissize)
 
         internalvalidcoherenceshape = (numvalidspatiallocs, coherencefreqaxissize)
-        internalcoherenceshape = (numspatiallocs, coherencefreqaxissize)
 
         # now allocate the arrays needed for the coherence calculation
+        coherencefunc, coherencefunc_shm = tide_util.allocarray(
+            internalvalidcoherenceshape,
+            rt_outfloattype,
+            shared=optiondict["sharedmem"],
+            name=f"coherencefunc_{optiondict['pid']}",
+        )
+        coherencepeakval, coherencepeakval_shm = tide_util.allocarray(
+            numvalidspatiallocs,
+            rt_outfloattype,
+            shared=optiondict["sharedmem"],
+            name=f"coherencepeakval_{optiondict['pid']}",
+        )
+        coherencepeakfreq, coherencepeakfreq_shm = tide_util.allocarray(
+            numvalidspatiallocs,
+            rt_outfloattype,
+            shared=optiondict["sharedmem"],
+            name=f"coherencepeakfreq_{optiondict['pid']}",
+        )
         if optiondict["sharedmem"]:
-            coherencefunc, dummy, dummy = tide_util.allocshared(
-                internalvalidcoherenceshape, rt_outfloatset
-            )
-            coherencepeakval, dummy, dummy = tide_util.allocshared(
-                numvalidspatiallocs, rt_outfloatset
-            )
-            coherencepeakfreq, dummy, dummy = tide_util.allocshared(
-                numvalidspatiallocs, rt_outfloatset
-            )
+            ramlocation = "in shared memory"
         else:
-            coherencefunc = np.zeros(internalvalidcoherenceshape, dtype=rt_outfloattype)
-            coherencepeakval, dummy, dummy = tide_util.allocshared(
-                numvalidspatiallocs, rt_outfloatset
-            )
-            coherencepeakfreq = np.zeros(numvalidspatiallocs, dtype=rt_outfloattype)
-
-        coherencepass_func = addmemprofiling(
-            tide_calccoherence.coherencepass,
-            optiondict["memprofile"],
-            "before coherencepass",
+            ramlocation = "locally"
+        optiondict["totalcoherencebytes"] = (
+            coherencefunc.nbytes + coherencepeakval.nbytes + coherencepeakfreq.nbytes
         )
-        disablemkl(1, debug=threaddebug)
-        voxelsprocessed_coherence = coherencepass_func(
+        thesize, theunit = tide_util.format_bytes(optiondict["totalcoherencebytes"])
+        print(f"allocated {thesize:.3f} {theunit} {ramlocation} for coherence calculation")
+
+        tide_util.disablemkl(1, debug=optiondict["threaddebug"])
+        voxelsprocessed_coherence = tide_calccoherence.coherencepass(
             fmri_data_valid,
             theCoherer,
             coherencefunc,
@@ -3002,27 +2509,17 @@ def rapidtide_main(argparsingfunc):
             alt=True,
             showprogressbar=optiondict["showprogressbar"],
             chunksize=optiondict["mp_chunksize"],
-            nprocs=1,
+            nprocs=optiondict["nprocs"],
             alwaysmultiproc=optiondict["alwaysmultiproc"],
-            rt_floatset=rt_floatset,
-            rt_floattype=rt_floattype,
         )
-        enablemkl(optiondict["mklthreads"], debug=threaddebug)
+        tide_util.enablemkl(optiondict["mklthreads"], debug=optiondict["threaddebug"])
 
         # save the results of the calculations
-        if not optiondict["textio"]:
-            theheader = copy.deepcopy(nim_hdr)
-            theheader["toffset"] = coherencefreqstart
-            theheader["pixdim"][4] = coherencefreqstep
-            if fileiscifti:
-                timeindex = theheader["dim"][0] - 1
-                spaceindex = theheader["dim"][0]
-                theheader["dim"][timeindex] = coherencefreqaxissize
-                theheader["dim"][spaceindex] = numspatiallocs
-            else:
-                theheader["dim"][0] = 3
-                theheader["dim"][4] = coherencefreqaxissize
-                theheader["pixdim"][4] = 1.0
+        theheader = theinputdata.copyheader(
+            numtimepoints=coherencefreqaxissize,
+            tr=coherencefreqstep,
+            toffset=coherencefreqstart,
+        )
         maplist = [(coherencefunc, "coherence", "info", None, "Coherence function")]
         tide_io.savemaplist(
             outputname,
@@ -3031,12 +2528,10 @@ def rapidtide_main(argparsingfunc):
             nativecoherenceshape,
             theheader,
             bidsbasedict,
-            textio=optiondict["textio"],
-            fileiscifti=fileiscifti,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
-            cifti_hdr=cifti_hdr,
+            cifti_hdr=theinputdata.cifti_hdr,
         )
-        del coherencefunc
 
         TimingLGR.info(
             "Coherence calculation end",
@@ -3052,29 +2547,35 @@ def rapidtide_main(argparsingfunc):
         LGR.info("\n\nWiener deconvolution")
 
         # now allocate the arrays needed for Wiener deconvolution
+        wienerdeconv, wienerdeconv_shm = tide_util.allocarray(
+            internalvalidspaceshape,
+            rt_outfloattype,
+            shared=optiondict["sharedmem"],
+            name=f"wienerdeconv_{optiondict['pid']}",
+        )
+        wpeak, wpeak_shm = tide_util.allocarray(
+            internalvalidspaceshape,
+            rt_outfloattype,
+            shared=optiondict["sharedmem"],
+            name=f"wpeak_{optiondict['pid']}",
+        )
         if optiondict["sharedmem"]:
-            wienerdeconv, dummy, dummy = tide_util.allocshared(
-                internalvalidspaceshape, rt_outfloatset
-            )
-            wpeak, dummy, dummy = tide_util.allocshared(internalvalidspaceshape, rt_outfloatset)
+            ramlocation = "in shared memory"
         else:
-            wienerdeconv = np.zeros(internalvalidspaceshape, dtype=rt_outfloattype)
-            wpeak = np.zeros(internalvalidspaceshape, dtype=rt_outfloattype)
+            ramlocation = "locally"
+        optiondict["totalwienerbytes"] = wienerdeconv.nbytes + wpeak.nbytes
+        thesize, theunit = tide_util.format_bytes(optiondict["totalwienerbytes"])
+        print(f"allocated {thesize:.3f} {theunit} {ramlocation} for wiener deconvolution")
 
-        wienerpass_func = addmemprofiling(
-            tide_wiener.wienerpass,
-            optiondict["memprofile"],
-            "before wienerpass",
-        )
-        voxelsprocessed_wiener = wienerpass_func(
+        voxelsprocessed_wiener = tide_wiener.wienerpass(
             numspatiallocs,
             fmri_data_valid,
             threshval,
+            lagtc,
             optiondict,
             wienerdeconv,
             wpeak,
             resampref_y,
-            rt_floatset=rt_floatset,
             rt_floattype=rt_floattype,
         )
         TimingLGR.info(
@@ -3084,56 +2585,60 @@ def rapidtide_main(argparsingfunc):
                 "message3": "voxels",
             },
         )
+        del wienerdeconv
+        del wpeak
+        if optiondict["sharedmem"]:
+            tide_util.cleanup_shm(wienerdeconv_shm)
+            tide_util.cleanup_shm(wpeak_shm)
 
     ####################################################
-    #  GLM filtering start
+    #  Linear regression filtering start
     ####################################################
-    # Post refinement step 1 - GLM fitting, either to remove moving signal, or to calculate delayed CVR
+    # Post refinement step 1 - regression fitting, either to remove moving signal, or to calculate delayed CVR
     # write out the current version of the run options
-    optiondict["currentstage"] = "preglm"
+    optiondict["currentstage"] = "presLFOfit"
     tide_io.writedicttojson(optiondict, f"{outputname}_desc-runoptions_info.json")
-    if optiondict["doglmfilt"] or optiondict["docvrmap"]:
-        if optiondict["doglmfilt"]:
-            TimingLGR.info("GLM filtering start")
-            LGR.info("\n\nGLM filtering")
+    if optiondict["dolinfitfilt"] or optiondict["docvrmap"] or optiondict["refinedelay"]:
+        if optiondict["sLFOfiltmask"]:
+            sLFOfiltmask = fitmask + 0.0
+        else:
+            sLFOfiltmask = np.ones_like(fitmask)
+        if optiondict["dolinfitfilt"]:
+            if optiondict["refinedelay"]:
+                TimingLGR.info("Setting up for delay refinement and sLFO filtering")
+                LGR.info("\n\nDelay refinement and sLFO filtering setup")
+            else:
+                TimingLGR.info("Setting up for sLFO filtering")
+                LGR.info("\n\nsLFO filtering setup")
+        elif optiondict["docvrmap"]:
+            if optiondict["refinedelay"]:
+                TimingLGR.info("Setting up for delay refinement and CVR map generation")
+                LGR.info("\n\nDelay refinement and CVR mapping setup")
+            else:
+                TimingLGR.info("Setting up for CVR map generation")
+                LGR.info("\n\nCVR mapping setup")
         else:
-            TimingLGR.info("CVR map generation start")
-            LGR.info("\n\nCVR mapping")
+            TimingLGR.info("Setting up for delay refinement")
+            LGR.info("\n\nDelay refinement setup")
         if (
             (optiondict["gausssigma"] > 0.0)
-            or (optiondict["glmsourcefile"] is not None)
+            or (optiondict["denoisesourcefile"] is not None)
             or optiondict["docvrmap"]
         ):
-            if optiondict["glmsourcefile"] is not None:
-                LGR.info(f"reading in {optiondict['glmsourcefile']} for GLM filter, please wait")
-                sourcename = optiondict["glmsourcefile"]
-            else:
-                LGR.info(f"rereading {fmrifilename} for GLM filter, please wait")
-                sourcename = fmrifilename
-            if fileiscifti:
-                LGR.info("input file is CIFTI")
-                (
-                    cifti,
-                    cifti_hdr,
-                    nim_data,
-                    nim_hdr,
-                    thedims,
-                    thesizes,
-                    dummy,
-                ) = tide_io.readfromcifti(sourcename)
-            else:
-                if optiondict["textio"]:
-                    nim_data = tide_io.readvecs(sourcename)
-                else:
-                    nim, nim_data, nim_hdr, thedims, thesizes = tide_io.readfromnifti(sourcename)
+            if optiondict["denoisesourcefile"] is not None:
+                LGR.info(
+                    f"reading in {optiondict['denoisesourcefile']} for sLFO filter, please wait"
+                )
+                sourcename = optiondict["denoisesourcefile"]
+                theinputdata = tide_voxelData.VoxelData(sourcename, timestep=optiondict["realtr"])
+                theinputdata.setvalidtimes(validstart, validend)
+                theinputdata.setvalidvoxels(validvoxels)
 
-            fmri_data_valid = (
-                nim_data.reshape((numspatiallocs, timepoints))[:, validstart : validend + 1]
-            )[validvoxels, :] + 0.0
+            fmri_data_valid = theinputdata.validdata() + 0.0
 
             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]
 
@@ -3149,79 +2654,58 @@ def rapidtide_main(argparsingfunc):
 
             # move fmri_data_valid into shared memory
             if optiondict["sharedmem"]:
+                tide_util.cleanup_shm(fmri_data_valid_shm)
                 LGR.info("moving fmri data to shared memory")
                 TimingLGR.info("Start moving fmri_data to shared memory")
-                numpy2shared_func = addmemprofiling(
-                    tide_util.numpy2shared,
-                    optiondict["memprofile"],
-                    "before movetoshared (glm)",
+                fmri_data_valid, fmri_data_valid_shm = tide_util.numpy2shared(
+                    fmri_data_valid,
+                    rt_floattype,
+                    name=f"fmri_data_valid_regressionfilt_{optiondict['pid']}",
                 )
-                fmri_data_valid = numpy2shared_func(fmri_data_valid, rt_floatset)
                 TimingLGR.info("End moving fmri_data to shared memory")
-            del nim_data
+            theinputdata.unload()
 
-        # now allocate the arrays needed for GLM filtering
-        internalvalidspaceshapederivs = (
-            internalvalidspaceshape,
-            optiondict["glmderivs"] + 1,
+        # allocate the arrays needed for sLFO filtering
+        movingsignal, movingsignal_shm = tide_util.allocarray(
+            internalvalidfmrishape,
+            rt_outfloattype,
+            shared=optiondict["sharedmem"],
+            name=f"movingsignal_{optiondict['pid']}",
+        )
+        filtereddata, filtereddata_shm = tide_util.allocarray(
+            internalvalidfmrishape,
+            rt_outfloattype,
+            shared=optiondict["sharedmem"],
+            name=f"filtereddata_{optiondict['pid']}",
         )
         if optiondict["sharedmem"]:
-            glmmean, dummy, dummy = tide_util.allocshared(internalvalidspaceshape, rt_outfloatset)
-            rvalue, dummy, dummy = tide_util.allocshared(internalvalidspaceshape, rt_outfloatset)
-            r2value, dummy, dummy = tide_util.allocshared(internalvalidspaceshape, rt_outfloatset)
-            fitNorm, dummy, dummy = tide_util.allocshared(
-                internalvalidspaceshapederivs, rt_outfloatset
-            )
-            fitcoeff, dummy, dummy = tide_util.allocshared(
-                internalvalidspaceshapederivs, rt_outfloatset
-            )
-            movingsignal, dummy, dummy = tide_util.allocshared(
-                internalvalidfmrishape, rt_outfloatset
-            )
-            lagtc, dummy, dummy = tide_util.allocshared(internalvalidfmrishape, rt_floatset)
-            filtereddata, dummy, dummy = tide_util.allocshared(
-                internalvalidfmrishape, rt_outfloatset
-            )
-        else:
-            glmmean = np.zeros(internalvalidspaceshape, dtype=rt_outfloattype)
-            rvalue = np.zeros(internalvalidspaceshape, dtype=rt_outfloattype)
-            r2value = np.zeros(internalvalidspaceshape, dtype=rt_outfloattype)
-            fitNorm = np.zeros(internalvalidspaceshapederivs, dtype=rt_outfloattype)
-            fitcoeff = np.zeros(internalvalidspaceshapederivs, dtype=rt_outfloattype)
-            movingsignal = np.zeros(internalvalidfmrishape, dtype=rt_outfloattype)
-            lagtc = np.zeros(internalvalidfmrishape, dtype=rt_floattype)
-            filtereddata = np.zeros(internalvalidfmrishape, dtype=rt_outfloattype)
-
-        if optiondict["memprofile"]:
-            if optiondict["doglmfilt"]:
-                memcheckpoint("about to start glm noise removal...")
-            else:
-                memcheckpoint("about to start CVR magnitude estimation...")
+            ramlocation = "in shared memory"
         else:
-            tide_util.logmem("before glm")
+            ramlocation = "locally"
 
-        if optiondict["doglmfilt"]:
+        optiondict["totalsLFOfilterbytes"] = movingsignal.nbytes + filtereddata.nbytes
+        thesize, theunit = tide_util.format_bytes(optiondict["totalsLFOfilterbytes"])
+        print(f"allocated {thesize:.3f} {theunit} {ramlocation} for sLFO filter")
+        tide_util.logmem("before sLFO filter")
+
+        if optiondict["dolinfitfilt"]:
             mode = "glm"
-            optiondict["glmthreshval"] = threshval
+            optiondict["regressfiltthreshval"] = threshval
         else:
             # set the threshval to zero
             mode = "cvrmap"
-            optiondict["glmthreshval"] = 0.0
-        if optiondict["focaldebug"]:
-            # dump the fmri input file going to glm
-            if not optiondict["textio"]:
-                theheader = copy.deepcopy(nim_hdr)
-                if fileiscifti:
-                    timeindex = theheader["dim"][0] - 1
-                    spaceindex = theheader["dim"][0]
-                    theheader["dim"][timeindex] = np.shape(outfmriarray)[1]
-                    theheader["dim"][spaceindex] = numspatiallocs
-                else:
-                    theheader["dim"][4] = np.shape(outfmriarray)[1]
-                    theheader["pixdim"][4] = fmritr
+            optiondict["regressfiltthreshval"] = 0.0
+
+        if optiondict["debug"]:
+            # dump the fmri input file going to sLFO filter
+            if theinputdata.filetype != "text":
+                outfmriarray = np.zeros(internalfmrishape, dtype=rt_floattype)
+                theheader = theinputdata.copyheader(
+                    numtimepoints=np.shape(outfmriarray)[1], tr=fmritr
+                )
             else:
                 theheader = None
-                cifti_hdr = None
+                outfmriarray = None
 
             maplist = [
                 (
@@ -3229,7 +2713,7 @@ def rapidtide_main(argparsingfunc):
                     "datatofilter",
                     "bold",
                     None,
-                    "fMRI data that will be subjected to GLM filtering",
+                    "fMRI data that will be subjected to sLFO filtering",
                 ),
             ]
             tide_io.savemaplist(
@@ -3239,77 +2723,278 @@ def rapidtide_main(argparsingfunc):
                 nativefmrishape,
                 theheader,
                 bidsbasedict,
-                textio=optiondict["textio"],
-                fileiscifti=fileiscifti,
+                filetype=theinputdata.filetype,
                 rt_floattype=rt_floattype,
-                cifti_hdr=cifti_hdr,
+                cifti_hdr=theinputdata.cifti_hdr,
             )
+        else:
+            outfmriarray = None
 
-        # calculate the initial bandlimited mean normalized variance if we're going to filter the data
-        initialvariance = tide_math.imagevariance(fmri_data_valid, theprefilter, 1.0 / fmritr)
+        # refine the delay value prior to calculating the sLFO filter
+        if optiondict["refinedelay"]:
+            TimingLGR.info("Delay refinement start")
+            LGR.info("\n\nDelay refinement")
 
-        voxelsprocessed_glm, regressorset = tide_glmfrommaps.glmfrommaps(
-            fmri_data_valid,
-            validvoxels,
-            initial_fmri_x,
-            lagtimes,
-            fitmask,
-            genlagtc,
-            mode,
-            outputname,
-            oversamptr,
-            glmmean,
-            rvalue,
-            r2value,
-            fitNorm,
-            fitcoeff,
-            movingsignal,
-            lagtc,
-            filtereddata,
-            LGR,
-            TimingLGR,
-            optiondict["glmthreshval"],
-            optiondict["saveminimumglmfiles"],
-            nprocs_makelaggedtcs=optiondict["nprocs_makelaggedtcs"],
-            nprocs_glm=optiondict["nprocs_glm"],
-            glmderivs=optiondict["glmderivs"],
-            mp_chunksize=optiondict["mp_chunksize"],
-            showprogressbar=optiondict["showprogressbar"],
-            alwaysmultiproc=optiondict["alwaysmultiproc"],
-            memprofile=optiondict["memprofile"],
-            debug=optiondict["focaldebug"],
-        )
+            if optiondict["delayoffsetgausssigma"] < 0.0 and theinputdata.filetype != "text":
+                # set gausssigma automatically
+                optiondict["delayoffsetgausssigma"] = np.mean([xdim, ydim, slicethickness]) / 2.0
 
-        # calculate the final bandlimited mean normalized variance
-        finalvariance = tide_math.imagevariance(filtereddata, theprefilter, 1.0 / fmritr)
-        divlocs = np.where(finalvariance > 0.0)
-        varchange = initialvariance * 0.0
-        varchange[divlocs] = 100.0 * (finalvariance[divlocs] / initialvariance[divlocs] - 1.0)
-        del fmri_data_valid
+            (
+                delayoffset,
+                regressderivratios,
+                medfiltregressderivratios,
+                filteredregressderivratios,
+                optiondict["delayoffsetMAD"],
+            ) = 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"],
+                mindelay=optiondict["mindelay"],
+                maxdelay=optiondict["maxdelay"],
+                numpoints=optiondict["numpoints"],
+                histlen=optiondict["histlen"],
+                rt_floattype=rt_floattype,
+                debug=optiondict["debug"],
+            )
+            lagtimesrefined = lagtimes + delayoffset
 
-        LGR.info("End filtering operation")
-        TimingLGR.info(
-            "GLM filtering end",
-            {
-                "message2": voxelsprocessed_glm,
-                "message3": "voxels",
-            },
-        )
-        if optiondict["memprofile"]:
-            memcheckpoint("...done")
-        else:
-            tide_util.logmem("after glm filter")
-        LGR.info("")
+            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
+            ####################################################
+
+        # now calculate the sLFO filter or CVR map
+        if optiondict["dolinfitfilt"] or optiondict["docvrmap"]:
+            if optiondict["dolinfitfilt"]:
+                TimingLGR.info("sLFO filtering start")
+                LGR.info("\n\nsLFO filtering")
+            else:
+                TimingLGR.info("CVR map generation")
+                LGR.info("\n\nCVR mapping")
+
+            # calculate the initial raw and bandlimited mean normalized variance if we're going to filter the data
+            # initialrawvariance = tide_math.imagevariance(fmri_data_valid, None, 1.0 / fmritr)
+            initialvariance = tide_math.imagevariance(fmri_data_valid, theprefilter, 1.0 / fmritr)
+
+            # now calculate the sLFO filter
+            if optiondict["refinedelay"] and optiondict["filterwithrefineddelay"]:
+                lagstouse = lagtimesrefined
+            else:
+                lagstouse = lagtimes
+            voxelsprocessed_regressionfilt, regressorset, evset = (
+                tide_regressfrommaps.regressfrommaps(
+                    fmri_data_valid,
+                    validvoxels,
+                    initial_fmri_x,
+                    lagstouse,
+                    sLFOfiltmask,
+                    genlagtc,
+                    mode,
+                    outputname,
+                    oversamptr,
+                    sLFOfitmean,
+                    rvalue,
+                    r2value,
+                    fitNorm[:, : optiondict["regressderivs"] + 1],
+                    fitcoeff[:, : optiondict["regressderivs"] + 1],
+                    movingsignal,
+                    lagtc,
+                    filtereddata,
+                    LGR,
+                    TimingLGR,
+                    optiondict["regressfiltthreshval"],
+                    optiondict["saveminimumsLFOfiltfiles"],
+                    nprocs_makelaggedtcs=optiondict["nprocs_makelaggedtcs"],
+                    nprocs_regressionfilt=optiondict["nprocs_regressionfilt"],
+                    regressderivs=optiondict["regressderivs"],
+                    chunksize=optiondict["mp_chunksize"],
+                    showprogressbar=optiondict["showprogressbar"],
+                    alwaysmultiproc=optiondict["alwaysmultiproc"],
+                    debug=optiondict["debug"],
+                )
+            )
+
+            evcolnames = ["base"]
+            if optiondict["regressderivs"] > 0:
+                for i in range(1, optiondict["regressderivs"] + 1):
+                    evcolnames.append(f"deriv_{str(i)}")
+
+            tide_io.writebidstsv(
+                f"{outputname}_desc-EV_timeseries",
+                np.transpose(evset),
+                1.0 / fmritr,
+                columns=evcolnames,
+                extraheaderinfo={"Description": "sLFO filter regressor set"},
+                append=False,
+            )
+
+            # calculate the final raw and bandlimited mean normalized variance
+            # finalrawvariance = tide_math.imagevariance(filtereddata, None, 1.0 / fmritr)
+            finalvariance = tide_math.imagevariance(filtereddata, theprefilter, 1.0 / fmritr)
+
+            divlocs = np.where(finalvariance > 0.0)
+            varchange = np.zeros_like(initialvariance)
+            varchange[divlocs] = 100.0 * (finalvariance[divlocs] / initialvariance[divlocs] - 1.0)
+
+            # calculate the voxelwise mean of the filtered data
+            lfofilteredmeanvalue = np.mean(
+                filtereddata,
+                axis=1,
+            )
+
+            LGR.info("End filtering operation")
+            TimingLGR.info(
+                "sLFO filtering end",
+                {
+                    "message2": voxelsprocessed_regressionfilt,
+                    "message3": "voxels",
+                },
+            )
+            if internalinitregressorincludemask is not None:
+                thisincludemask = internalinitregressorincludemask[validvoxels]
+            else:
+                thisincludemask = None
+            if internalinitregressorexcludemask is not None:
+                thisexcludemask = internalinitregressorexcludemask[validvoxels]
+            else:
+                thisexcludemask = None
+
+            meanvec, meanmask = tide_mask.saveregionaltimeseries(
+                "initial regressor",
+                "startregressormask",
+                filtereddata,
+                thisincludemask,
+                meanfreq,
+                outputname,
+                initfile=True,
+                excludemask=thisexcludemask,
+                filedesc="regionalpostfilter",
+                suffix="",
+                debug=optiondict["debug"],
+            )
+            if brainmask is not None:
+                brainvec, dummy = tide_mask.saveregionaltimeseries(
+                    "whole brain",
+                    "brain",
+                    filtereddata,
+                    internalbrainmask[validvoxels],
+                    meanfreq,
+                    outputname,
+                    filedesc="regionalpostfilter",
+                    suffix="",
+                    debug=optiondict["debug"],
+                )
+            if graymask is not None:
+                grayvec, dummy = tide_mask.saveregionaltimeseries(
+                    "gray matter",
+                    "GM",
+                    filtereddata,
+                    internalgraymask[validvoxels],
+                    meanfreq,
+                    outputname,
+                    excludemask=internalinvbrainmask[validvoxels],
+                    filedesc="regionalpostfilter",
+                    suffix="",
+                    debug=optiondict["debug"],
+                )
+            if whitemask is not None:
+                whitevec, dummy = tide_mask.saveregionaltimeseries(
+                    "white matter",
+                    "WM",
+                    filtereddata,
+                    internalwhitemask[validvoxels],
+                    meanfreq,
+                    outputname,
+                    excludemask=internalinvbrainmask[validvoxels],
+                    filedesc="regionalpostfilter",
+                    suffix="",
+                    debug=optiondict["debug"],
+                )
+            if csfmask is not None:
+                csfvec, dummy = tide_mask.saveregionaltimeseries(
+                    "CSF",
+                    "CSF",
+                    filtereddata,
+                    internalcsfmask[validvoxels],
+                    meanfreq,
+                    outputname,
+                    excludemask=internalinvbrainmask[validvoxels],
+                    filedesc="regionalpostfilter",
+                    suffix="",
+                    debug=optiondict["debug"],
+                )
+            tide_util.logmem("after sLFO filter")
+            LGR.info("")
     else:
-        # get the original data to calculate the mean
-        pass
-        """LGR.info(f"rereading {fmrifilename} to calculate mean value, please wait")
-        if optiondict["textio"]:
-            nim_data = tide_io.readvecs(fmrifilename)
-        else:
-            nim, nim_data, nim_hdr, thedims, thesizes = tide_io.readfromnifti(fmrifilename)"""
+        outfmriarray = None
     ####################################################
-    #  GLM filtering end
+    #  sLFO filtering end
     ####################################################
 
     # Post refinement step 2 - make and save interesting histograms
@@ -3347,24 +3032,24 @@ def rapidtide_main(argparsingfunc):
         thedict=optiondict,
     )
     namesuffix = "_desc-lfofilterR2_hist"
-    if optiondict["doglmfilt"]:
+    if optiondict["dolinfitfilt"]:
         tide_stats.makeandsavehistogram(
             r2value[np.where(fitmask > 0)],
             optiondict["histlen"],
             1,
             outputname + namesuffix,
-            displaytitle="Histogram of GLM filter R2 values",
+            displaytitle="Histogram of sLFO filter R2 values",
             dictvarname="R2hist",
             thedict=optiondict,
         )
     namesuffix = "_desc-lfofilterInbandVarianceChange_hist"
-    if optiondict["doglmfilt"]:
+    if optiondict["dolinfitfilt"]:
         tide_stats.makeandsavehistogram(
             varchange[np.where(fitmask > 0)],
             optiondict["histlen"],
             1,
             outputname + namesuffix,
-            displaytitle="Histogram of percent of inband variance removed by GLM filter",
+            displaytitle="Histogram of percent of inband variance removed by sLFO filter",
             dictvarname="varchangehist",
             thedict=optiondict,
         )
@@ -3378,6 +3063,10 @@ def rapidtide_main(argparsingfunc):
         lagstrengths[np.where(fitmask > 0)], histpcts, nozero=False
     )
     thesigmapcts = tide_stats.getfracvals(lagsigma[np.where(fitmask > 0)], histpcts, nozero=False)
+    if optiondict["refinedelay"]:
+        therefinedtimepcts = tide_stats.getfracvals(
+            lagtimesrefined[np.where(fitmask > 0)], histpcts, nozero=False
+        )
     for i in range(len(histpcts)):
         optiondict[f"lagtimes_{str(int(np.round(100 * histpcts[i], 0))).zfill(2)}pct"] = (
             thetimepcts[i]
@@ -3388,6 +3077,10 @@ def rapidtide_main(argparsingfunc):
         optiondict[f"lagsigma_{str(int(np.round(100 * histpcts[i], 0))).zfill(2)}pct"] = (
             thesigmapcts[i]
         )
+        if optiondict["refinedelay"]:
+            optiondict[
+                f"lagtimesrefined_{str(int(np.round(100 * histpcts[i], 0))).zfill(2)}pct"
+            ] = therefinedtimepcts[i]
     optiondict["fitmasksize"] = np.sum(fitmask)
     optiondict["fitmaskpct"] = 100.0 * optiondict["fitmasksize"] / optiondict["corrmasksize"]
 
@@ -3397,21 +3090,7 @@ def rapidtide_main(argparsingfunc):
 
     # write the 3D maps that need to be remapped
     TimingLGR.info("Start saving maps")
-    if not optiondict["textio"]:
-        theheader = copy.deepcopy(nim_hdr)
-        if fileiscifti:
-            timeindex = theheader["dim"][0] - 1
-            spaceindex = theheader["dim"][0]
-            theheader["dim"][timeindex] = 1
-            theheader["dim"][spaceindex] = numspatiallocs
-        else:
-            theheader["dim"][0] = 3
-            theheader["dim"][4] = 1
-            theheader["pixdim"][4] = 1.0
-    else:
-        theheader = None
-        cifti_hdr = None
-
+    theheader = theinputdata.copyheader(numtimepoints=1)
     savelist = [
         (lagtimes, "maxtime", "map", "second", "Lag time in seconds"),
         (
@@ -3433,10 +3112,51 @@ def rapidtide_main(argparsingfunc):
         (fitmask, "corrfit", "mask", None, "Voxels where correlation value was fit"),
         (failreason, "corrfitfailreason", "info", None, "Result codes for correlation fit"),
     ]
-    MTT = np.square(lagsigma) - (optiondict["acwidth"] * optiondict["acwidth"])
+    MTT = np.square(lagsigma) - 0.5 * (optiondict["acwidth"] * optiondict["acwidth"])
     MTT = np.where(MTT > 0.0, MTT, 0.0)
     MTT = np.sqrt(MTT)
     savelist += [(MTT, "MTT", "map", "second", "Mean transit time (estimated)")]
+    if optiondict["refinedelay"]:
+        savelist += [
+            (
+                delayoffset,
+                "delayoffset",
+                "map",
+                "second",
+                "Delay offset correction from delay refinement",
+            ),
+            (
+                lagtimesrefined,
+                "maxtimerefined",
+                "map",
+                "second",
+                "Lag time in seconds, refined",
+            ),
+        ]
+        if (optiondict["outputlevel"] != "min") and (optiondict["outputlevel"] != "less"):
+            savelist += [
+                (
+                    regressderivratios,
+                    "regressderivratios",
+                    "map",
+                    None,
+                    "Ratio of the first derivative of delayed sLFO to the delayed sLFO",
+                ),
+                (
+                    medfiltregressderivratios,
+                    "medfiltregressderivratios",
+                    "map",
+                    None,
+                    "Median filtered version of the regressderivratios map",
+                ),
+                (
+                    filteredregressderivratios,
+                    "filteredregressderivratios",
+                    "map",
+                    None,
+                    "regressderivratios, with outliers patched using median filtered data",
+                ),
+            ]
     if optiondict["calccoherence"]:
         savelist += [
             (coherencepeakval, "coherencepeakval", "map", None, "Coherence peak value"),
@@ -3449,10 +3169,9 @@ def rapidtide_main(argparsingfunc):
         nativespaceshape,
         theheader,
         bidsbasedict,
-        textio=optiondict["textio"],
-        fileiscifti=fileiscifti,
+        filetype=theinputdata.filetype,
         rt_floattype=rt_floattype,
-        cifti_hdr=cifti_hdr,
+        cifti_hdr=theinputdata.cifti_hdr,
     )
     namesuffix = "_desc-MTT_hist"
     tide_stats.makeandsavehistogram(
@@ -3464,10 +3183,18 @@ def rapidtide_main(argparsingfunc):
         dictvarname="MTThist",
         thedict=optiondict,
     )
+    if optiondict["calccoherence"]:
+        del coherencefunc
+        del coherencepeakval
+        del coherencepeakfreq
+        if optiondict["sharedmem"]:
+            tide_util.cleanup_shm(coherencefunc_shm)
+            tide_util.cleanup_shm(coherencepeakval_shm)
+            tide_util.cleanup_shm(coherencepeakfreq_shm)
 
     # write the optional 3D maps that need to be remapped
-    if optiondict["doglmfilt"] or optiondict["docvrmap"]:
-        if optiondict["doglmfilt"]:
+    if optiondict["dolinfitfilt"] or optiondict["docvrmap"]:
+        if optiondict["dolinfitfilt"]:
             maplist = [
                 (
                     initialvariance,
@@ -3490,34 +3217,41 @@ def rapidtide_main(argparsingfunc):
                     "percent",
                     "Change in inband variance after filtering, in percent",
                 ),
+                # (
+                #    lfofilteredmeanvalue,
+                #    "lfofilterMean",
+                #    "map",
+                #    None,
+                #    "Voxelwise mean of the sLFO filtered data",
+                # ),
             ]
-            if optiondict["saveminimumglmfiles"]:
+            if optiondict["saveminimumsLFOfiltfiles"]:
                 maplist += [
                     (
                         r2value,
                         "lfofilterR2",
                         "map",
                         None,
-                        "Squared R value of the GLM fit (proportion of variance explained)",
+                        "Squared R value of the sLFO fit (proportion of variance explained)",
                     ),
                 ]
-            if optiondict["savenormalglmfiles"]:
+            if optiondict["savenormalsLFOfiltfiles"]:
                 maplist += [
-                    (rvalue, "lfofilterR", "map", None, "R value of the GLM fit"),
-                    (glmmean, "lfofilterMean", "map", None, "Intercept from GLM fit"),
+                    (rvalue, "lfofilterR", "map", None, "R value of the sLFO fit"),
+                    (sLFOfitmean, "lfofilterMean", "map", None, "Intercept from sLFO fit"),
                 ]
-                if optiondict["glmderivs"] > 0:
+                if optiondict["regressderivs"] > 0:
                     maplist += [
-                        (fitcoeff[:, 0], f"lfofilterCoeff", "map", None, "Fit coefficient"),
+                        (fitcoeff[:, 0], "lfofilterCoeff", "map", None, "Fit coefficient"),
                         (
                             fitNorm[:, 0],
-                            f"lfofilterNorm",
+                            "lfofilterNorm",
                             "map",
                             None,
                             "Normalized fit coefficient",
                         ),
                     ]
-                    for thederiv in range(1, optiondict["glmderivs"] + 1):
+                    for thederiv in range(1, optiondict["regressderivs"] + 1):
                         maplist += [
                             (
                                 fitcoeff[:, thederiv],
@@ -3536,9 +3270,74 @@ def rapidtide_main(argparsingfunc):
                         ]
                 else:
                     maplist += [
-                        (fitcoeff, "lfofilterCoeff", "map", None, "Fit coefficient"),
-                        (fitNorm, "lfofilterNorm", "map", None, "Normalized fit coefficient"),
+                        (
+                            fitcoeff[:, : optiondict["regressderivs"] + 1],
+                            "lfofilterCoeff",
+                            "map",
+                            None,
+                            "Fit coefficient",
+                        ),
+                        (
+                            fitNorm[:, : optiondict["regressderivs"] + 1],
+                            "lfofilterNorm",
+                            "map",
+                            None,
+                            "Normalized fit coefficient",
+                        ),
                     ]
+                init_std_valid = init_std[validvoxels] + 0.0
+                init_skew_valid = init_skew[validvoxels] + 0.0
+                init_kurtosis_valid = init_kurtosis[validvoxels] + 0.0
+                maplist += [
+                    (init_std_valid, "initialStd", "map", None, "Std of the raw input data"),
+                    (
+                        init_skew_valid,
+                        "initialSkewness",
+                        "map",
+                        None,
+                        "Skewness of the raw input data",
+                    ),
+                    (
+                        init_kurtosis_valid,
+                        "initialKurtosis",
+                        "map",
+                        None,
+                        "Kurtosis of the raw input data",
+                    ),
+                ]
+                (
+                    final_min_valid,
+                    final_max_valid,
+                    final_mean_valid,
+                    final_std_valid,
+                    final_median_valid,
+                    final_MAD_valid,
+                    final_skew_valid,
+                    final_kurtosis_valid,
+                ) = tide_stats.fmristats(filtereddata)
+                maplist += [
+                    (
+                        final_std_valid,
+                        "lfofilterCleanedStd",
+                        "map",
+                        None,
+                        "Std of the sLFO cleaned data",
+                    ),
+                    (
+                        final_skew_valid,
+                        "lfofilterCleanedSkewness",
+                        "map",
+                        None,
+                        "Skewness of the sLFO cleaned data",
+                    ),
+                    (
+                        final_kurtosis_valid,
+                        "lfofilterCleanedKurtosis",
+                        "map",
+                        None,
+                        "Kurtosis of the sLFO cleaned data",
+                    ),
+                ]
         else:
             maplist = [
                 (
@@ -3562,25 +3361,22 @@ def rapidtide_main(argparsingfunc):
                     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["savenormalglmfiles"]:
-                maplist = [
-                    (rvalue, "CVRR", "map", None, "R value of the GLM fit"),
-                    (
-                        r2value,
-                        "CVRR2",
-                        "map",
-                        None,
-                        "Squared R value of the GLM fit (proportion of variance explained)",
-                    ),
-                    (
-                        fitcoeff,
-                        "CVR",
-                        "map",
-                        "percent",
-                        "Percent signal change due to the CVR regressor",
-                    ),
-                ]
 
         tide_io.savemaplist(
             outputname,
@@ -3589,11 +3385,78 @@ def rapidtide_main(argparsingfunc):
             nativespaceshape,
             theheader,
             bidsbasedict,
-            textio=optiondict["textio"],
-            fileiscifti=fileiscifti,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
-            cifti_hdr=cifti_hdr,
+            cifti_hdr=theinputdata.cifti_hdr,
         )
+
+        if optiondict["refinedelay"]:
+            # filter the fmri data to the lfo band
+            print("filtering fmri_data to sLFO band")
+            for i in range(fmri_data_valid.shape[0]):
+                fmri_data_valid[i, :] = theprefilter.apply(
+                    optiondict["fmrifreq"], fmri_data_valid[i, :]
+                )
+
+            print("rerunning sLFO fit to get filtered R value")
+            dummy, dummy, dummy = tide_regressfrommaps.regressfrommaps(
+                fmri_data_valid,
+                validvoxels,
+                initial_fmri_x,
+                lagstouse,
+                sLFOfiltmask,
+                genlagtc,
+                mode,
+                outputname,
+                oversamptr,
+                sLFOfitmean,
+                rvalue,
+                r2value,
+                fitNorm[:, : optiondict["regressderivs"] + 1],
+                fitcoeff[:, : optiondict["regressderivs"] + 1],
+                movingsignal,
+                lagtc,
+                filtereddata,
+                LGR,
+                TimingLGR,
+                optiondict["regressfiltthreshval"],
+                optiondict["saveminimumsLFOfiltfiles"],
+                nprocs_makelaggedtcs=optiondict["nprocs_makelaggedtcs"],
+                nprocs_regressionfilt=optiondict["nprocs_regressionfilt"],
+                regressderivs=optiondict["regressderivs"],
+                chunksize=optiondict["mp_chunksize"],
+                showprogressbar=optiondict["showprogressbar"],
+                alwaysmultiproc=optiondict["alwaysmultiproc"],
+                debug=optiondict["debug"],
+            )
+
+            maplist = [
+                (
+                    rvalue,
+                    "maxcorrrefined",
+                    "map",
+                    None,
+                    "R value of the inband sLFO fit, with sign",
+                ),
+            ]
+
+            tide_io.savemaplist(
+                outputname,
+                maplist,
+                validvoxels,
+                nativespaceshape,
+                theheader,
+                bidsbasedict,
+                filetype=theinputdata.filetype,
+                rt_floattype=rt_floattype,
+                cifti_hdr=theinputdata.cifti_hdr,
+            )
+
+        del fmri_data_valid
+        if optiondict["sharedmem"]:
+            tide_util.cleanup_shm(fmri_data_valid_shm)
+
+        del sLFOfitmean
         del rvalue
         del r2value
         del fitcoeff
@@ -3601,10 +3464,27 @@ def rapidtide_main(argparsingfunc):
         del initialvariance
         del finalvariance
         del varchange
+        if optiondict["sharedmem"]:
+            tide_util.cleanup_shm(sLFOfitmean_shm)
+            tide_util.cleanup_shm(rvalue_shm)
+            tide_util.cleanup_shm(r2value_shm)
+            tide_util.cleanup_shm(fitcoeff_shm)
+            tide_util.cleanup_shm(fitNorm_shm)
 
     # write the 3D maps that don't need to be remapped
+    if theinputdata.filetype != "nifti":
+        unfiltmeanvalue = meanvalue
     maplist = [
+        (
+            unfiltmeanvalue,
+            "unfiltmean",
+            "map",
+            None,
+            "Voxelwise mean of fmri data before smoothing",
+        ),
         (meanvalue, "mean", "map", None, "Voxelwise mean of fmri data"),
+        (stddevvalue, "std", "map", None, "Voxelwise standard deviation of fmri data"),
+        (covvalue, "CoV", "map", None, "Voxelwise coefficient of variation of fmri data"),
     ]
     if brainmask is not None:
         maplist.append((brainmask, "brainmask", "mask", None, "Brain mask"))
@@ -3612,6 +3492,8 @@ def rapidtide_main(argparsingfunc):
         maplist.append((graymask, "GM", "mask", None, "Gray matter mask"))
     if whitemask is not None:
         maplist.append((whitemask, "WM", "mask", None, "White matter mask"))
+    if csfmask is not None:
+        maplist.append((csfmask, "CSF", "mask", None, "CSF mask"))
     tide_io.savemaplist(
         outputname,
         maplist,
@@ -3619,29 +3501,38 @@ def rapidtide_main(argparsingfunc):
         nativespaceshape,
         theheader,
         bidsbasedict,
-        textio=optiondict["textio"],
-        fileiscifti=fileiscifti,
+        filetype=theinputdata.filetype,
         rt_floattype=rt_floattype,
-        cifti_hdr=cifti_hdr,
+        cifti_hdr=theinputdata.cifti_hdr,
     )
     del meanvalue
+    del unfiltmeanvalue
 
     if optiondict["numestreps"] > 0:
         masklist = []
-        for i in range(0, len(thepercentiles)):
-            if optiondict["dosighistfit"]:
-                pmask = np.where(np.abs(lagstrengths) > pcts_fit[i], fitmask, 0 * fitmask)
-            else:
-                pmask = np.where(np.abs(lagstrengths) > pcts[i], fitmask, 0 * fitmask)
-            masklist += [
-                (
-                    pmask.copy(),
-                    f"plt{thepvalnames[i]}",
-                    "mask",
-                    None,
-                    f"Voxels where the maxcorr value exceeds the p < {1.0 - thepercentiles[i]:.3f} significance level",
-                )
-            ]
+
+        # we can only calculate this map if we have enough data for a good fit, and the fit succeeded
+        if optiondict["numestreps"] >= 1000:
+            if sigfit is not None:
+                neglogpmax = np.log10(optiondict["numestreps"])
+                # generate a neglogp map
+                neglog10pmap = np.zeros_like(lagstrengths)
+                for voxel in range(neglog10pmap.shape[0]):
+                    neglog10pmap[voxel] = tide_stats.neglog10pfromr(
+                        lagstrengths[voxel],
+                        sigfit,
+                        neglogpmax=neglogpmax,
+                        debug=optiondict["debug"],
+                    )
+                masklist += [
+                    (
+                        neglog10pmap.copy(),
+                        "neglog10p",
+                        "map",
+                        None,
+                        f"Negative log(10) of the p value of the r at each voxel",
+                    )
+                ]
 
         tide_io.savemaplist(
             outputname,
@@ -3650,21 +3541,21 @@ def rapidtide_main(argparsingfunc):
             nativespaceshape,
             theheader,
             bidsbasedict,
-            textio=optiondict["textio"],
-            fileiscifti=fileiscifti,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
-            cifti_hdr=cifti_hdr,
+            cifti_hdr=theinputdata.cifti_hdr,
         )
         del masklist
 
-    if (optiondict["passes"] > 1 or optiondict["globalpreselect"]) and optiondict[
+    if (optiondict["passes"] > 1 or optiondict["initregressorpreselect"]) and optiondict[
         "refinestopreason"
     ] != "emptymask":
-        if optiondict["globalpreselect"]:
+        refinemask = theRegressorRefiner.getrefinemask()
+        if optiondict["initregressorpreselect"]:
             masklist = [
                 (
                     refinemask,
-                    "globalmeanpreselect",
+                    "initregressorpreselect",
                     "mask",
                     None,
                     "I really don't know what this file is for",
@@ -3679,10 +3570,9 @@ def rapidtide_main(argparsingfunc):
             nativespaceshape,
             theheader,
             bidsbasedict,
-            textio=optiondict["textio"],
-            fileiscifti=fileiscifti,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
-            cifti_hdr=cifti_hdr,
+            cifti_hdr=theinputdata.cifti_hdr,
         )
         del refinemask
 
@@ -3694,20 +3584,18 @@ def rapidtide_main(argparsingfunc):
     del fitmask
 
     # now do the 4D maps of the similarity function and friends
-    if not optiondict["textio"]:
-        theheader = copy.deepcopy(nim_hdr)
-        theheader["toffset"] = corrscale[corrorigin - lagmininpts]
-        if fileiscifti:
-            timeindex = theheader["dim"][0] - 1
-            spaceindex = theheader["dim"][0]
-            theheader["dim"][timeindex] = np.shape(outcorrarray)[1]
-            theheader["dim"][spaceindex] = numspatiallocs
-        else:
-            theheader["dim"][4] = np.shape(outcorrarray)[1]
-            theheader["pixdim"][4] = corrtr
+    if optiondict["similaritymetric"] == "riptide":
+        theheader = theinputdata.copyheader(
+            numtimepoints=np.shape(outcorrarray)[1],
+            tr=riptidedelays[1] - riptidedelays[0],
+            toffset=(riptidedelays[0]),
+        )
     else:
-        theheader = None
-        cifti_hdr = None
+        theheader = theinputdata.copyheader(
+            numtimepoints=np.shape(outcorrarray)[1],
+            tr=corrtr,
+            toffset=(corrscale[corrorigin - lagmininpts]),
+        )
 
     if (
         optiondict["savecorrout"]
@@ -3735,33 +3623,29 @@ def rapidtide_main(argparsingfunc):
             nativecorrshape,
             theheader,
             bidsbasedict,
-            textio=optiondict["textio"],
-            fileiscifti=fileiscifti,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
-            cifti_hdr=cifti_hdr,
+            cifti_hdr=theinputdata.cifti_hdr,
         )
     del windowout
     del gaussout
     del corrout
+    del outcorrarray
+    if optiondict["sharedmem"]:
+        tide_util.cleanup_shm(windowout_shm)
+        tide_util.cleanup_shm(gaussout_shm)
+        tide_util.cleanup_shm(corrout_shm)
+        tide_util.cleanup_shm(outcorrarray_shm)
 
     # now save all the files that are of the same length as the input data file and masked
-    if not optiondict["textio"]:
-        theheader = copy.deepcopy(nim_hdr)
-        if fileiscifti:
-            timeindex = theheader["dim"][0] - 1
-            spaceindex = theheader["dim"][0]
-            theheader["dim"][timeindex] = np.shape(outfmriarray)[1]
-            theheader["dim"][spaceindex] = numspatiallocs
-        else:
-            theheader["dim"][4] = np.shape(outfmriarray)[1]
-            theheader["pixdim"][4] = fmritr
-    else:
-        theheader = None
-        cifti_hdr = None
-
+    if outfmriarray is None:
+        outfmriarray = np.zeros(internalfmrishape, dtype=rt_floattype)
+    theheader = theinputdata.copyheader(numtimepoints=np.shape(outfmriarray)[1], tr=fmritr)
     maplist = []
-    if optiondict["saveallglmfiles"] and (optiondict["doglmfilt"] or optiondict["docvrmap"]):
-        if optiondict["glmderivs"] > 0:
+    if optiondict["saveallsLFOfiltfiles"] and (
+        optiondict["dolinfitfilt"] or optiondict["docvrmap"]
+    ):
+        if optiondict["regressderivs"] > 0:
             maplist += [
                 (
                     regressorset[:, :, 0],
@@ -3771,7 +3655,7 @@ def rapidtide_main(argparsingfunc):
                     "Shifted sLFO regressor to filter",
                 ),
             ]
-            for thederiv in range(1, optiondict["glmderivs"] + 1):
+            for thederiv in range(1, optiondict["regressderivs"] + 1):
                 maplist += [
                     (
                         regressorset[:, :, thederiv],
@@ -3786,11 +3670,11 @@ def rapidtide_main(argparsingfunc):
                 (regressorset, "lfofilterEV", "bold", None, "Shifted sLFO regressor to filter"),
             ]
 
-    if optiondict["passes"] > 1:
+    if (optiondict["passes"] > 1) or optiondict["dofinalrefine"]:
         if optiondict["savelagregressors"]:
             maplist += [
                 (
-                    paddedshiftedtcs[:, numpadtrs:-numpadtrs],
+                    (theRegressorRefiner.getpaddedshiftedtcs())[:, numpadtrs:-numpadtrs],
                     "shiftedtcs",
                     "bold",
                     None,
@@ -3798,8 +3682,8 @@ def rapidtide_main(argparsingfunc):
                 ),
             ]
 
-    if optiondict["doglmfilt"]:
-        if optiondict["saveminimumglmfiles"]:
+    if optiondict["dolinfitfilt"]:
+        if optiondict["saveminimumsLFOfiltfiles"]:
             maplist += [
                 (
                     filtereddata,
@@ -3820,6 +3704,27 @@ def rapidtide_main(argparsingfunc):
                 ),
             ]
 
+            # save a pseudofile if we're going to
+            if optiondict["makepseudofile"]:
+                print("reading mean image")
+                meanfile = f"{outputname}_desc-mean_map.nii.gz"
+                (
+                    mean_input,
+                    mean,
+                    mean_header,
+                    mean_dims,
+                    mean_sizes,
+                ) = tide_io.readfromnifti(meanfile)
+                if not tide_io.checkspacematch(theheader, mean_header):
+                    raise ValueError("mean dimensions do not match fmri dimensions")
+                if optiondict["debug"]:
+                    print(f"{mean.shape=}")
+                mean_spacebytime = mean.reshape((numspatiallocs))
+                if optiondict["debug"]:
+                    print(f"{mean_spacebytime.shape=}")
+                pseudofile = mean_spacebytime[validvoxels, None] + movingsignal[:, :]
+                maplist.append((pseudofile, "pseudofile", "bold", None, None))
+
     # save maps in the current output list
     if len(maplist) > 0:
         tide_io.savemaplist(
@@ -3829,20 +3734,22 @@ def rapidtide_main(argparsingfunc):
             nativefmrishape,
             theheader,
             bidsbasedict,
-            textio=optiondict["textio"],
-            fileiscifti=fileiscifti,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
-            cifti_hdr=cifti_hdr,
+            cifti_hdr=theinputdata.cifti_hdr,
         )
 
     # clean up
     if optiondict["passes"] > 1:
-        del paddedshiftedtcs
-        del shiftedtcs
-    if optiondict["doglmfilt"]:
+        theRegressorRefiner.cleanup()
+    if optiondict["dolinfitfilt"]:
         del lagtc
         del filtereddata
         del movingsignal
+        if optiondict["sharedmem"]:
+            tide_util.cleanup_shm(lagtc_shm)
+            tide_util.cleanup_shm(filtereddata_shm)
+            tide_util.cleanup_shm(movingsignal_shm)
 
     TimingLGR.info("Finished saving maps")
     LGR.info("done")
@@ -3877,6 +3784,13 @@ def rapidtide_main(argparsingfunc):
     )
     Path(f"{outputname}_runtimings.tsv").unlink(missing_ok=True)
 
+    # save pyfftw wisdom
+    tide_util.savewisdom(optiondict["pyfftw_wisdom"])
+
+    # show fft cache information
+    if optiondict["focaldebug"]:
+        showfftcache()
+
     # do a final save of the options file
     optiondict["currentstage"] = "done"
     tide_io.writedicttojson(optiondict, f"{outputname}_desc-runoptions_info.json")
@@ -3891,5 +3805,5 @@ def rapidtide_main(argparsingfunc):
     # delete the canary file
     Path(f"{outputname}_ISRUNNING.txt").unlink()
 
-    # created the finished file
+    # create the finished file
     Path(f"{outputname}_DONE.txt").touch()