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

rapidtide/workflows/{retroglm.py → retroregress.py}

@@ -34,9 +34,10 @@ import rapidtide.refinedelay as tide_refinedelay
 import rapidtide.resample as tide_resample
 import rapidtide.stats as tide_stats
 import rapidtide.util as tide_util
-import rapidtide.workflows.glmfrommaps as tide_glmfrommaps
 import rapidtide.workflows.parser_funcs as pf
+import rapidtide.workflows.regressfrommaps as tide_regressfrommaps
 
+from .rapidtide_parser import DEFAULT_REGRESSIONFILTDERIVS
 from .utils import setup_logger
 
 
@@ -51,12 +52,13 @@ LGR = logging.getLogger(__name__)
 ErrorLGR = logging.getLogger("ERROR")
 TimingLGR = logging.getLogger("TIMING")
 
-DEFAULT_GLMDERIVS = 0
+DEFAULT_REGRESSIONFILTDERIVS = 0
 DEFAULT_PATCHTHRESH = 3.0
 DEFAULT_REFINEDELAYMINDELAY = -5.0
 DEFAULT_REFINEDELAYMAXDELAY = 5.0
 DEFAULT_REFINEDELAYNUMPOINTS = 501
 DEFAULT_DELAYOFFSETSPATIALFILT = -1
+DEFAULT_REFINEREGRESSDERIVS = 1
 
 
 def _get_parser():
