rapidtide 3.0a11__py3-none-any.whl → 3.0a13__py3-none-any.whl

rapidtide/workflows/rapidtide.py

@@ -37,22 +37,22 @@ 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.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.refineregressor as tide_refineregressor
+import rapidtide.RegressorRefiner as tide_regrefiner
 import rapidtide.resample as tide_resample
 import rapidtide.simfuncfit as tide_simfuncfit
 import rapidtide.stats as tide_stats
 import rapidtide.util as tide_util
 import rapidtide.wiener as tide_wiener
-import rapidtide.workflows.glmfrommaps as tide_glmfrommaps
+import rapidtide.workflows.regressfrommaps as tide_regressfrommaps
 from rapidtide.tests.utils import mse
 
 from .utils import setup_logger
@@ -382,10 +382,10 @@ 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:
@@ -889,7 +889,7 @@ def rapidtide_main(argparsingfunc):
             mergedregressorlabels,
             fmri_data_valid,
             confoundr2,
-        ) = tide_glmpass.confoundregress(
+        ) = tide_linfitfiltpass.confoundregress(
             mergedregressors,
             mergedregressorlabels,
             fmri_data_valid,
@@ -961,7 +961,7 @@ def rapidtide_main(argparsingfunc):
         )
         if optiondict["memprofile"]:
             memcheckpoint("...done")
-        tide_util.logmem("after confound glm filter")
+        tide_util.logmem("after confound sLFO filter")
 
         if optiondict["saveconfoundfiltered"]:
             if not optiondict["textio"]:
@@ -1455,6 +1455,8 @@ def rapidtide_main(argparsingfunc):
         resampref_y *= tmaskos_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(
@@ -1730,38 +1732,49 @@ def rapidtide_main(argparsingfunc):
     if (
         optiondict["passes"] > 1
         or optiondict["globalpreselect"]
+        or optiondict["dofinalrefine"]
         or optiondict["convergencethresh"] is not None
     ):
-        if optiondict["sharedmem"]:
-            shiftedtcs, shiftedtcs_shm = tide_util.allocshared(
-                internalvalidfmrishape, rt_floatset, name=f"shiftedtcs_{optiondict['pid']}"
-            )
-            weights, weights_shm = tide_util.allocshared(
-                internalvalidfmrishape, rt_floatset, name=f"weights_{optiondict['pid']}"
-            )
-            paddedshiftedtcs, paddedshiftedtcs_shm = tide_util.allocshared(
-                internalvalidpaddedfmrishape,
-                rt_floatset,
-                name=f"paddedshiftedtcs_{optiondict['pid']}",
-            )
-            paddedweights, paddedweights_shm = tide_util.allocshared(
-                internalvalidpaddedfmrishape,
-                rt_floatset,
-                name=f"paddedweights_{optiondict['pid']}",
-            )
-            ramlocation = "in shared memory"
-        else:
-            shiftedtcs = np.zeros(internalvalidfmrishape, dtype=rt_floattype)
-            weights = np.zeros(internalvalidfmrishape, dtype=rt_floattype)
-            paddedshiftedtcs = np.zeros(internalvalidpaddedfmrishape, dtype=rt_floattype)
-            paddedweights = np.zeros(internalvalidpaddedfmrishape, dtype=rt_floattype)
-            ramlocation = "locally"
-        optiondict["totalrefinementbytes"] = (
-            shiftedtcs.nbytes + weights.nbytes + paddedshiftedtcs.nbytes + paddedweights.nbytes
+        # we will be doing regressor refinement, so set that up
+        theRegressorRefiner = tide_regrefiner.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"],
+            debug=optiondict["debug"],
         )
-        thesize, theunit = tide_util.format_bytes(optiondict["totalrefinementbytes"])
-        print(f"allocated {thesize:.3f} {theunit} {ramlocation} for refinement")
-        tide_util.logmem("after refinement array allocation")
 
     outfmriarray = np.zeros(internalfmrishape, dtype=rt_floattype)
 
@@ -1935,7 +1948,7 @@ def rapidtide_main(argparsingfunc):
             )
 
             # regress out
