rapidtide 3.0.7__py3-none-any.whl → 3.0.8__py3-none-any.whl

rapidtide/workflows/rapidtide.py

@@ -25,7 +25,6 @@ import warnings
 from pathlib import Path
 
 import numpy as np
-from scipy import ndimage
 from scipy.stats import rankdata
 
 import rapidtide.calccoherence as tide_calccoherence
@@ -40,17 +39,16 @@ 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.patchmatch as tide_patch
-import rapidtide.peakeval as tide_peakeval
-import rapidtide.refinedelay as tide_refinedelay
-import rapidtide.RegressorRefiner as tide_regrefiner
 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.cleanregressor as tide_cleanregressor
+import rapidtide.workflows.estimateDelayMap as tide_estimateDelayMap
+import rapidtide.workflows.refineDelayMap as tide_refineDelayMap
+import rapidtide.workflows.refineRegressor as tide_refineRegressor
 import rapidtide.workflows.regressfrommaps as tide_regressfrommaps
 
 from .utils import setup_logger
@@ -117,8 +115,8 @@ def echocancel(thetimecourse, echooffset, thetimestep, outputname, padtimepoints
 
 
 def rapidtide_main(argparsingfunc):
-    threaddebug = False
     optiondict, theprefilter = argparsingfunc
+    optiondict["threaddebug"] = False
 
     optiondict["nodename"] = platform.node()
 
@@ -277,7 +275,7 @@ def rapidtide_main(argparsingfunc):
         mklmaxthreads = mkl.get_max_threads()
         if not (1 <= optiondict["mklthreads"] <= mklmaxthreads):
             optiondict["mklthreads"] = mklmaxthreads
-        tide_util.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
@@ -298,15 +296,6 @@ def rapidtide_main(argparsingfunc):
     nativespaceshape = theinputdata.nativespaceshape
     fmritr = theinputdata.timestep
     optiondict["filetype"] = theinputdata.filetype
-    if theinputdata.filetype == "cifti":
-        fileiscifti = True
-        optiondict["textio"] = False
-    elif theinputdata.filetype == "text":
-        fileiscifti = False
-        optiondict["textio"] = True
-    else:
-        fileiscifti = False
-        optiondict["textio"] = False
 
     # check to see if we need to adjust the oversample factor
     if optiondict["oversampfactor"] < 0:
@@ -629,7 +618,6 @@ def rapidtide_main(argparsingfunc):
         )
     else:
         internaloffsetexcludemask_valid = None
-
     tide_util.logmem("after selecting valid voxels")
 
     # move fmri_data_valid into shared memory
@@ -701,7 +689,7 @@ def rapidtide_main(argparsingfunc):
             print(f"{fmritr=}")
             print(f"{validstart=}")
             print(f"{validend=}")
-        tide_util.disablemkl(optiondict["nprocs_confoundregress"], debug=threaddebug)
+        tide_util.disablemkl(optiondict["nprocs_confoundregress"], debug=optiondict["threaddebug"])
         (
             mergedregressors,
             mergedregressorlabels,
@@ -718,7 +706,7 @@ def rapidtide_main(argparsingfunc):
             orthogonalize=optiondict["orthogonalize"],
             showprogressbar=optiondict["showprogressbar"],
         )
-        tide_util.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()
@@ -742,7 +730,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,
@@ -1256,7 +1244,7 @@ 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"],
@@ -1289,7 +1277,7 @@ 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,
@@ -1384,26 +1372,35 @@ def rapidtide_main(argparsingfunc):
     LGR.debug(
         f"allocating memory for correlation arrays {internalcorrshape} {internalvalidcorrshape}"
     )
+    corrout, corrout_shm = tide_util.allocarray(
+        internalvalidcorrshape,
+        rt_floatset,
+        shared=optiondict["sharedmem"],
+        name=f"corrout_{optiondict['pid']}",
+    )
+    gaussout, gaussout_shm = tide_util.allocarray(
+        internalvalidcorrshape,
+        rt_floatset,
+        shared=optiondict["sharedmem"],
+        name=f"gaussout_{optiondict['pid']}",
+    )
+    windowout, windowout_shm = tide_util.allocarray(
+        internalvalidcorrshape,
+        rt_floatset,
+        shared=optiondict["sharedmem"],
+        name=f"windowout_{optiondict['pid']}",
+    )
+    outcorrarray, outcorrarray_shm = tide_util.allocarray(
+        internalcorrshape,
+        rt_floatset,
+        shared=optiondict["sharedmem"],
+        name=f"outcorrarray_{optiondict['pid']}",
+    )
     if optiondict["sharedmem"]:
-        corrout, corrout_shm = tide_util.allocshared(
-            internalvalidcorrshape, rt_floatset, name=f"corrout_{optiondict['pid']}"
-        )
-        gaussout, gaussout_shm = tide_util.allocshared(
-            internalvalidcorrshape, rt_floatset, name=f"gaussout_{optiondict['pid']}"
-        )
-        windowout, windowout_shm = tide_util.allocshared(
-            internalvalidcorrshape, rt_floatset, name=f"windowout_{optiondict['pid']}"
-        )
-        outcorrarray, outcorrarray_shm = tide_util.allocshared(
-            internalcorrshape, rt_floatset, name=f"outcorrarray_{optiondict['pid']}"
-        )
         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)
         ramlocation = "locally"
+
     optiondict["totalcorrelationbytes"] = (
         corrout.nbytes + gaussout.nbytes + windowout.nbytes + outcorrarray.nbytes
     )
@@ -1467,6 +1464,69 @@ def rapidtide_main(argparsingfunc):
         2 * numpadtrs + np.shape(initial_fmri_x)[0],
     )
 
+    # now do the arrays for delay refinement
+    if optiondict["dolinfitfilt"] or optiondict["docvrmap"] or optiondict["refinedelay"]:
+        if optiondict["refinedelay"]:
+            derivaxissize = np.max([2, optiondict["regressderivs"] + 1])
+        else:
+            derivaxissize = optiondict["regressderivs"] + 1
+        internalvalidspaceshapederivs = (
+            internalvalidspaceshape,
+            derivaxissize,
+        )
+        sLFOfitmean, sLFOfitmean_shm = tide_util.allocarray(
+            internalvalidspaceshape,
+            rt_outfloattype,
+            shared=optiondict["sharedmem"],
+            name=f"sLFOfitmean_{optiondict['pid']}",
+        )
+        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")
+
     # prepare for regressor refinement, if we're doing it
     if (
         optiondict["passes"] > 1
@@ -1475,7 +1535,7 @@ def rapidtide_main(argparsingfunc):
         or optiondict["convergencethresh"] is not None
     ):
         # we will be doing regressor refinement, so configure the refiner