@@ -64,8 +66,8 @@ def _get_parser():
     Argument parser for glmfilt
     """
     parser = argparse.ArgumentParser(
-        prog="retroglm",
-        description="Do the rapidtide GLM filtering using the maps generated from a previous analysis.",
+        prog="retroregress",
+        description="Do the rapidtide sLFO filtering using the maps generated from a previous analysis.",
         allow_abbrev=False,
     )
 
@@ -88,15 +90,15 @@ def _get_parser():
         default=None,
     )
     parser.add_argument(
-        "--glmderivs",
-        dest="glmderivs",
+        "--regressderivs",
+        dest="regressderivs",
         action="store",
-        type=int,
+        type=lambda x: pf.is_int(parser, x, minval=0),
         metavar="NDERIVS",
         help=(
-            f"When doing final GLM, include derivatives up to NDERIVS order. Default is {DEFAULT_GLMDERIVS}"
+            f"When doing final GLM, include derivatives up to NDERIVS order. Default is {DEFAULT_REGRESSIONFILTDERIVS}"
         ),
-        default=DEFAULT_GLMDERIVS,
+        default=DEFAULT_REGRESSIONFILTDERIVS,
     )
     parser.add_argument(
         "--nprocs",
@@ -115,7 +117,7 @@ def _get_parser():
         "--numskip",
         dest="numskip",
         action="store",
-        type=int,
+        type=lambda x: pf.is_int(parser, x, minval=0),
         metavar="NUMSKIP",
         help=("Skip NUMSKIP points at the beginning of the fmri file."),
         default=0,
@@ -128,7 +130,7 @@ def _get_parser():
         choices=["min", "less", "normal", "more", "max"],
         help=(
             "The level of file output produced.  'min' produces only absolutely essential files, 'less' adds in "
-            "the GLM filtered data (rather than just filter efficacy metrics), 'normal' saves what you "
+            "the sLFO filtered data (rather than just filter efficacy metrics), 'normal' saves what you "
             "would typically want around for interactive data exploration, "
             "'more' adds files that are sometimes useful, and 'max' outputs anything you might possibly want. "
             "Selecting 'max' will produce ~3x your input datafile size as output.  "
@@ -170,7 +172,7 @@ def _get_parser():
         "--nofilterwithrefineddelay",
         dest="filterwithrefineddelay",
         action="store_false",
-        help=("Do not use the refined delay in GLM filter."),
+        help=("Do not use the refined delay in sLFO filter."),
         default=True,
     )
     parser.add_argument(
@@ -213,11 +215,26 @@ def _get_parser():
         help=("Output lots of helpful information on a limited subset of operations."),
         default=False,
     )
+    experimental = parser.add_argument_group(
+        "Experimental options (not fully tested, or not tested at all, may not work).  Beware!"
+    )
+    experimental.add_argument(
+        "--refineregressderivs",
+        dest="refineregressderivs",
+        action="store",
+        type=lambda x: pf.is_int(parser, x, minval=1),
+        metavar="NDERIVS",
+        help=(
+            f"When doing GLM for delay refinement, include derivatives up to NDERIVS order. Must be 1 or more.  "
+            f"Default is {DEFAULT_REFINEREGRESSDERIVS}"
+        ),
+        default=DEFAULT_REFINEREGRESSDERIVS,
+    )
 
     return parser
 
 
-def retroglm(args):
+def retroregress(args):
     # get the pid of the parent process
     args.pid = os.getpid()
 
@@ -242,7 +259,7 @@ def retroglm(args):
         debug=args.debug,
     )
     TimingLGR.info("Start")
-    LGR.info(f"starting retroglm")
+    LGR.info(f"starting retroregress")
 
     # set some global values
     args.mindelay = DEFAULT_REFINEDELAYMINDELAY
@@ -250,30 +267,30 @@ def retroglm(args):
     args.numpoints = DEFAULT_REFINEDELAYNUMPOINTS
 
     if args.outputlevel == "min":
-        args.saveminimumglmfiles = False
-        args.savenormalglmfiles = False
+        args.saveminimumsLFOfiltfiles = False
+        args.savenormalsLFOfiltfiles = False
         args.savemovingsignal = False
-        args.saveallglmfiles = False
+        args.saveallsLFOfiltfiles = False
     elif args.outputlevel == "less":
-        args.saveminimumglmfiles = True
-        args.savenormalglmfiles = False
+        args.saveminimumsLFOfiltfiles = True
+        args.savenormalsLFOfiltfiles = False
         args.savemovingsignal = False
-        args.saveallglmfiles = False
+        args.saveallsLFOfiltfiles = False
     elif args.outputlevel == "normal":
-        args.saveminimumglmfiles = True
-        args.savenormalglmfiles = True
+        args.saveminimumsLFOfiltfiles = True
+        args.savenormalsLFOfiltfiles = True
         args.savemovingsignal = False
-        args.saveallglmfiles = False
+        args.saveallsLFOfiltfiles = False
     elif args.outputlevel == "more":
-        args.saveminimumglmfiles = True
-        args.savenormalglmfiles = True
+        args.saveminimumsLFOfiltfiles = True
+        args.savenormalsLFOfiltfiles = True
         args.savemovingsignal = True
-        args.saveallglmfiles = False
+        args.saveallsLFOfiltfiles = False
     elif args.outputlevel == "max":
-        args.saveminimumglmfiles = True
-        args.savenormalglmfiles = True
+        args.saveminimumsLFOfiltfiles = True
+        args.savenormalsLFOfiltfiles = True
         args.savemovingsignal = True
-        args.saveallglmfiles = True
+        args.saveallsLFOfiltfiles = True
     else:
         print(f"illegal output level {args['outputlevel']}")
         sys.exit()
@@ -288,12 +305,25 @@ def retroglm(args):
     else:
         usesharedmem = True
 
-    # read the runoptions file
+    # read the runoptions file, update if necessary
     print("reading runoptions")
     runoptionsfile = f"{args.datafileroot}_desc-runoptions_info"
     therunoptions = tide_io.readoptionsfile(runoptionsfile)
+    sublist = (
+        ("retroglmcompatible", "retroregresscompatible"),
+        ("glmthreshval", "regressfiltthreshval"),
+    )
+    therunoptions["singleproc_regressionfilt"] = False
+    therunoptions["nprocs_regressionfilt"] = args.nprocs
+    for subpair in sublist:
+        try:
+            therunoptions[subpair[1]] = therunoptions[subpair[0]]
+            print(f"substituting {subpair[1]} for {subpair[0]} in runoptions")
+        except KeyError:
+            pass
+
     try:
-        candoretroglm = therunoptions["retroglmcompatible"]
+        candoretroregress = therunoptions["retroregresscompatible"]
     except KeyError:
         print(
             f"based on {runoptionsfile}, this rapidtide dataset does not support retrospective GLM calculation"
@@ -314,7 +344,7 @@ def retroglm(args):
     else:
         rt_outfloattype = "float32"
         rt_outfloatset = np.float32
-    therunoptions["saveminimumglmfiles"] = args.saveminimumglmfiles
+    therunoptions["saveminimumsLFOfiltfiles"] = args.saveminimumsLFOfiltfiles
 
     # read the fmri input files
     print("reading fmrifile")
@@ -347,7 +377,7 @@ def retroglm(args):
     if not tide_io.checkspacematch(fmri_header, procmask_header):
         raise ValueError("procmask dimensions do not match fmri dimensions")
     procmask_spacebytime = procmask.reshape((numspatiallocs))
-    if args.debug or args.focaldebug:
+    if args.debug:
         print(f"{procmask_spacebytime.shape=}")
         print(f"{tide_stats.getmasksize(procmask_spacebytime)=}")
 
@@ -364,7 +394,7 @@ def retroglm(args):
     if not tide_io.checkspacematch(fmri_header, corrmask_header):
         raise ValueError("corrmask dimensions do not match fmri dimensions")
     corrmask_spacebytime = corrmask.reshape((numspatiallocs))
-    if args.debug or args.focaldebug:
+    if args.debug:
         print(f"{corrmask_spacebytime.shape=}")
         print(f"{tide_stats.getmasksize(corrmask_spacebytime)=}")
 
@@ -426,19 +456,19 @@ def retroglm(args):
     print("figuring out valid voxels")
     validvoxels = np.where(procmask_spacebytime > 0)[0]
     numvalidspatiallocs = np.shape(validvoxels)[0]
-    if args.debug or args.focaldebug:
+    if args.debug:
         print(f"{numvalidspatiallocs=}")
     internalvalidspaceshape = numvalidspatiallocs
     if args.refinedelay:
-        derivaxissize = np.max([2, args.glmderivs + 1])
+        derivaxissize = np.max([args.refineregressderivs + 1, args.regressderivs + 1])
     else:
-        derivaxissize = args.glmderivs + 1
+        derivaxissize = args.regressderivs + 1
     internalvalidspaceshapederivs = (
         internalvalidspaceshape,
         derivaxissize,
     )
     internalvalidfmrishape = (numvalidspatiallocs, np.shape(initial_fmri_x)[0])
-    if args.debug or args.focaldebug:
+    if args.debug:
         print(f"validvoxels shape = {numvalidspatiallocs}")
         print(f"internalvalidfmrishape shape = {internalvalidfmrishape}")
 
@@ -454,7 +484,9 @@ def retroglm(args):
     if usesharedmem:
         if args.debug:
             print("allocating shared memory")
-        glmmean, glmmean_shm = tide_util.allocshared(internalvalidspaceshape, rt_outfloatset)
+        sLFOfitmean, sLFOfitmean_shm = tide_util.allocshared(
+            internalvalidspaceshape, rt_outfloatset
+        )
         rvalue, rvalue_shm = tide_util.allocshared(internalvalidspaceshape, rt_outfloatset)
         r2value, r2value_shm = tide_util.allocshared(internalvalidspaceshape, rt_outfloatset)
         fitNorm, fitNorm_shm = tide_util.allocshared(internalvalidspaceshapederivs, rt_outfloatset)
@@ -472,7 +504,7 @@ def retroglm(args):
     else:
         if args.debug:
             print("allocating memory")
-        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)
@@ -483,7 +515,7 @@ def retroglm(args):
         ramlocation = "locally"
 
     totalbytes = (
-        glmmean.nbytes
+        sLFOfitmean.nbytes
         + rvalue.nbytes
         + r2value.nbytes
         + fitNorm.nbytes
@@ -502,12 +534,13 @@ def retroglm(args):
         print(f"{outputname=}")
     oversamptr = fmritr / oversampfactor
     try:
-        threshval = therunoptions["glmthreshval"]
+        threshval = therunoptions["regressfiltthreshval"]
     except KeyError:
         threshval = 0.0
+        therunoptions["regressfiltthreshval"] = threshval
     mode = "glm"
 
-    if args.debug or args.focaldebug:
+    if args.debug:
         print(f"{validvoxels.shape=}")
         np.savetxt(f"{outputname}_validvoxels.txt", validvoxels)
 
@@ -539,7 +572,7 @@ def retroglm(args):
                 "inputdata",
                 "bold",
                 None,
-                "fMRI data that will be subjected to GLM filtering",
+                "fMRI data that will be subjected to sLFO filtering",
             ),
         ]
         tide_io.savemaplist(
@@ -566,7 +599,7 @@ def retroglm(args):
             args.delayoffsetgausssigma = np.mean([xdim, ydim, slicedim]) / 2.0
 
         TimingLGR.info("Refinement calibration start")
-        glmderivratios = tide_refinedelay.getderivratios(
+        regressderivratios, regressrvalues = tide_refinedelay.getderivratios(
             fmri_data_valid,
             validvoxels,
             initial_fmri_x,
@@ -576,57 +609,99 @@ def retroglm(args):
             mode,
             outputname,
             oversamptr,
-            glmmean,
+            sLFOfitmean,
             rvalue,
             r2value,
-            fitNorm[:, :2],
-            fitcoeff[:, :2],
+            fitNorm[:, : (args.refineregressderivs + 1)],
+            fitcoeff[:, : (args.refineregressderivs + 1)],
             movingsignal,
             lagtc,
             filtereddata,
             LGR,
             TimingLGR,
             therunoptions,
+            regressderivs=args.refineregressderivs,
             debug=args.debug,
         )
 
-        medfiltglmderivratios, filteredglmderivratios, delayoffsetMAD = (
-            tide_refinedelay.filterderivratios(
-                glmderivratios,
-                (xsize, ysize, numslices),
-                validvoxels,
-                (xdim, ydim, slicedim),
-                gausssigma=args.delayoffsetgausssigma,
-                patchthresh=args.delaypatchthresh,
-                fileiscifti=False,
-                textio=False,
-                rt_floattype=rt_floattype,
+        if args.refineregressderivs == 1:
+            medfiltregressderivratios, filteredregressderivratios, delayoffsetMAD = (
+                tide_refinedelay.filterderivratios(
+                    regressderivratios,
+                    (xsize, ysize, numslices),
+                    validvoxels,
+                    (xdim, ydim, slicedim),
+                    gausssigma=args.delayoffsetgausssigma,
+                    patchthresh=args.delaypatchthresh,
+                    fileiscifti=False,
+                    textio=False,
+                    rt_floattype=rt_floattype,
+                    debug=args.debug,
+                )
+            )
+
+            # find the mapping of glm ratios to delays
+            tide_refinedelay.trainratiotooffset(
+                genlagtc,
+                initial_fmri_x,
+                outputname,
+                args.outputlevel,
+                mindelay=args.mindelay,
+                maxdelay=args.maxdelay,
+                numpoints=args.numpoints,
                 debug=args.debug,
             )
-        )
+            TimingLGR.info("Refinement calibration end")
 
-        # find the mapping of glm ratios to delays
-        tide_refinedelay.trainratiotooffset(
-            genlagtc,
-            initial_fmri_x,
-            outputname,
-            args.outputlevel,
-            mindelay=args.mindelay,
-            maxdelay=args.maxdelay,
-            numpoints=args.numpoints,
-            debug=args.debug,
-        )
-        TimingLGR.info("Refinement calibration end")
-
-        # now calculate the delay offsets
-        TimingLGR.info("Calculating delay offsets")
-        delayoffset = filteredglmderivratios * 0.0
-        if args.focaldebug:
-            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"
+            # now calculate the delay offsets
+            TimingLGR.info("Calculating delay offsets")
+            delayoffset = np.zeros_like(filteredregressderivratios)
+            if args.debug:
+                print(f"calculating delayoffsets for {filteredregressderivratios.shape[0]} voxels")
+            for i in range(filteredregressderivratios.shape[0]):
+                delayoffset[i] = tide_refinedelay.ratiotodelay(filteredregressderivratios[i])
+                """delayoffset[i] = tide_refinedelay.coffstodelay(
+                    np.asarray([filteredregressderivratios[i]]),
+                    mindelay=args.mindelay,
+                    maxdelay=args.maxdelay,
+                )"""
+
+            refinedvoxelstoreport = filteredregressderivratios.shape[0]
+        else:
+            medfiltregressderivratios = np.zeros_like(regressderivratios)
+            filteredregressderivratios = np.zeros_like(regressderivratios)
+            delayoffsetMAD = np.zeros(args.refineregressderivs, dtype=float)
+            for i in range(args.refineregressderivs):
+                (
+                    medfiltregressderivratios[i, :],
+                    filteredregressderivratios[i, :],
+                    delayoffsetMAD[i],
+                ) = tide_refinedelay.filterderivratios(
+                    regressderivratios[i, :],
+                    (xsize, ysize, numslices),
+                    validvoxels,
+                    (xdim, ydim, slicedim),
+                    gausssigma=args.delayoffsetgausssigma,
+                    patchthresh=args.delaypatchthresh,
+                    fileiscifti=False,
+                    textio=False,
+                    rt_floattype=rt_floattype,
+                    debug=args.debug,
+                )
+
+            # now calculate the delay offsets
+            delayoffset = np.zeros_like(filteredregressderivratios[0, :])
+            if args.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=args.mindelay,
+                    maxdelay=args.maxdelay,
+                )
+            refinedvoxelstoreport = filteredregressderivratios.shape[1]
 
+        namesuffix = "_desc-delayoffset_hist"
         tide_stats.makeandsavehistogram(
             delayoffset,
             therunoptions["histlen"],
@@ -641,7 +716,7 @@ def retroglm(args):
         TimingLGR.info(
             "Delay offset calculation done",
             {
-                "message2": filteredglmderivratios.shape[0],
+                "message2": refinedvoxelstoreport,
                 "message3": "voxels",
             },
         )
@@ -649,16 +724,15 @@ def retroglm(args):
         #  Delay refinement end
         ####################################################
 
-    # initialrawvariance = tide_math.imagevariance(fmri_data_valid, None, 1.0 / fmritr)
     initialvariance = tide_math.imagevariance(fmri_data_valid, theprefilter, 1.0 / fmritr)
 
-    print("calling glmmfrommaps")
-    TimingLGR.info("Starting GLM filtering")
+    print("calling regressfrommaps")
+    TimingLGR.info("Starting sLFO filtering")
     if args.refinedelay and args.filterwithrefineddelay:
         lagstouse_valid = lagtimesrefined_valid
     else:
         lagstouse_valid = lagtimes_valid
-    voxelsprocessed_glm, regressorset, evset = tide_glmfrommaps.glmfrommaps(
+    voxelsprocessed_regressionfilt, regressorset, evset = tide_regressfrommaps.regressfrommaps(
         fmri_data_valid,
         validvoxels,
         initial_fmri_x,
@@ -668,29 +742,29 @@ def retroglm(args):
         mode,
         outputname,
         oversamptr,
-        glmmean,
+        sLFOfitmean,
         rvalue,
         r2value,
-        fitNorm[:, : args.glmderivs + 1],
-        fitcoeff[:, : args.glmderivs + 1],
+        fitNorm[:, : args.regressderivs + 1],
+        fitcoeff[:, : args.regressderivs + 1],
         movingsignal,
         lagtc,
         filtereddata,
         LGR,
         TimingLGR,
         threshval,
-        args.saveminimumglmfiles,
+        args.saveminimumsLFOfiltfiles,
         nprocs_makelaggedtcs=args.nprocs,
-        nprocs_glm=args.nprocs,
-        glmderivs=args.glmderivs,
+        nprocs_regressionfilt=args.nprocs,
+        regressderivs=args.regressderivs,
         showprogressbar=args.showprogressbar,
         debug=args.debug,
     )
-    print(f"filtered {voxelsprocessed_glm} voxels")
+    print(f"filtered {voxelsprocessed_regressionfilt} voxels")
     TimingLGR.info(
-        "GLM filtering done",
+        "sLFO filtering done",
         {
-            "message2": voxelsprocessed_glm,
+            "message2": voxelsprocessed_regressionfilt,
             "message3": "voxels",
         },
     )
@@ -753,7 +827,7 @@ def retroglm(args):
             #    "Change in total variance after filtering, in percent",
             # ),
         ]
-        if args.saveminimumglmfiles:
+        if args.saveminimumsLFOfiltfiles:
             maplist += [
                 (
                     r2value,
@@ -763,10 +837,10 @@ def retroglm(args):
                     "Squared R value of the GLM fit (proportion of variance explained)",
                 ),
             ]
-        if args.savenormalglmfiles:
+        if args.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 GLM fit"),
+                (sLFOfitmean, "lfofilterMean", "map", None, "Intercept from GLM fit"),
             ]
     else:
         maplist = [
@@ -774,7 +848,7 @@ def retroglm(args):
             (finalvariance, "lfofilterInbandVarianceAfter", "map", None),
             (varchange, "CVRVariance", "map", None),
         ]
-        if args.savenormalglmfiles:
+        if args.savenormalsLFOfiltfiles:
             maplist += [
                 (rvalue, "CVRR", "map", None),
                 (r2value, "CVRR2", "map", None),
@@ -794,13 +868,13 @@ def retroglm(args):
             (corrmask_valid, "corrfitREAD", "mask", None, "Correlation mask used for calculation"),
             (procmask_valid, "processedREAD", "mask", None, "Processed mask used for calculation"),
         ]
-    if args.savenormalglmfiles:
-        if args.glmderivs > 0 or args.refinedelay:
+    if args.savenormalsLFOfiltfiles:
+        if args.regressderivs > 0 or args.refinedelay:
             maplist += [
                 (fitcoeff[:, 0], "lfofilterCoeff", "map", None, "Fit coefficient"),
                 (fitNorm[:, 0], "lfofilterNorm", "map", None, "Normalized fit coefficient"),
             ]
-            for thederiv in range(1, args.glmderivs + 1):
+            for thederiv in range(1, args.regressderivs + 1):
                 maplist += [
                     (
                         fitcoeff[:, thederiv],
@@ -824,28 +898,56 @@ def retroglm(args):
             ]
 
     if args.refinedelay:
+        if args.refineregressderivs > 1:
+            for i in range(args.refineregressderivs):
+                maplist += [
+                    (
+                        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:
+            maplist += [
+                (
+                    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",
+                ),
+            ]
         maplist += [
-            (
-                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",
-            ),
             (
                 delayoffset,
                 "delayoffset",
@@ -876,7 +978,7 @@ def retroglm(args):
     # write the 4D maps
     theheader = copy.deepcopy(fmri_header)
     maplist = []
-    if args.saveminimumglmfiles:
+    if args.saveminimumsLFOfiltfiles:
         maplist = [
             (
                 filtereddata,
@@ -897,8 +999,8 @@ def retroglm(args):
             )
         ]
 
-    if args.saveallglmfiles:
-        if args.glmderivs > 0:
+    if args.saveallsLFOfiltfiles:
+        if args.regressderivs > 0:
             if args.debug:
                 print("going down the multiple EV path")
                 print(f"{regressorset[:, :, 0].shape=}")
@@ -911,7 +1013,7 @@ def retroglm(args):
                     "Shifted sLFO regressor to filter",
                 ),
             ]
-            for thederiv in range(1, args.glmderivs + 1):
+            for thederiv in range(1, args.regressderivs + 1):
                 if args.debug:
                     print(f"{regressorset[:, :, thederiv].shape=}")
                 maplist += [
@@ -973,7 +1075,7 @@ def retroglm(args):
             )
         TimingLGR.info("Filtering for maxcorralt calculation complete")
         TimingLGR.info("GLM for maxcorralt calculation start")
-        voxelsprocessed_glm, regressorset, evset = tide_glmfrommaps.glmfrommaps(
+        voxelsprocessed_regressionfilt, regressorset, evset = tide_regressfrommaps.regressfrommaps(
             fmri_data_valid,
             validvoxels,
             initial_fmri_x,
@@ -983,28 +1085,28 @@ def retroglm(args):
             mode,
             outputname,
             oversamptr,
-            glmmean,
+            sLFOfitmean,
             rvalue,
             r2value,
-            fitNorm[:, : args.glmderivs + 1],
-            fitcoeff[:, : args.glmderivs + 1],
+            fitNorm[:, : args.regressderivs + 1],
+            fitcoeff[:, : args.regressderivs + 1],
             movingsignal,
             lagtc,
             filtereddata,
             LGR,
             TimingLGR,
             threshval,
-            args.saveminimumglmfiles,
+            args.saveminimumsLFOfiltfiles,
             nprocs_makelaggedtcs=args.nprocs,
-            nprocs_glm=args.nprocs,
-            glmderivs=args.glmderivs,
+            nprocs_regressionfilt=args.nprocs,
+            regressderivs=args.regressderivs,
             showprogressbar=args.showprogressbar,
             debug=args.debug,
         )
         TimingLGR.info(
             "GLM for maxcorralt calculation done",
             {
-                "message2": voxelsprocessed_glm,
+                "message2": voxelsprocessed_regressionfilt,
                 "message3": "voxels",
             },
         )
@@ -1059,15 +1161,15 @@ def retroglm(args):
     # read the runoptions file
     print("writing runoptions")
     if args.refinedelay:
-        therunoptions["retroglm_delayoffsetMAD"] = delayoffsetMAD
-    therunoptions["retroglm_runtime"] = time.strftime(
+        therunoptions["retroregress_delayoffsetMAD"] = delayoffsetMAD
+    therunoptions["retroregress_runtime"] = time.strftime(
         "%a, %d %b %Y %H:%M:%S %Z", time.localtime(time.time())
     )
 
     # clean up shared memory
     if usesharedmem:
         TimingLGR.info("Shared memory cleanup start")
-        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(fitNorm_shm)
@@ -1075,7 +1177,7 @@ def retroglm(args):
         tide_util.cleanup_shm(movingsignal_shm)
         tide_util.cleanup_shm(lagtc_shm)
         tide_util.cleanup_shm(filtereddata_shm)
-        TimingLGR.info("Shared memory cleanup complete")
+    TimingLGR.info("Shared memory cleanup complete")
 
     # shut down logging
     TimingLGR.info("Done")
@@ -1110,7 +1212,7 @@ def retroglm(args):
 
 def process_args(inputargs=None):
     """
-    Compile arguments for retroglm workflow.
+    Compile arguments for retroregress workflow.
     """
     args, argstowrite = pf.setargs(_get_parser, inputargs=inputargs)
     return args