-            resampref_y, datatoremove, R, dummy = tide_fit.glmfilt(
+            resampref_y, datatoremove, R, dummy = tide_fit.linfitfilt(
                 resampref_y, shiftednoise, debug=True
             )
 
@@ -2779,6 +2792,7 @@ def rapidtide_main(argparsingfunc):
             thepass < optiondict["passes"]
             or optiondict["convergencethresh"] is not None
             or optiondict["globalpreselect"]
+            or optiondict["dofinalrefine"]
         ):
             LGR.info(f"\n\nRegressor refinement, pass {thepass}")
             TimingLGR.info(f"Regressor refinement start, pass {thepass}")
@@ -2840,254 +2854,51 @@ def rapidtide_main(argparsingfunc):
                         "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")
-            (
-                dummy,
-                refinemask,
-                locationfails,
-                ampfails,
-                lagfails,
-                sigmafails,
-                numinmask,
-            ) = tide_refineregressor.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")
+            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
-            alignvoxels_func = addmemprofiling(
-                tide_refineregressor.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,
+            voxelsprocessed_rra = theRegressorRefiner.alignvoxels(
+                fmri_data_valid, fmritr, lagtimes
             )
             enablemkl(optiondict["mklthreads"], debug=threaddebug)
             LGR.info(f"align complete: {voxelsprocessed_rra=}")
 
+            # prenormalize
             LGR.info("prenormalizing timecourses")
-            tide_refineregressor.prenorm(
-                paddedshiftedtcs,
-                refinemask,
-                lagtimes,
-                optiondict["lagmaxthresh"],
-                lagstrengths,
-                R2,
-                optiondict["refineprenorm"],
-                optiondict["refineweighting"],
-            )
+            theRegressorRefiner.prenormalize(lagtimes, lagstrengths, R2)
 
+            # now doing the refinement
             (
                 voxelsprocessed_rr,
-                paddedoutputdata,
-            ) = tide_refineregressor.dorefine(
-                paddedshiftedtcs,
-                refinemask,
-                weights,
+                outputdict,
+                previousnormoutputdata,
+                resampref_y,
+                resampnonosref_y,
+                stoprefining,
+                refinestopreason,
+                genlagtc,
+            ) = theRegressorRefiner.refine(
                 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"]
+                previousnormoutputdata,
+                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["tincludemaskname"] is not None:
-                    resampnonosref_y *= tmask_y
-                    thefit, R2val = tide_fit.mlregress(tmask_y, resampnonosref_y)
-                    resampnonosref_y -= thefit[0, 1] * tmask_y
-                    resampref_y *= tmaskos_y
-                    thefit, R2val = 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=optiondict["fastresamplerpadtime"],
-                )
-                genlagtc.save(f"{outputname}_desc-lagtcgenerator_timeseries")
-                if optiondict["debug"]:
-                    genlagtc.info()
-                (
-                    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}",
                 {
@@ -3095,7 +2906,10 @@ def rapidtide_main(argparsingfunc):
                     "message3": "voxels",
                 },
             )
-        if optiondict["saveintermediatemaps"]:
+            for key, value in outputdict.items():
+                optiondict[key] = value
+
+        """if optiondict["saveintermediatemaps"]:
             if not optiondict["textio"]:
                 theheader = copy.deepcopy(nim_hdr)
                 if fileiscifti:
@@ -3143,9 +2957,10 @@ def rapidtide_main(argparsingfunc):
                 fileiscifti=fileiscifti,
                 rt_floattype=rt_floattype,
                 cifti_hdr=cifti_hdr,
-            )
+            )"""
+
+        # We are done with refinement.
 
-    # We are done with refinement.
     if optiondict["convergencethresh"] is None:
         optiondict["actual_passes"] = optiondict["passes"]
     else:
@@ -3340,20 +3155,20 @@ def rapidtide_main(argparsingfunc):
             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"] or optiondict["refinedelay"]:
-        if optiondict["doglmfilt"]:
+    if optiondict["dolinfitfilt"] or optiondict["docvrmap"] or optiondict["refinedelay"]:
+        if optiondict["dolinfitfilt"]:
             if optiondict["refinedelay"]:
-                TimingLGR.info("Setting up for delay refinement and GLM filtering")
-                LGR.info("\n\nDelay refinement and GLM filtering setup")
+                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 GLM filtering")
-                LGR.info("\n\nGLM filtering setup")
+                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")
@@ -3366,14 +3181,16 @@ def rapidtide_main(argparsingfunc):
             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"]
+            if optiondict["denoisesourcefile"] is not None:
+                LGR.info(
+                    f"reading in {optiondict['denoisesourcefile']} for sLFO filter, please wait"
+                )
+                sourcename = optiondict["denoisesourcefile"]
             else:
-                LGR.info(f"rereading {fmrifilename} for GLM filter, please wait")
+                LGR.info(f"rereading {fmrifilename} for sLFO filter, please wait")
                 sourcename = fmrifilename
             if fileiscifti:
                 LGR.info("input file is CIFTI")
@@ -3420,26 +3237,30 @@ def rapidtide_main(argparsingfunc):
                 numpy2shared_func = addmemprofiling(
                     tide_util.numpy2shared,
                     optiondict["memprofile"],
-                    "before movetoshared (glm)",
+                    "before movetoshared (sLFO filter)",
                 )
                 fmri_data_valid, fmri_data_valid_shm = numpy2shared_func(
-                    fmri_data_valid, rt_floatset, name=f"fmri_data_valid_glm_{optiondict['pid']}"
+                    fmri_data_valid,
+                    rt_floatset,
+                    name=f"fmri_data_valid_regressionfilt_{optiondict['pid']}",
                 )
                 TimingLGR.info("End moving fmri_data to shared memory")
             del nim_data
 
-        # now allocate the arrays needed for GLM filtering
+        # now allocate the arrays needed for sLFO filtering
         if optiondict["refinedelay"]:
-            derivaxissize = np.max([2, optiondict["glmderivs"] + 1])
+            derivaxissize = np.max(
+                [optiondict["refineregressderivs"] + 1, optiondict["regressderivs"] + 1]
+            )
         else:
-            derivaxissize = optiondict["glmderivs"] + 1
+            derivaxissize = optiondict["regressderivs"] + 1
         internalvalidspaceshapederivs = (
             internalvalidspaceshape,
             derivaxissize,
         )
         if optiondict["sharedmem"]:
-            glmmean, glmmean_shm = tide_util.allocshared(
-                internalvalidspaceshape, rt_outfloatset, name=f"glmmean_{optiondict['pid']}"
+            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']}"
@@ -3464,7 +3285,7 @@ def rapidtide_main(argparsingfunc):
             )
             ramlocation = "in shared memory"
         else:
-            glmmean = np.zeros(internalvalidspaceshape, dtype=rt_outfloattype)
+            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)
@@ -3474,8 +3295,8 @@ def rapidtide_main(argparsingfunc):
             filtereddata = np.zeros(internalvalidfmrishape, dtype=rt_outfloattype)
             ramlocation = "locally"
 