-        theRegressorRefiner = tide_regrefiner.RegressorRefiner(
+        theRegressorRefiner = tide_refineRegressor.RegressorRefiner(
             internalvalidfmrishape,
             internalvalidpaddedfmrishape,
             optiondict["pid"],
@@ -1524,7 +1584,7 @@ def rapidtide_main(argparsingfunc):
     LGR.verbose(f"edgebufferfrac set to {optiondict['edgebufferfrac']}")
 
     # initialize the correlation fitter
-    theFitter = tide_classes.SimilarityFunctionFitter(
+    theFitter = tide_simFuncClasses.SimilarityFunctionFitter(
         lagmod=optiondict["lagmod"],
         lthreshval=optiondict["lthreshval"],
         uthreshval=optiondict["uthreshval"],
@@ -1552,7 +1612,7 @@ def rapidtide_main(argparsingfunc):
             windowfunc=optiondict["windowfunc"],
         )
 
-        tide_util.disablemkl(optiondict["nprocs_calcsimilarity"], debug=threaddebug)
+        tide_util.disablemkl(optiondict["nprocs_calcsimilarity"], debug=optiondict["threaddebug"])
         (
             voxelsprocessed_echo,
             theglobalmaxlist,
@@ -1576,7 +1636,7 @@ def rapidtide_main(argparsingfunc):
             rt_floatset=rt_floatset,
             rt_floattype=rt_floattype,
         )
-        tide_util.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"]
@@ -1731,7 +1791,7 @@ def rapidtide_main(argparsingfunc):
                 theSimFunc = theMutualInformationator
             else:
                 theSimFunc = theCorrelator
-            tide_util.disablemkl(optiondict["nprocs_getNullDist"], debug=threaddebug)
+            tide_util.disablemkl(optiondict["nprocs_getNullDist"], debug=optiondict["threaddebug"])
             simdistdata = tide_nullsimfunc.getNullDistributionData(
                 oversampfreq,
                 theSimFunc,
@@ -1746,7 +1806,7 @@ def rapidtide_main(argparsingfunc):
                 rt_floatset=np.float64,
                 rt_floattype="float64",
             )
-            tide_util.enablemkl(optiondict["mklthreads"], debug=threaddebug)
+            tide_util.enablemkl(optiondict["mklthreads"], debug=optiondict["threaddebug"])
 
             tide_io.writebidstsv(
                 f"{outputname}_desc-simdistdata_info",
@@ -1786,6 +1846,8 @@ def rapidtide_main(argparsingfunc):
                 twotail=optiondict["bipolar"],
                 nozero=optiondict["nohistzero"],
             )
+            if sigfit is None:
+                optiondict["ampthreshfromsig"] = False
             if pcts is not None:
                 for i in range(len(thepvalnames)):
                     optiondict[
@@ -1841,455 +1903,108 @@ def rapidtide_main(argparsingfunc):
         optiondict["currentstage"] = f"precorrelation_pass{thepass}"
         tide_io.writedicttojson(optiondict, f"{outputname}_desc-runoptions_info.json")
 
-        # tide_delayestimate.estimateDelay(
-        #    fmri_data_valid[:, validsimcalcstart : validsimcalcend + 1],
-        #    initial_fmri_x[validsimcalcstart : validsimcalcend + 1],
-        #    os_fmri_x[osvalidsimcalcstart : osvalidsimcalcend + 1],
-        #    theMutualInformationator,
-        #    thepass,
-        # )
-        ########################
-        # Delay estimation start
-        ########################
-        # 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}")
-
-        tide_util.disablemkl(optiondict["nprocs_calcsimilarity"], debug=threaddebug)
-        if optiondict["similaritymetric"] == "mutualinfo":
-            theMutualInformationator.setlimits(lagmininpts, lagmaxinpts)
-            (
-                voxelsprocessed_cp,
-                theglobalmaxlist,
-                trimmedcorrscale,
-            ) = tide_calcsimfunc.correlationpass(
-                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,
-                debug=optiondict["focaldebug"],
-            )
-        else:
-            (
-                voxelsprocessed_cp,
-                theglobalmaxlist,
-                trimmedcorrscale,
-            ) = tide_calcsimfunc.correlationpass(
-                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,
-                debug=optiondict["focaldebug"],
-            )
-        tide_util.enablemkl(optiondict["mklthreads"], debug=threaddebug)
-
-        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 theinputdata.filetype == "text":
-                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}")
-
-            tide_util.disablemkl(optiondict["nprocs_peakeval"], debug=threaddebug)
-            voxelsprocessed_pe, thepeakdict = tide_peakeval.peakevalpass(
-                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,
-                rt_floattype=rt_floattype,
-            )
-            tide_util.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}")
-
-        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
-
-        tide_util.disablemkl(optiondict["nprocs_fitcorr"], debug=threaddebug)
-        voxelsprocessed_fc = tide_simfuncfit.fitcorr(
-            trimmedcorrscale,
-            theFitter,
+        # step 1 - do the initial delay estimation
+        internaldespeckleincludemask = tide_estimateDelayMap.estimateDelay(
+            fmri_data_valid,
+            validsimcalcstart,
+            validsimcalcend,
+            osvalidsimcalcstart,
+            osvalidsimcalcend,
+            initial_fmri_x,
+            os_fmri_x,
+            theCorrelator,
+            theMutualInformationator,
+            cleaned_referencetc,
             corrout,
+            meanval,
+            corrscale,
+            outputname,
+            outcorrarray,
+            validvoxels,
+            nativecorrshape,
+            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"],
-            initialdelayvalue=theinitialdelay,
-            showprogressbar=optiondict["showprogressbar"],
-            chunksize=optiondict["mp_chunksize"],
-            despeckle_thresh=optiondict["despeckle_thresh"],
-            initiallags=initlags,
-            rt_floatset=rt_floatset,
-            rt_floattype=rt_floattype,
+            failreason,
+            outmaparray,
+            lagmininpts,
+            lagmaxinpts,
+            thepass,
+            optiondict,
+            LGR,
+            TimingLGR,
+            rt_floatset=np.float64,
+            rt_floattype="float64",
         )
-        tide_util.enablemkl(optiondict["mklthreads"], debug=threaddebug)
 
-        TimingLGR.info(
-            f"Time lag estimation end, pass {thepass}",
-            {
-                "message2": voxelsprocessed_fc,
-                "message3": "voxels",
-            },
-        )
+        # refine delay
+        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
-            lastnumdespeckled = 1000000
-            for despecklepass in range(optiondict["despeckle_passes"]):
-                LGR.info(f"\n\n{similaritytype} despeckling subpass {despecklepass + 1}")
-                outmaparray *= 0.0
-                outmaparray[validvoxels] = eval("lagtimes")[:]
-
-                # find voxels to despeckle
-                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:
-                    numdespeckled = len(np.where(initlags != -1000000.0)[0])
-                    if lastnumdespeckled > numdespeckled > 0:
-                        lastnumdespeckled = numdespeckled
-                        tide_util.disablemkl(optiondict["nprocs_fitcorr"], debug=threaddebug)
-                        voxelsprocessed_thispass = tide_simfuncfit.fitcorr(
-                            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"],
-                            initialdelayvalue=theinitialdelay,
-                            showprogressbar=optiondict["showprogressbar"],
-                            chunksize=optiondict["mp_chunksize"],
-                            despeckle_thresh=optiondict["despeckle_thresh"],
-                            initiallags=initlags,
-                            rt_floatset=rt_floatset,
-                            rt_floattype=rt_floattype,
-                        )
-                        tide_util.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["savedespecklemasks"] and (optiondict["despeckle_passes"] > 0):
-                despecklesavemask = np.where(
-                    internaldespeckleincludemask[validvoxels] == 0.0, 0, 1
-                )
-                if thepass == optiondict["passes"]:
-                    if theinputdata.filetype != "text":
-                        if theinputdata.filetype == "cifti":
-                            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,
-                        filetype=theinputdata.filetype,
-                        rt_floattype=rt_floattype,
-                        cifti_hdr=theinputdata.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",
-                },
-            )
+            if optiondict["sLFOfiltmask"]:
+                sLFOfiltmask = fitmask + 0.0
+            else:
+                sLFOfiltmask = fitmask * 0.0 + 1.0
 
-        # Step 2c - patch shifting
-        if optiondict["patchshift"]:
-            outmaparray *= 0.0
-            outmaparray[validvoxels] = eval("lagtimes")[:]
-            # new method
-            masklist = [
-                (
-                    outmaparray[validvoxels],
-                    f"lagtimes_prepatch_pass{thepass}",
-                    "map",
-                    None,
-                    f"Input lagtimes map prior to patch map generation pass {thepass}",
-                ),
-            ]
-            tide_io.savemaplist(
+            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,
-                masklist,
                 validvoxels,
                 nativespaceshape,
-                theheader,
-                bidsbasedict,
-                filetype=theinputdata.filetype,
+                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_floatset=rt_floatset,
                 rt_floattype=rt_floattype,
-                cifti_hdr=theinputdata.cifti_hdr,
+                debug=optiondict["debug"],
             )
-
-            # create list of anomalous 3D regions that don't match surroundings
-            if theinputdata.nim_affine is not None:
-                # make an atlas of anomalous patches - each patch shares the same integer value
-                step1 = tide_patch.calc_DoG(
-                    outmaparray.reshape(nativespaceshape).copy(),
-                    theinputdata.nim_affine,
-                    thesizes,
-                    fwhm=optiondict["patchfwhm"],
-                    ratioopt=False,
-                    debug=True,
-                )
-                masklist = [
-                    (
-                        step1.reshape(internalspaceshape)[validvoxels],
-                        f"DoG_pass{thepass}",
-                        "map",
-                        None,
-                        f"DoG map for pass {thepass}",
-                    ),
-                ]
-                tide_io.savemaplist(
-                    outputname,
-                    masklist,
-                    validvoxels,
-                    nativespaceshape,
-                    theheader,
-                    bidsbasedict,
-                    filetype=theinputdata.filetype,
-                    rt_floattype=rt_floattype,
-                    cifti_hdr=theinputdata.cifti_hdr,
-                )
-                step2 = tide_patch.invertedflood3D(
-                    step1,
-                    1,
-                )
-                masklist = [
-                    (
-                        step2.reshape(internalspaceshape)[validvoxels],
-                        f"invertflood_pass{thepass}",
-                        "map",
-                        None,
-                        f"Inverted flood map for pass {thepass}",
-                    ),
-                ]
-                tide_io.savemaplist(
-                    outputname,
-                    masklist,
-                    validvoxels,
-                    nativespaceshape,
-                    theheader,
-                    bidsbasedict,
-                    filetype=theinputdata.filetype,
-                    rt_floattype=rt_floattype,
-                    cifti_hdr=theinputdata.cifti_hdr,
-                )
-
-                patchmap = tide_patch.separateclusters(
-                    step2,
-                    sizethresh=optiondict["patchminsize"],
-                    debug=True,
-                )
-                # patchmap = tide_patch.getclusters(
-                #   outmaparray.reshape(nativespaceshape),
-                #    theinputdata.nim_affine,
-                #    thesizes,
-                #    fwhm=optiondict["patchfwhm"],
-                #    ratioopt=True,
-                #    sizethresh=optiondict["patchminsize"],
-                #    debug=True,
-                # )
-                masklist = [
-                    (
-                        patchmap[validvoxels],
-                        f"patch_pass{thepass}",
-                        "map",
-                        None,
-                        f"Patch map for despeckling pass {thepass}",
-                    ),
-                ]
-                tide_io.savemaplist(
-                    outputname,
-                    masklist,
-                    validvoxels,
-                    nativespaceshape,
-                    theheader,
-                    bidsbasedict,
-                    filetype=theinputdata.filetype,
-                    rt_floattype=rt_floattype,
-                    cifti_hdr=theinputdata.cifti_hdr,
-                )
-
-            # now shift the patches to align with the majority of the image
-            tide_patch.interppatch(lagtimes, patchmap[validvoxels])
-        ########################
-        # Delay estimation end
-        ########################
+            lagtimes[:] = lagtimes + delayoffset
 
         # Step 2d - make a rank order map
         timepercentile = (
@@ -2333,147 +2048,37 @@ def rapidtide_main(argparsingfunc):
             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 + 0
-
-                peaklag, dummy, dummy = 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
-            theRegressorRefiner.setmasks(
-                internalrefineincludemask_valid, thisinternalrefineexcludemask_valid
-            )
-
-            # regenerate regressor for next pass
-            # create the refinement mask
-            LGR.info("making refine mask")
-            createdmask = theRegressorRefiner.makemask(lagstrengths, lagtimes, lagsigma, fitmask)
-            print(f"Refine mask has {theRegressorRefiner.refinemaskvoxels} voxels")
-            if not createdmask:
-                print("no voxels qualify for refinement - exiting")
-                sys.exit()
-
-            # align timecourses to prepare for refinement
-            LGR.info("aligning timecourses")
-            tide_util.disablemkl(optiondict["nprocs_refine"], debug=threaddebug)
-            voxelsprocessed_rra = theRegressorRefiner.alignvoxels(
-                fmri_data_valid, fmritr, lagtimes
-            )
-            tide_util.enablemkl(optiondict["mklthreads"], debug=threaddebug)
-            LGR.info(f"align complete: {voxelsprocessed_rra=}")
-
-            # prenormalize
-            LGR.info("prenormalizing timecourses")
-            theRegressorRefiner.prenormalize(lagtimes, lagstrengths, R2)
-
-            # now doing the refinement
-            (
-                voxelsprocessed_rr,
-                outputdict,
-                previousnormoutputdata,
-                resampref_y,
-                resampnonosref_y,
-                stoprefining,
-                refinestopreason,
-                genlagtc,
-            ) = theRegressorRefiner.refine(
-                theprefilter,
-                fmritr,
-                thepass,
-                lagstrengths,
-                lagtimes,
-                previousnormoutputdata,
-                optiondict["corrmasksize"],
-            )
-            TimingLGR.info(
-                f"Regressor refinement end, pass {thepass}",
-                {
-                    "message2": voxelsprocessed_rr,
-                    "message3": "voxels",
-                },
-            )
-            for key, value in outputdict.items():
-                optiondict[key] = value
-
-            # Save shifted timecourses for César
-            if optiondict["saveintermediatemaps"] and optiondict["savelagregressors"]:
-                theheader = theinputdata.copyheader()
-                bidspasssuffix = f"_intermediatedata-pass{thepass}"
-                maplist = [
-                    (
-                        (theRegressorRefiner.getpaddedshiftedtcs())[:, numpadtrs:-numpadtrs],
-                        "shiftedtcs",
-                        "bold",
-                        None,
-                        "The filtered input fMRI data, in voxels used for refinement, time shifted by the negated delay in every voxel so that the moving blood component is aligned.",
-                    ),
-                ]
-                tide_io.savemaplist(
-                    f"{outputname}{bidspasssuffix}",
-                    maplist,
+            (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,
-                    theheader,
                     bidsbasedict,
-                    filetype=theinputdata.filetype,
-                    rt_floattype=rt_floattype,
-                    cifti_hdr=theinputdata.cifti_hdr,
-                    debug=True,
+                    rt_floatset=np.float64,
+                    rt_floattype="float64",
                 )
-            # We are done with refinement.
+            )
         # End of main pass loop
 
     if optiondict["convergencethresh"] is None:
@@ -2536,23 +2141,27 @@ def rapidtide_main(argparsingfunc):
         internalvalidcoherenceshape = (numvalidspatiallocs, coherencefreqaxissize)
 
         # now allocate the arrays needed for the coherence calculation
+        coherencefunc, coherencefunc_shm = tide_util.allocarray(
+            internalvalidcoherenceshape,
+            rt_outfloatset,
+            shared=optiondict["sharedmem"],
+            name=f"coherencefunc_{optiondict['pid']}",
+        )
+        coherencepeakval, coherencepeakval_shm = tide_util.allocarray(
+            numvalidspatiallocs,
+            rt_outfloatset,
+            shared=optiondict["sharedmem"],
+            name=f"coherencepeakval_{optiondict['pid']}",
+        )
+        coherencepeakfreq, coherencepeakfreq_shm = tide_util.allocarray(
+            numvalidspatiallocs,
+            rt_outfloatset,
+            shared=optiondict["sharedmem"],
+            name=f"coherencepeakfreq_{optiondict['pid']}",
+        )
         if optiondict["sharedmem"]:
-            coherencefunc, coherencefunc_shm = tide_util.allocshared(
-                internalvalidcoherenceshape,
-                rt_outfloatset,
-                name=f"coherencefunc_{optiondict['pid']}",
-            )
-            coherencepeakval, coherencepeakval_shm = tide_util.allocshared(
-                numvalidspatiallocs, rt_outfloatset, name=f"coherencepeakval_{optiondict['pid']}"
-            )
-            coherencepeakfreq, coherencepeakfreq_shm = tide_util.allocshared(
-                numvalidspatiallocs, rt_outfloatset, name=f"coherencepeakfreq_{optiondict['pid']}"
-            )
             ramlocation = "in shared memory"
         else:
-            coherencefunc = np.zeros(internalvalidcoherenceshape, dtype=rt_outfloattype)
-            coherencepeakval = np.zeros(numvalidspatiallocs, dtype=rt_outfloattype)
-            coherencepeakfreq = np.zeros(numvalidspatiallocs, dtype=rt_outfloattype)
             ramlocation = "locally"
         optiondict["totalcoherencebytes"] = (
             coherencefunc.nbytes + coherencepeakval.nbytes + coherencepeakfreq.nbytes
@@ -2560,7 +2169,7 @@ def rapidtide_main(argparsingfunc):
         thesize, theunit = tide_util.format_bytes(optiondict["totalcoherencebytes"])
         print(f"allocated {thesize:.3f} {theunit} {ramlocation} for coherence calculation")
 
-        tide_util.disablemkl(1, debug=threaddebug)
+        tide_util.disablemkl(1, debug=optiondict["threaddebug"])
         voxelsprocessed_coherence = tide_calccoherence.coherencepass(
             fmri_data_valid,
             theCoherer,
@@ -2570,10 +2179,10 @@ def rapidtide_main(argparsingfunc):
             alt=True,
             showprogressbar=optiondict["showprogressbar"],
             chunksize=optiondict["mp_chunksize"],
-            nprocs=1,
+            nprocs=optiondict["nprocs"],
             alwaysmultiproc=optiondict["alwaysmultiproc"],
         )
-        tide_util.enablemkl(optiondict["mklthreads"], debug=threaddebug)
+        tide_util.enablemkl(optiondict["mklthreads"], debug=optiondict["threaddebug"])
 
         # save the results of the calculations
         theheader = theinputdata.copyheader(
@@ -2608,17 +2217,21 @@ 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_outfloatset,
+            shared=optiondict["sharedmem"],
+            name=f"wienerdeconv_{optiondict['pid']}",
+        )
+        wpeak, wpeak_shm = tide_util.allocarray(
+            internalvalidspaceshape,
+            rt_outfloatset,
+            shared=optiondict["sharedmem"],
+            name=f"wpeak_{optiondict['pid']}",
+        )
         if optiondict["sharedmem"]:
-            wienerdeconv, wienerdeconv_shm = tide_util.allocshared(
-                internalvalidspaceshape, rt_outfloatset, name=f"wienerdeconv_{optiondict['pid']}"
-            )
-            wpeak, wpeak_shm = tide_util.allocshared(
-                internalvalidspaceshape, rt_outfloatset, name=f"wpeak_{optiondict['pid']}"
-            )
             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"])
@@ -2628,6 +2241,7 @@ def rapidtide_main(argparsingfunc):
             numspatiallocs,
             fmri_data_valid,
             threshval,
+            lagtc,
             optiondict,
             wienerdeconv,
             wpeak,
@@ -2656,9 +2270,10 @@ def rapidtide_main(argparsingfunc):
     optiondict["currentstage"] = "presLFOfit"
     tide_io.writedicttojson(optiondict, f"{outputname}_desc-runoptions_info.json")
     if optiondict["dolinfitfilt"] or optiondict["docvrmap"] or optiondict["refinedelay"]:
-        sLFOfiltmask = fitmask + 0.0
-        if optiondict["nosLFOfiltmask"]:
-            sLFOfiltmask = sLFOfiltmask * 0.0 + 1.0
+        if optiondict["sLFOfiltmask"]:
+            sLFOfiltmask = fitmask + 0.0
+        else:
+            sLFOfiltmask = fitmask * 0.0 + 1.0
         if optiondict["dolinfitfilt"]:
             if optiondict["refinedelay"]:
                 TimingLGR.info("Setting up for delay refinement and sLFO filtering")
@@ -2721,66 +2336,27 @@ def rapidtide_main(argparsingfunc):
                 TimingLGR.info("End moving fmri_data to shared memory")
             theinputdata.unload()
 
-        # now allocate the arrays needed for sLFO filtering
-        if optiondict["refinedelay"]:
-            derivaxissize = np.max(
-                [optiondict["refineregressderivs"] + 1, optiondict["regressderivs"] + 1]
-            )
-        else:
-            derivaxissize = optiondict["regressderivs"] + 1
-        internalvalidspaceshapederivs = (
-            internalvalidspaceshape,
-            derivaxissize,
+        # 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"]:
-            sLFOfitmean, sLFOfitmean_shm = tide_util.allocshared(
-                internalvalidspaceshape, rt_outfloatset, name=f"sLFOfitmean_{optiondict['pid']}"
-            )
-            rvalue, rvalue_shm = tide_util.allocshared(
-                internalvalidspaceshape, rt_outfloatset, name=f"rvalue_{optiondict['pid']}"
-            )
-            r2value, r2value_shm = tide_util.allocshared(
-                internalvalidspaceshape, rt_outfloatset, name=f"r2value_{optiondict['pid']}"
-            )
-            fitNorm, fitNorm_shm = tide_util.allocshared(
-                internalvalidspaceshapederivs, rt_outfloatset, name=f"fitNorm_{optiondict['pid']}"
-            )
-            fitcoeff, fitcoeff_shm = tide_util.allocshared(
-                internalvalidspaceshapederivs, rt_outfloatset, name=f"fitcoeff_{optiondict['pid']}"
-            )
-            movingsignal, movingsignal_shm = tide_util.allocshared(
-                internalvalidfmrishape, rt_outfloatset, name=f"movingsignal_{optiondict['pid']}"
-            )
-            lagtc, lagtc_shm = tide_util.allocshared(
-                internalvalidfmrishape, rt_floatset, name=f"lagtc_{optiondict['pid']}"
-            )
-            filtereddata, filtereddata_shm = tide_util.allocshared(
-                internalvalidfmrishape, rt_outfloatset, name=f"filtereddata_{optiondict['pid']}"
-            )
             ramlocation = "in shared memory"
         else:
-            sLFOfitmean = 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)
             ramlocation = "locally"
 
-        optiondict["totalsLFOfilterbytes"] = (
-            sLFOfitmean.nbytes
-            + rvalue.nbytes
-            + r2value.nbytes
-            + fitNorm.nbytes
-            + fitcoeff.nbytes
-            + movingsignal.nbytes
-            + lagtc.nbytes
-            + filtereddata.nbytes
-        )
+        optiondict["totalsLFOfilterbytes"] = movingsignal.nbytes + filtereddata.nbytes
         thesize, theunit = tide_util.format_bytes(optiondict["totalsLFOfilterbytes"])
-        print(f"allocated {thesize:.3f} {theunit} {ramlocation} for sLFO filter/delay refinement")
+        print(f"allocated {thesize:.3f} {theunit} {ramlocation} for sLFO filter")
         tide_util.logmem("before sLFO filter")
 
         if optiondict["dolinfitfilt"]:
@@ -2829,121 +2405,52 @@ def rapidtide_main(argparsingfunc):
         if optiondict["refinedelay"]:
             TimingLGR.info("Delay refinement start")
             LGR.info("\n\nDelay refinement")
+
             if optiondict["delayoffsetgausssigma"] < 0.0 and theinputdata.filetype != "text":
                 # set gausssigma automatically
                 optiondict["delayoffsetgausssigma"] = np.mean([xdim, ydim, slicethickness]) / 2.0
 
-            regressderivratios, regressrvalues = tide_refinedelay.getderivratios(
+            (
+                delayoffset,
+                regressderivratios,
+                medfiltregressderivratios,
+                filteredregressderivratios,
+                optiondict["delayoffsetMAD"],
+            ) = tide_refineDelayMap.refineDelay(
                 fmri_data_valid,
-                validvoxels,
                 initial_fmri_x,
-                lagtimes,
+                xdim,
+                ydim,
+                slicethickness,
                 sLFOfiltmask,
                 genlagtc,
-                mode,
-                outputname,
                 oversamptr,
                 sLFOfitmean,
                 rvalue,
                 r2value,
-                fitNorm[:, : (optiondict["refineregressderivs"] + 1)],
-                fitcoeff[:, : (optiondict["refineregressderivs"] + 1)],
-                movingsignal,
+                fitNorm,
+                fitcoeff,
                 lagtc,
-                filtereddata,
+                outputname,
+                validvoxels,
+                nativespaceshape,
+                theinputdata,
+                lagtimes,
+                optiondict,
                 LGR,
                 TimingLGR,
-                optiondict,
-                regressderivs=optiondict["refineregressderivs"],
+                outputlevel=optiondict["outputlevel"],
+                gausssigma=optiondict["delayoffsetgausssigma"],
+                patchthresh=optiondict["delaypatchthresh"],
+                mindelay=optiondict["mindelay"],
+                maxdelay=optiondict["maxdelay"],
+                numpoints=optiondict["numpoints"],
+                histlen=optiondict["histlen"],
+                rt_floatset=rt_floatset,
+                rt_floattype=rt_floattype,
                 debug=optiondict["debug"],
             )
-
-            if optiondict["refineregressderivs"] == 1:
-                medfiltregressderivratios, filteredregressderivratios, delayoffsetMAD = (
-                    tide_refinedelay.filterderivratios(
-                        regressderivratios,
-                        nativespaceshape,
-                        validvoxels,
-                        (xdim, ydim, slicethickness),
-                        gausssigma=optiondict["delayoffsetgausssigma"],
-                        patchthresh=optiondict["delaypatchthresh"],
-                        filetype=theinputdata.filetype,
-                        rt_floattype="float64",
-                        debug=optiondict["debug"],
-                    )
-                )
-                optiondict["delayoffsetMAD"] = delayoffsetMAD
-
-                # find the mapping of derivative ratios to delays
-                tide_refinedelay.trainratiotooffset(
-                    genlagtc,
-                    initial_fmri_x,
-                    outputname,
-                    optiondict["outputlevel"],
-                    mindelay=optiondict["mindelay"],
-                    maxdelay=optiondict["maxdelay"],
-                    numpoints=optiondict["numpoints"],
-                    debug=optiondict["debug"],
-                )
-
-                # now calculate the delay offsets
-                delayoffset = np.zeros_like(filteredregressderivratios)
-                if optiondict["debug"]:
-                    print(
-                        f"calculating delayoffsets for {filteredregressderivratios.shape[0]} voxels"
-                    )
-                for i in range(filteredregressderivratios.shape[0]):
-                    delayoffset[i], closestoffset = tide_refinedelay.ratiotodelay(
-                        filteredregressderivratios[i]
-                    )
-            else:
-                medfiltregressderivratios = np.zeros_like(regressderivratios)
-                filteredregressderivratios = np.zeros_like(regressderivratios)
-                delayoffsetMAD = np.zeros(optiondict["refineregressderivs"], dtype=float)
-                for i in range(optiondict["refineregressderivs"]):
-                    (
-                        medfiltregressderivratios[i, :],
-                        filteredregressderivratios[i, :],
-                        delayoffsetMAD[i],
-                    ) = tide_refinedelay.filterderivratios(
-                        regressderivratios[i, :],
-                        (xsize, ysize, numslices),
-                        validvoxels,
-                        (xdim, ydim, slicethickness),
-                        gausssigma=optiondict["delayoffsetgausssigma"],
-                        patchthresh=optiondict["delaypatchthresh"],
-                        filetype=theinputdata.filetype,
-                        rt_floattype=rt_floattype,
-                        debug=optiondict["debug"],
-                    )
-                    optiondict[f"delayoffsetMAD_{i + 1}"] = delayoffsetMAD[i]
-
-                # now calculate the delay offsets
-                delayoffset = np.zeros_like(filteredregressderivratios[0, :])
-                if optiondict["debug"]:
-                    print(
-                        f"calculating delayoffsets for {filteredregressderivratios.shape[1]} voxels"
-                    )
-                for i in range(filteredregressderivratios.shape[1]):
-                    delayoffset[i] = tide_refinedelay.coffstodelay(
-                        filteredregressderivratios[:, i],
-                        mindelay=optiondict["mindelay"],
-                        maxdelay=optiondict["maxdelay"],
-                    )
-
-            namesuffix = "_desc-delayoffset_hist"
-            if optiondict["dolinfitfilt"]:
-                tide_stats.makeandsavehistogram(
-                    delayoffset[np.where(sLFOfiltmask > 0)],
-                    optiondict["histlen"],
-                    1,
-                    outputname + namesuffix,
-                    displaytitle="Histogram of delay offsets calculated from regression coefficients",
-                    dictvarname="delayoffsethist",
-                    thedict=optiondict,
-                )
             lagtimesrefined = lagtimes + delayoffset
-
             ####################################################
             #  Delay refinement end
             ####################################################
@@ -3176,6 +2683,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]
@@ -3186,6 +2697,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"]
 
@@ -3239,55 +2754,29 @@ def rapidtide_main(argparsingfunc):
             ),
         ]
         if (optiondict["outputlevel"] != "min") and (optiondict["outputlevel"] != "less"):
-            if optiondict["refineregressderivs"] > 1:
-                for i in range(optiondict["refineregressderivs"]):
-                    savelist += [
-                        (
-                            regressderivratios[i, :],
-                            f"regressderivratios_{i}",
-                            "map",
-                            None,
-                            f"Ratio of derivative {i + 1} of delayed sLFO to the delayed sLFO",
-                        ),
-                        (
-                            medfiltregressderivratios[i, :],
-                            f"medfiltregressderivratios_{i}",
-                            "map",
-                            None,
-                            f"Median filtered version of the regressderivratios_{i} map",
-                        ),
-                        (
-                            filteredregressderivratios[i, :],
-                            f"filteredregressderivratios_{i}",
-                            "map",
-                            None,
-                            f"regressderivratios_{i}, with outliers patched using median filtered data",
-                        ),
-                    ]
-            else:
-                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",
-                    ),
-                ]
+            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"),
@@ -3549,7 +3038,13 @@ def rapidtide_main(argparsingfunc):
     if theinputdata.filetype != "nifti":
         unfiltmeanvalue = meanvalue
     maplist = [
-        (unfiltmeanvalue, "unfiltmean", "map", None, "Voxelwise mean of fmri data before smoothing"),
+        (
+            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"),
@@ -3579,27 +3074,28 @@ def rapidtide_main(argparsingfunc):
     if optiondict["numestreps"] > 0:
         masklist = []
 
-        # we can only calculate this map if we have enough data for a good fit
+        # we can only calculate this map if we have enough data for a good fit, and the fit succeeded
         if optiondict["numestreps"] >= 1000:
-            neglogpmax = np.log10(optiondict["numestreps"])
-            # generate a neglogp map
-            neglog10pmap = lagstrengths * 0.0
-            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",
-                )
-            ]
+            if sigfit is not None:
+                neglogpmax = np.log10(optiondict["numestreps"])
+                # generate a neglogp map
+                neglog10pmap = lagstrengths * 0.0
+                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,