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

rapidtide/{glmpass.py → linfitfiltpass.py}

@@ -17,6 +17,7 @@
 #
 #
 import numpy as np
+from scipy.special import factorial
 from tqdm import tqdm
 
 import rapidtide.filter as tide_filt
@@ -25,7 +26,9 @@ import rapidtide.miscmath as tide_math
 import rapidtide.multiproc as tide_multiproc
 
 
-def _procOneGLMItem(vox, theevs, thedata, rt_floatset=np.float64, rt_floattype="float64"):
+def _procOneRegressionFitItem(
+    vox, theevs, thedata, rt_floatset=np.float64, rt_floattype="float64"
+):
     # NOTE: if theevs is 2D, dimension 0 is number of points, dimension 1 is number of evs
     thefit, R2 = tide_fit.mlregress(theevs, thedata)
     if theevs.ndim > 1:
@@ -74,7 +77,7 @@ def _procOneGLMItem(vox, theevs, thedata, rt_floatset=np.float64, rt_floattype="
         )
 
 
-def glmpass(
+def linfitfiltpass(
     numprocitems,
     fmri_data,
     threshval,
@@ -88,7 +91,7 @@ def glmpass(
     filtereddata,
     nprocs=1,
     alwaysmultiproc=False,
-    confoundglm=False,
+    confoundregress=False,
     procbyvoxel=True,
     showprogressbar=True,
     mp_chunksize=1000,
@@ -131,9 +134,9 @@ def glmpass(
 
                     # process and send the data
                     if procbyvoxel:
-                        if confoundglm:
+                        if confoundregress:
                             outQ.put(
-                                _procOneGLMItem(
+                                _procOneRegressionFitItem(
                                     val,
                                     theevs,
                                     fmri_data[val, :],
@@ -143,7 +146,7 @@ def glmpass(
                             )
                         else:
                             outQ.put(
-                                _procOneGLMItem(
+                                _procOneRegressionFitItem(
                                     val,
                                     theevs[val, :],
                                     fmri_data[val, :],
@@ -152,9 +155,9 @@ def glmpass(
                                 )
                             )
                     else:
-                        if confoundglm:
+                        if confoundregress:
                             outQ.put(
-                                _procOneGLMItem(
+                                _procOneRegressionFitItem(
                                     val,
                                     theevs,
                                     fmri_data[:, val],
@@ -164,7 +167,7 @@ def glmpass(
                             )
                         else:
                             outQ.put(
-                                _procOneGLMItem(
+                                _procOneRegressionFitItem(
                                     val,
                                     theevs[:, val],
                                     fmri_data[:, val],
@@ -190,7 +193,7 @@ def glmpass(
         # unpack the data
         itemstotal = 0
         if procbyvoxel:
-            if confoundglm:
+            if confoundregress:
                 for voxel in data_out:
                     r2value[voxel[0]] = voxel[3]
                     filtereddata[voxel[0], :] = voxel[7]
@@ -210,7 +213,7 @@ def glmpass(
                     filtereddata[voxel[0], :] = voxel[7]
                     itemstotal += 1
         else:
-            if confoundglm:
+            if confoundregress:
                 for timepoint in data_out:
                     r2value[timepoint[0]] = timepoint[3]
                     filtereddata[:, timepoint[0]] = timepoint[7]
@@ -242,7 +245,7 @@ def glmpass(
             ):
                 thedata = fmri_data[vox, :].copy()
                 if (themask is None) or (themask[vox] > 0):
-                    if confoundglm:
+                    if confoundregress:
                         (
                             dummy,
                             dummy,
@@ -252,7 +255,7 @@ def glmpass(
                             dummy,
                             dummy,
                             filtereddata[vox, :],
-                        ) = _procOneGLMItem(
+                        ) = _procOneRegressionFitItem(
                             vox,
                             theevs,
                             thedata,
@@ -269,7 +272,7 @@ def glmpass(
                             fitNorm[vox],
                             datatoremove[vox, :],
                             filtereddata[vox, :],
-                        ) = _procOneGLMItem(
+                        ) = _procOneRegressionFitItem(
                             vox,
                             theevs[vox, :],
                             thedata,
@@ -286,7 +289,7 @@ def glmpass(
             ):
                 thedata = fmri_data[:, timepoint].copy()
                 if (themask is None) or (themask[timepoint] > 0):
-                    if confoundglm:
+                    if confoundregress:
                         (
                             dummy,
                             dummy,
@@ -296,7 +299,7 @@ def glmpass(
                             dummy,
                             dummy,
                             filtereddata[:, timepoint],
-                        ) = _procOneGLMItem(
+                        ) = _procOneRegressionFitItem(
                             timepoint,
                             theevs,
                             thedata,
@@ -313,7 +316,7 @@ def glmpass(
                             fitNorm[timepoint],
                             datatoremove[:, timepoint],
                             filtereddata[:, timepoint],
-                        ) = _procOneGLMItem(
+                        ) = _procOneRegressionFitItem(
                             timepoint,
                             theevs[:, timepoint],
                             thedata,
@@ -350,11 +353,17 @@ def makevoxelspecificderivs(theevs, nderivs=1, debug=False):
     if nderivs == 0:
         thenewevs = theevs
     else:
+        taylorcoffs = np.zeros((nderivs + 1), dtype=np.float64)
+        taylorcoffs[0] = 1.0
         thenewevs = np.zeros((theevs.shape[0], theevs.shape[1], nderivs + 1), dtype=float)
+        for i in range(1, nderivs + 1):
+            taylorcoffs[i] = 1.0 / factorial(i)
         for thevoxel in range(0, theevs.shape[0]):
             thenewevs[thevoxel, :, 0] = theevs[thevoxel, :] * 1.0
             for i in range(1, nderivs + 1):
-                thenewevs[thevoxel, :, i] = np.gradient(thenewevs[thevoxel, :, i - 1])
+                thenewevs[thevoxel, :, i] = taylorcoffs[i] * np.gradient(
+                    thenewevs[thevoxel, :, i - 1]
+                )
     if debug:
         print(f"{nderivs=}")
         print(f"{thenewevs.shape=}")
@@ -418,7 +427,7 @@ def confoundregress(
     numprocitems = thedataarray.shape[0]
     filtereddata = thedataarray * 0.0
     r2value = np.zeros(numprocitems)
-    numfiltered = glmpass(
+    numfiltered = linfitfiltpass(
         numprocitems,
         thedataarray,
         None,
@@ -430,7 +439,7 @@ def confoundregress(
         None,
         None,
         filtereddata,
-        confoundglm=True,
+        confoundregress=True,
         nprocs=nprocs,
         showprogressbar=showprogressbar,
         procbyvoxel=True,

rapidtide/refinedelay.py

@@ -17,14 +17,14 @@
 #
 #
 import numpy as np
+import numpy.polynomial.polynomial as poly
 from scipy.interpolate import CubicSpline, UnivariateSpline
 from scipy.ndimage import median_filter
 from statsmodels.robust import mad
 
 import rapidtide.filter as tide_filt
 import rapidtide.io as tide_io
-import rapidtide.workflows.glmfrommaps as tide_glmfrommaps
-
+import rapidtide.workflows.regressfrommaps as tide_regressfrommaps
 
 global ratiotooffsetfunc, maplimits
 
@@ -40,11 +40,14 @@ def trainratiotooffset(
     timeaxis,
     outputname,
     outputlevel,
+    trainwidth=0.0,
+    trainstep=0.5,
     mindelay=-3.0,
     maxdelay=3.0,
     numpoints=501,
     smoothpts=3,
     edgepad=5,
+    regressderivs=1,
     debug=False,
 ):
     global ratiotooffsetfunc, maplimits
@@ -54,10 +57,13 @@ def trainratiotooffset(
         lagtcgenerator.info(prefix="\t")
         print("\ttimeaxis:", timeaxis)
         print("\toutputname:", outputname)
+        print("\ttrainwidth:", trainwidth)
+        print("\ttrainstep:", trainstep)
         print("\tmindelay:", mindelay)
         print("\tmaxdelay:", maxdelay)
         print("\tsmoothpts:", smoothpts)
         print("\tedgepad:", edgepad)
+        print("\tregressderivs:", regressderivs)
         print("\tlagtcgenerator:", lagtcgenerator)
     # make a delay map
     delaystep = (maxdelay - mindelay) / (numpoints - 1)
@@ -76,16 +82,13 @@ def trainratiotooffset(
         print(f"{maxdelay=}")
         print("lagtimes=", lagtimes)
 
-    # now make synthetic fMRI data
+    # set up for getratioderivs call
+    rt_floattype = "float64"
     internalvalidfmrishape = (numpoints + 2 * edgepad, timeaxis.shape[0])
     fmridata = np.zeros(internalvalidfmrishape, dtype=float)
     fmrimask = np.ones(numpoints + 2 * edgepad, dtype=float)
     validvoxels = np.where(fmrimask > 0)[0]
-    for i in range(numpoints + 2 * edgepad):
-        fmridata[i, :] = lagtcgenerator.yfromx(timeaxis - lagtimes[i])
-
-    rt_floattype = "float64"
-    glmmean = np.zeros(numpoints + 2 * edgepad, dtype=rt_floattype)
+    sLFOfitmean = np.zeros(numpoints + 2 * edgepad, dtype=rt_floattype)
     rvalue = np.zeros(numpoints + 2 * edgepad, dtype=rt_floattype)
     r2value = np.zeros(numpoints + 2 * edgepad, dtype=rt_floattype)
     fitNorm = np.zeros((numpoints + 2 * edgepad, 2), dtype=rt_floattype)
@@ -95,10 +98,10 @@ def trainratiotooffset(
     filtereddata = np.zeros(internalvalidfmrishape, dtype=rt_floattype)
     sampletime = timeaxis[1] - timeaxis[0]
     optiondict = {
-        "glmthreshval": 0.0,
-        "saveminimumglmfiles": False,
+        "regressfiltthreshval": 0.0,
+        "saveminimumsLFOfiltfiles": False,
         "nprocs_makelaggedtcs": 1,
-        "nprocs_glm": 1,
+        "nprocs_regressionfilt": 1,
         "mp_chunksize": 1000,
         "showprogressbar": False,
         "alwaysmultiproc": False,
@@ -108,7 +111,27 @@ def trainratiotooffset(
         "textio": False,
     }
 
-    glmderivratios = getderivratios(
+    if trainwidth > 0.0:
+        numsteps = int(trainwidth / trainstep)
+        numsteps += 1 - numsteps % 2  # force numsteps to be odd
+        numsteps = np.max((numsteps, 3))  # ensure at least 1 positive and 1 negative step
+        trainoffsets = (
+            np.linspace(0, numsteps * trainstep, numsteps, endpoint=True)
+            - (numsteps // 2) * trainstep
+        )
+    else:
+        trainoffsets = np.array([0.0], dtype=float)
+    if debug:
+        print("trainoffsets:", trainoffsets)
+
+    for i in range(len(trainoffsets)):
+        pass
+
+    # now make synthetic fMRI data
+    for i in range(numpoints + 2 * edgepad):
+        fmridata[i, :] = lagtcgenerator.yfromx(timeaxis - lagtimes[i])
+
+    regressderivratios, regressrvalues = getderivratios(
         fmridata,
         validvoxels,
         timeaxis,
@@ -118,7 +141,7 @@ def trainratiotooffset(
         "glm",
         "refinedelaytest",
         sampletime,
-        glmmean,
+        sLFOfitmean,
         rvalue,
         r2value,
         fitNorm[:, :2],
@@ -129,27 +152,41 @@ def trainratiotooffset(
         None,
         None,
         optiondict,
+        regressderivs=regressderivs,
         debug=debug,
     )
     if debug:
         print("before trimming")
-        print(f"{glmderivratios.shape=}")
+        print(f"{regressderivratios.shape=}")
         print(f"{lagtimes.shape=}")
-    smoothglmderivratios = tide_filt.unpadvec(
-        smooth(tide_filt.padvec(glmderivratios, padlen=20, padtype="constant"), smoothpts),
-        padlen=20,
-    )
-    glmderivratios = glmderivratios[edgepad:-edgepad]
-    smoothglmderivratios = smoothglmderivratios[edgepad:-edgepad]
+    if regressderivs == 1:
+        smoothregressderivratios = tide_filt.unpadvec(
+            smooth(tide_filt.padvec(regressderivratios, padlen=20, padtype="constant"), smoothpts),
+            padlen=20,
+        )
+        regressderivratios = regressderivratios[edgepad:-edgepad]
+        smoothregressderivratios = smoothregressderivratios[edgepad:-edgepad]
+    else:
+        smoothregressderivratios = np.zeros_like(regressderivratios)
+        for i in range(regressderivs):
+            smoothregressderivratios[i, :] = tide_filt.unpadvec(
+                smooth(
+                    tide_filt.padvec(regressderivratios[i, :], padlen=20, padtype="constant"),
+                    smoothpts,
+                ),
+                padlen=20,
+            )
+        regressderivratios = regressderivratios[:, edgepad:-edgepad]
+        smoothregressderivratios = smoothregressderivratios[:, edgepad:-edgepad]
     lagtimes = lagtimes[edgepad:-edgepad]
     if debug:
         print("after trimming")
-        print(f"{glmderivratios.shape=}")
-        print(f"{smoothglmderivratios.shape=}")
+        print(f"{regressderivratios.shape=}")
+        print(f"{smoothregressderivratios.shape=}")
         print(f"{lagtimes.shape=}")
 
     # make sure the mapping function is legal
-    xaxis = smoothglmderivratios[::-1]
+    xaxis = smoothregressderivratios[::-1]
     yaxis = lagtimes[::-1]
     midpoint = int(len(xaxis) // 2)
     lowerlim = midpoint + 0
@@ -164,16 +201,6 @@ def trainratiotooffset(
     maplimits = (xaxis[0], xaxis[-1])
 
     if outputlevel != "min":
-        """tide_io.writebidstsv(
-            f"{outputname}_desc-ratiotodelaymapping_timeseries",
-            np.stack((xaxis, yaxis)),
-            1.0,
-            columns=["smoothglmderivratio", "delay"],
-            extraheaderinfo={
-                "Description": "The ratio of sLFO derivative to the sLFO, and the corresponding delay offset"
-            },
-            append=False,
-        )"""
         resampaxis = np.linspace(xaxis[0], xaxis[-1], num=len(xaxis), endpoint=True)
         tide_io.writebidstsv(
             f"{outputname}_desc-ratiotodelayfunc_timeseries",
@@ -182,8 +209,12 @@ def trainratiotooffset(
             starttime=resampaxis[0],
             columns=["delay"],
             extraheaderinfo={
-                "Description": "The function mapping derivative ratio to delay"
+                "Description": "The function mapping derivative ratio to delay",
+                "minratio": f"{resampaxis[0]}",
+                "maxratio": f"{resampaxis[-1]}",
             },
+            xaxislabel="coefficientratio",
+            yaxislabel="time",
             append=False,
         )
 
@@ -198,6 +229,34 @@ def ratiotodelay(theratio):
         return ratiotooffsetfunc(theratio)
 
 
+def coffstodelay(thecoffs, mindelay=-3.0, maxdelay=3.0, debug=False):
+    justaone = np.array([1.0], dtype=thecoffs.dtype)
+    allcoffs = np.concatenate((justaone, thecoffs))
+    theroots = (poly.Polynomial(allcoffs, domain=(mindelay, maxdelay))).roots()
+    if theroots is None:
+        return 0.0
+    elif len(theroots) == 1:
+        return theroots[0].real
+    else:
+        candidates = []
+        for i in range(len(theroots)):
+            if np.isreal(theroots[i]) and (mindelay <= theroots[i] <= maxdelay):
+                if debug:
+                    print(f"keeping root {i} ({theroots[i]})")
+                candidates.append(theroots[i].real)
+            else:
+                if debug:
+                    print(f"discarding root {i} ({theroots[i]})")
+                else:
+                    pass
+        if len(candidates) > 0:
+            chosen = candidates[np.argmin(np.fabs(np.array(candidates)))].real
+            if debug:
+                print(f"{theroots=}, {candidates=}, {chosen=}")
+            return chosen
+        return 0.0
+
+
 def getderivratios(
     fmri_data_valid,
     validvoxels,
@@ -208,7 +267,7 @@ def getderivratios(
     mode,
     outputname,
     oversamptr,
-    glmmean,
+    sLFOfitmean,
     rvalue,
     r2value,
     fitNorm,
@@ -219,23 +278,34 @@ def getderivratios(
     LGR,
     TimingLGR,
     optiondict,
+    regressderivs=1,
+    starttr=None,
+    endtr=None,
     debug=False,
 ):
+    if starttr is None:
+        starttr = 0
+    if endtr is None:
+        endtr = fmri_data_valid.shape[1]
     if debug:
         print("getderivratios")
         print(f"{fitNorm.shape=}")
         print(f"{fitcoeff.shape=}")
-    voxelsprocessed_glm, regressorset, evset = tide_glmfrommaps.glmfrommaps(
-        fmri_data_valid,
+        print(f"{regressderivs=}")
+        print(f"{starttr=}")
+        print(f"{endtr=}")
+
+    voxelsprocessed_regressionfilt, regressorset, evset = tide_regressfrommaps.regressfrommaps(
+        fmri_data_valid[:, starttr:endtr],
         validvoxels,
-        initial_fmri_x,
+        initial_fmri_x[starttr:endtr],
         lagtimes,
         fitmask,
         genlagtc,
         mode,
         outputname,
         oversamptr,
-        glmmean,
+        sLFOfitmean,
         rvalue,
         r2value,
         fitNorm,
@@ -245,11 +315,11 @@ def getderivratios(
         filtereddata,
         LGR,
         TimingLGR,
-        optiondict["glmthreshval"],
-        optiondict["saveminimumglmfiles"],
+        optiondict["regressfiltthreshval"],
+        optiondict["saveminimumsLFOfiltfiles"],
         nprocs_makelaggedtcs=optiondict["nprocs_makelaggedtcs"],
-        nprocs_glm=optiondict["nprocs_glm"],
-        glmderivs=1,
+        nprocs_regressionfilt=optiondict["nprocs_regressionfilt"],
+        regressderivs=regressderivs,
         mp_chunksize=optiondict["mp_chunksize"],
         showprogressbar=optiondict["showprogressbar"],
         alwaysmultiproc=optiondict["alwaysmultiproc"],
@@ -258,13 +328,19 @@ def getderivratios(
     )
 
     # calculate the ratio of the first derivative to the main regressor
-    glmderivratio = np.nan_to_num(fitcoeff[:, 1] / fitcoeff[:, 0])
+    if regressderivs == 1:
+        regressderivratios = np.nan_to_num(fitcoeff[:, 1] / fitcoeff[:, 0])
+    else:
+        numvoxels = fitcoeff.shape[0]
+        regressderivratios = np.zeros((regressderivs, numvoxels), dtype=np.float64)
+        for i in range(regressderivs):
+            regressderivratios[i, :] = np.nan_to_num(fitcoeff[:, i + 1] / fitcoeff[:, 0])
 
-    return glmderivratio
+    return regressderivratios, rvalue
 
 
 def filterderivratios(
-    glmderivratio,
+    regressderivratios,
     nativespaceshape,
     validvoxels,
     thedims,
@@ -283,32 +359,34 @@ def filterderivratios(
         print(f"\t{nativespaceshape=}")
 
     # filter the ratio to find weird values
-    themad = mad(glmderivratio).astype(np.float64)
-    print(f"MAD of GLM derivative ratios = {themad}")
+    themad = mad(regressderivratios).astype(np.float64)
+    print(f"MAD of regression fit derivative ratios = {themad}")
     outmaparray, internalspaceshape = tide_io.makedestarray(
         nativespaceshape,
         textio=textio,
         fileiscifti=fileiscifti,
         rt_floattype=rt_floattype,
     )
-    mappedglmderivratio = tide_io.populatemap(
-        glmderivratio,
+    mappedregressderivratios = tide_io.populatemap(
+        regressderivratios,
         internalspaceshape,
         validvoxels,
         outmaparray,
         debug=debug,
     )
     if textio or fileiscifti:
-        medfilt = glmderivratio
-        filteredarray = glmderivratio
+        medfilt = regressderivratios
+        filteredarray = regressderivratios
     else:
         if debug:
-            print(f"{glmderivratio.shape=}, {mappedglmderivratio.shape=}")
+            print(f"{regressderivratios.shape=}, {mappedregressderivratios.shape=}")
         medfilt = median_filter(
-            mappedglmderivratio.reshape(nativespaceshape), size=(3, 3, 3)
+            mappedregressderivratios.reshape(nativespaceshape), size=(3, 3, 3)
         ).reshape(internalspaceshape)[validvoxels]
         filteredarray = np.where(
-            np.fabs(glmderivratio - medfilt) > patchthresh * themad, medfilt, glmderivratio
+            np.fabs(regressderivratios - medfilt) > patchthresh * themad,
+            medfilt,
+            regressderivratios,
         )
         if gausssigma > 0:
             mappedfilteredarray = tide_io.populatemap(

rapidtide/refineregressor.py

@@ -151,6 +151,9 @@ def alignvoxels(
     """
     inputshape = np.shape(fmridata)
     volumetotal = np.sum(lagmask)
+    if debug:
+        print("alignvoxels: {inputshape}")
+        print("volumetotal: {volumetotal}")
 
     # timeshift the valid voxels
     if nprocs > 1 or alwaysmultiproc:
@@ -253,6 +256,7 @@ def makerefinemask(
     bipolar=False,
     includemask=None,
     excludemask=None,
+    fixdelay=False,
     debug=False,
     rt_floatset=np.float64,
     rt_floattype="float64",
@@ -321,35 +325,45 @@ def makerefinemask(
         LGR.info(f"setting ampthresh to the {-100.0 * ampthresh}th percentile ({theampthresh})")
     else:
         theampthresh = ampthresh
+    if debug:
+        print(f"makerefinemask: {theampthresh=}")
     if bipolar:
         ampmask = np.where(np.fabs(lagstrengths) >= theampthresh, np.int16(1), np.int16(0))
     else:
         ampmask = np.where(lagstrengths >= theampthresh, np.int16(1), np.int16(0))
-    if lagmaskside == "upper":
-        delaymask = np.where(
-            (lagtimes - offsettime) > lagminthresh,
-            np.int16(1),
-            np.int16(0),
-        ) * np.where(
-            (lagtimes - offsettime) < lagmaxthresh,
-            np.int16(1),
-            np.int16(0),
-        )
-    elif lagmaskside == "lower":
-        delaymask = np.where(
-            (lagtimes - offsettime) < -lagminthresh,
-            np.int16(1),
-            np.int16(0),
-        ) * np.where(
-            (lagtimes - offsettime) > -lagmaxthresh,
-            np.int16(1),
-            np.int16(0),
-        )
+    if fixdelay:
+        delaymask = lagmask + 0
     else:
-        abslag = abs(lagtimes - offsettime)
-        delaymask = np.where(abslag > lagminthresh, np.int16(1), np.int16(0)) * np.where(
-            abslag < lagmaxthresh, np.int16(1), np.int16(0)
-        )
+        if lagmaskside == "upper":
+            delaymask = np.where(
+                (lagtimes - offsettime) > lagminthresh,
+                np.int16(1),
+                np.int16(0),
+            ) * np.where(
+                (lagtimes - offsettime) < lagmaxthresh,
+                np.int16(1),
+                np.int16(0),
+            )
+        elif lagmaskside == "lower":
+            delaymask = np.where(
+                (lagtimes - offsettime) < -lagminthresh,
+                np.int16(1),
+                np.int16(0),
+            ) * np.where(
+                (lagtimes - offsettime) > -lagmaxthresh,
+                np.int16(1),
+                np.int16(0),
+            )
+        else:
+            abslag = abs(lagtimes - offsettime)
+            delaymask = np.where(abslag > lagminthresh, np.int16(1), np.int16(0)) * np.where(
+                abslag < lagmaxthresh, np.int16(1), np.int16(0)
+            )
+        if debug:
+            print(f"makerefinemask: {lagmaskside=}")
+            print(f"makerefinemask: {lagminthresh=}")
+            print(f"makerefinemask: {lagmaxthresh=}")
+            print(f"makerefinemask: {offsettime=}")
     sigmamask = np.where(lagsigma < sigmathresh, np.int16(1), np.int16(0))
     locationmask = lagmask + 0
     if includemask is not None:

rapidtide/resample.py

@@ -328,6 +328,9 @@ class FastResampler:
             pl.legend(("input", "hires"))
             pl.show()
 
+    def getdata(self):
+        return self.timeaxis, self.timecourse, self.hires_x, self.hires_y, 1.0 / self.initstep
+
     def info(self, prefix=""):
         print(f"{prefix}{self.timeaxis=}")
         print(f"{prefix}{self.timecourse=}")

rapidtide/scripts/{retroglm.py → delayvar.py}

@@ -17,11 +17,11 @@
 #
 #
 import rapidtide.workflows.parser_funcs as pf
-import rapidtide.workflows.retroglm as theworkflow
+import rapidtide.workflows.delayvar as theworkflow
 
 
 def entrypoint():
-    pf.generic_init(theworkflow._get_parser, theworkflow.retroglm)
+    pf.generic_init(theworkflow._get_parser, theworkflow.delayvar)
 
 
 if __name__ == "__main__":

rapidtide/scripts/{glmfilt.py → linfitfilt.py}

@@ -16,11 +16,11 @@
 #   limitations under the License.
 #
 #
-import rapidtide.workflows.glmfilt as glmfilt_workflow
+import rapidtide.workflows.linfitfilt as linfitfilt_workflow
 
 
 def entrypoint():
-    glmfilt_workflow.main()
+    linfitfilt_workflow.main()
 
 
 if __name__ == "__main__":