-        optiondict["totalglmbytes"] = (
-            glmmean.nbytes
+        optiondict["totalsLFOfilterbytes"] = (
+            sLFOfitmean.nbytes
             + rvalue.nbytes
             + r2value.nbytes
             + fitNorm.nbytes
@@ -3484,25 +3305,25 @@ def rapidtide_main(argparsingfunc):
             + lagtc.nbytes
             + filtereddata.nbytes
         )
-        thesize, theunit = tide_util.format_bytes(optiondict["totalglmbytes"])
-        print(f"allocated {thesize:.3f} {theunit} {ramlocation} for glm/delay refinement")
+        thesize, theunit = tide_util.format_bytes(optiondict["totalsLFOfilterbytes"])
+        print(f"allocated {thesize:.3f} {theunit} {ramlocation} for sLFO filter/delay refinement")
 
         if optiondict["memprofile"]:
-            if optiondict["doglmfilt"]:
-                memcheckpoint("about to start glm noise removal...")
+            if optiondict["dolinfitfilt"]:
+                memcheckpoint("about to start sLFO noise removal...")
             else:
                 memcheckpoint("about to start CVR magnitude estimation...")
-        tide_util.logmem("before glm")
+        tide_util.logmem("before sLFO filter")
 
-        if optiondict["doglmfilt"]:
+        if optiondict["dolinfitfilt"]:
             mode = "glm"
-            optiondict["glmthreshval"] = threshval
+            optiondict["regressfiltthreshval"] = threshval
         else:
             # set the threshval to zero
             mode = "cvrmap"
-            optiondict["glmthreshval"] = 0.0
+            optiondict["regressfiltthreshval"] = 0.0
         if optiondict["debug"]:
-            # dump the fmri input file going to glm
+            # dump the fmri input file going to sLFO filter
             if not optiondict["textio"]:
                 theheader = copy.deepcopy(nim_hdr)
                 if fileiscifti:
@@ -3523,7 +3344,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(
@@ -3539,7 +3360,7 @@ def rapidtide_main(argparsingfunc):
                 cifti_hdr=cifti_hdr,
             )
 
-        # refine the delay value prior to calculating the GLM
+        # refine the delay value prior to calculating the sLFO filter
         if optiondict["refinedelay"]:
             TimingLGR.info("Delay refinement start")
             LGR.info("\n\nDelay refinement")
@@ -3547,7 +3368,7 @@ def rapidtide_main(argparsingfunc):
                 # set gausssigma automatically
                 optiondict["delayoffsetgausssigma"] = np.mean([xdim, ydim, slicethickness]) / 2.0
 
-            glmderivratios = tide_refinedelay.getderivratios(
+            regressderivratios, regressrvalues = tide_refinedelay.getderivratios(
                 fmri_data_valid,
                 validvoxels,
                 initial_fmri_x,
@@ -3557,62 +3378,102 @@ def rapidtide_main(argparsingfunc):
                 mode,
                 outputname,
                 oversamptr,
-                glmmean,
+                sLFOfitmean,
                 rvalue,
                 r2value,
-                fitNorm[:, :2],
-                fitcoeff[:, :2],
+                fitNorm[:, : (optiondict["refineregressderivs"] + 1)],
+                fitcoeff[:, : (optiondict["refineregressderivs"] + 1)],
                 movingsignal,
                 lagtc,
                 filtereddata,
                 LGR,
                 TimingLGR,
                 optiondict,
+                regressderivs=optiondict["refineregressderivs"],
                 debug=optiondict["debug"],
             )
 
-            medfiltglmderivratios, filteredglmderivratios, delayoffsetMAD = (
-                tide_refinedelay.filterderivratios(
-                    glmderivratios,
-                    nativespaceshape,
-                    validvoxels,
-                    (xdim, ydim, slicethickness),
-                    gausssigma=optiondict["delayoffsetgausssigma"],
-                    patchthresh=optiondict["delaypatchthresh"],
-                    fileiscifti=fileiscifti,
-                    textio=optiondict["textio"],
-                    rt_floattype="float64",
+            if optiondict["refineregressderivs"] == 1:
+                medfiltregressderivratios, filteredregressderivratios, delayoffsetMAD = (
+                    tide_refinedelay.filterderivratios(
+                        regressderivratios,
+                        nativespaceshape,
+                        validvoxels,
+                        (xdim, ydim, slicethickness),
+                        gausssigma=optiondict["delayoffsetgausssigma"],
+                        patchthresh=optiondict["delaypatchthresh"],
+                        fileiscifti=fileiscifti,
+                        textio=optiondict["textio"],
+                        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"],
                 )
-            )
-            optiondict["delayoffsetMAD"] = delayoffsetMAD
 
-            # find the mapping of glm 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] = 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"],
+                        fileiscifti=False,
+                        textio=False,
+                        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"],
+                    )
 
-            # now calculate the delay offsets
-            delayoffset = filteredglmderivratios * 0.0
-            if optiondict["debug"]:
-                print(f"calculating delayoffsets for {filteredglmderivratios.shape[0]} voxels")
-            for i in range(filteredglmderivratios.shape[0]):
-                delayoffset[i] = tide_refinedelay.ratiotodelay(filteredglmderivratios[i])
             namesuffix = "_desc-delayoffset_hist"
-            if optiondict["doglmfilt"]:
+            if optiondict["dolinfitfilt"]:
                 tide_stats.makeandsavehistogram(
                     delayoffset[np.where(fitmask > 0)],
                     optiondict["histlen"],
                     1,
                     outputname + namesuffix,
-                    displaytitle="Histogram of delay offsets calculated from GLM",
+                    displaytitle="Histogram of delay offsets calculated from regression coefficients",
                     dictvarname="delayoffsethist",
                     thedict=optiondict,
                 )
@@ -3622,11 +3483,11 @@ def rapidtide_main(argparsingfunc):
             #  Delay refinement end
             ####################################################
 
-        # now calculate the GLM or CVR map
-        if optiondict["doglmfilt"] or optiondict["docvrmap"]:
-            if optiondict["doglmfilt"]:
-                TimingLGR.info("GLM filtering start")
-                LGR.info("\n\nGLM filtering")
+        # 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")
@@ -3635,46 +3496,48 @@ def rapidtide_main(argparsingfunc):
             # 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 GLM
+            # now calculate the sLFO filter
             if optiondict["refinedelay"] and optiondict["filterwithrefineddelay"]:
                 lagstouse = lagtimesrefined
             else:
                 lagstouse = lagtimes
-            voxelsprocessed_glm, regressorset, evset = tide_glmfrommaps.glmfrommaps(
-                fmri_data_valid,
-                validvoxels,
-                initial_fmri_x,
-                lagstouse,
-                fitmask,
-                genlagtc,
-                mode,
-                outputname,
-                oversamptr,
-                glmmean,
-                rvalue,
-                r2value,
-                fitNorm[:, : optiondict["glmderivs"] + 1],
-                fitcoeff[:, : optiondict["glmderivs"] + 1],
-                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["debug"],
+            voxelsprocessed_regressionfilt, regressorset, evset = (
+                tide_regressfrommaps.regressfrommaps(
+                    fmri_data_valid,
+                    validvoxels,
+                    initial_fmri_x,
+                    lagstouse,
+                    fitmask,
+                    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"],
+                    mp_chunksize=optiondict["mp_chunksize"],
+                    showprogressbar=optiondict["showprogressbar"],
+                    alwaysmultiproc=optiondict["alwaysmultiproc"],
+                    memprofile=optiondict["memprofile"],
+                    debug=optiondict["debug"],
+                )
             )
 
             evcolnames = ["base"]
-            if optiondict["glmderivs"] > 0:
-                for i in range(1, optiondict["glmderivs"] + 1):
+            if optiondict["regressderivs"] > 0:
+                for i in range(1, optiondict["regressderivs"] + 1):
                     evcolnames.append(f"deriv_{str(i)}")
 
             tide_io.writebidstsv(
@@ -3682,7 +3545,7 @@ def rapidtide_main(argparsingfunc):
                 np.transpose(evset),
                 1.0 / fmritr,
                 columns=evcolnames,
-                extraheaderinfo={"Description": "GLM regressor set"},
+                extraheaderinfo={"Description": "sLFO filter regressor set"},
                 append=False,
             )
 
@@ -3694,30 +3557,20 @@ def rapidtide_main(argparsingfunc):
             varchange = initialvariance * 0.0
             varchange[divlocs] = 100.0 * (finalvariance[divlocs] / initialvariance[divlocs] - 1.0)
 
-            """divlocs = np.where(finalrawvariance > 0.0)
-            rawvarchange = initialrawvariance * 0.0
-            rawvarchange[divlocs] = 100.0 * (
-                finalrawvariance[divlocs] / initialvariance[divlocs] - 1.0
-            )"""
-
-            del fmri_data_valid
-            if optiondict["sharedmem"]:
-                tide_util.cleanup_shm(fmri_data_valid_shm)
-
             LGR.info("End filtering operation")
             TimingLGR.info(
-                "GLM filtering end",
+                "sLFO filtering end",
                 {
-                    "message2": voxelsprocessed_glm,
+                    "message2": voxelsprocessed_regressionfilt,
                     "message3": "voxels",
                 },
             )
             if optiondict["memprofile"]:
                 memcheckpoint("...done")
-            tide_util.logmem("after glm filter")
+            tide_util.logmem("after sLFO filter")
             LGR.info("")
     ####################################################
-    #  GLM filtering end
+    #  sLFO filtering end
     ####################################################
 
     # Post refinement step 2 - make and save interesting histograms
@@ -3755,24 +3608,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,
         )
@@ -3861,32 +3714,57 @@ def rapidtide_main(argparsingfunc):
                 "second",
                 "Lag time in seconds, refined",
             ),
-            (np.fabs(rvalue), "maxcorralt", "map", None, "R value of the GLM fit, with sign"),
         ]
         if (optiondict["outputlevel"] != "min") and (optiondict["outputlevel"] != "less"):
-            savelist += [
-                (
-                    glmderivratios,
-                    "glmderivratios",
-                    "map",
-                    None,
-                    "Ratio of the first derivative of delayed sLFO to the delayed sLFO",
-                ),
-                (
-                    medfiltglmderivratios,
-                    "medfiltglmderivratios",
-                    "map",
-                    None,
-                    "Median filtered version of the glmderivratios map",
-                ),
-                (
-                    filteredglmderivratios,
-                    "filteredglmderivratios",
-                    "map",
-                    None,
-                    "glmderivratios, with outliers patched using median filtered data",
-                ),
-            ]
+            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",
+                    ),
+                ]
     if optiondict["calccoherence"]:
         savelist += [
             (coherencepeakval, "coherencepeakval", "map", None, "Coherence peak value"),
@@ -3924,8 +3802,8 @@ def rapidtide_main(argparsingfunc):
             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,
@@ -3949,22 +3827,22 @@ def rapidtide_main(argparsingfunc):
                     "Change in inband variance after filtering, in percent",
                 ),
             ]
-            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 += [
-                    (np.fabs(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], "lfofilterCoeff", "map", None, "Fit coefficient"),
                         (
@@ -3975,7 +3853,7 @@ def rapidtide_main(argparsingfunc):
                             "Normalized fit coefficient",
                         ),
                     ]
-                    for thederiv in range(1, optiondict["glmderivs"] + 1):
+                    for thederiv in range(1, optiondict["regressderivs"] + 1):
                         maplist += [
                             (
                                 fitcoeff[:, thederiv],
@@ -3995,14 +3873,14 @@ def rapidtide_main(argparsingfunc):
                 else:
                     maplist += [
                         (
-                            fitcoeff[:, : optiondict["glmderivs"] + 1],
+                            fitcoeff[:, : optiondict["regressderivs"] + 1],
                             "lfofilterCoeff",
                             "map",
                             None,
                             "Fit coefficient",
                         ),
                         (
-                            fitNorm[:, : optiondict["glmderivs"] + 1],
+                            fitNorm[:, : optiondict["regressderivs"] + 1],
                             "lfofilterNorm",
                             "map",
                             None,
@@ -4033,15 +3911,15 @@ def rapidtide_main(argparsingfunc):
                     "Percentage of inband variance attributable to CVR regressor",
                 ),
             ]
-            if optiondict["savenormalglmfiles"]:
+            if optiondict["savenormalsLFOfiltfiles"]:
                 maplist = [
-                    (rvalue, "CVRR", "map", None, "R value of the GLM fit"),
+                    (rvalue, "CVRR", "map", None, "R value of the sLFO fit"),
                     (
                         r2value,
                         "CVRR2",
                         "map",
                         None,
-                        "Squared R value of the GLM fit (proportion of variance explained)",
+                        "Squared R value of the sLFO fit (proportion of variance explained)",
                     ),
                     (
                         fitcoeff,
@@ -4064,7 +3942,70 @@ def rapidtide_main(argparsingfunc):
             rt_floattype=rt_floattype,
             cifti_hdr=cifti_hdr,
         )
-        del glmmean
+
+        if optiondict["refinedelay"] and False:
+            # 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,
+                fitmask,
+                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"],
+                mp_chunksize=optiondict["mp_chunksize"],
+                showprogressbar=optiondict["showprogressbar"],
+                alwaysmultiproc=optiondict["alwaysmultiproc"],
+                memprofile=optiondict["memprofile"],
+                debug=optiondict["debug"],
+            )
+
+            maplist = [
+                (rvalue, "maxcorralt", "map", None, "R value of the inband sLFO fit, with sign"),
+            ]
+
+            tide_io.savemaplist(
+                outputname,
+                maplist,
+                validvoxels,
+                nativespaceshape,
+                theheader,
+                bidsbasedict,
+                textio=optiondict["textio"],
+                fileiscifti=fileiscifti,
+                rt_floattype=rt_floattype,
+                cifti_hdr=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
@@ -4073,7 +4014,7 @@ def rapidtide_main(argparsingfunc):
         del finalvariance
         del varchange
         if optiondict["sharedmem"]:
-            tide_util.cleanup_shm(glmmean_shm)
+            tide_util.cleanup_shm(sLFOfitmean_shm)
             tide_util.cleanup_shm(rvalue_shm)
             tide_util.cleanup_shm(r2value_shm)
             tide_util.cleanup_shm(fitcoeff_shm)
@@ -4118,7 +4059,7 @@ def rapidtide_main(argparsingfunc):
                     lagstrengths[voxel],
                     sigfit,
                     neglogpmax=neglogpmax,
-                    debug=optiondict["focaldebug"],
+                    debug=optiondict["debug"],
                 )
             masklist += [
                 (
@@ -4147,6 +4088,7 @@ def rapidtide_main(argparsingfunc):
     if (optiondict["passes"] > 1 or optiondict["globalpreselect"]) and optiondict[
         "refinestopreason"
     ] != "emptymask":
+        refinemask = theRegressorRefiner.getrefinemask()
         if optiondict["globalpreselect"]:
             masklist = [
                 (
@@ -4253,8 +4195,10 @@ def rapidtide_main(argparsingfunc):
         cifti_hdr = None
 
     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],
@@ -4264,7 +4208,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],
@@ -4279,11 +4223,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,
@@ -4291,8 +4235,8 @@ def rapidtide_main(argparsingfunc):
                 ),
             ]
 
-    if optiondict["doglmfilt"]:
-        if optiondict["saveminimumglmfiles"]:
+    if optiondict["dolinfitfilt"]:
+        if optiondict["saveminimumsLFOfiltfiles"]:
             maplist += [
                 (
                     filtereddata,
@@ -4351,16 +4295,8 @@ def rapidtide_main(argparsingfunc):
 
     # clean up
     if optiondict["passes"] > 1:
-        del paddedshiftedtcs
-        del paddedweights
-        del shiftedtcs
-        del weights
-        if optiondict["sharedmem"]:
-            tide_util.cleanup_shm(paddedshiftedtcs_shm)
-            tide_util.cleanup_shm(paddedweights_shm)
-            tide_util.cleanup_shm(shiftedtcs_shm)
-            tide_util.cleanup_shm(weights_shm)
-    if optiondict["doglmfilt"]:
+        theRegressorRefiner.cleanup()
+    if optiondict["dolinfitfilt"]:
         del lagtc
         del filtereddata
         del movingsignal