rapidtide 3.0a12__py3-none-any.whl → 3.0a14__py3-none-any.whl

rapidtide/refinedelay.py

@@ -24,9 +24,9 @@ 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
+global ratiotooffsetfunc, funcoffsets, maplimits
 
 
 def smooth(y, box_pts):
@@ -40,33 +40,39 @@ def trainratiotooffset(
     timeaxis,
     outputname,
     outputlevel,
+    trainlagmin=0.0,
+    trainlagmax=0.0,
+    trainlagstep=0.5,
     mindelay=-3.0,
     maxdelay=3.0,
     numpoints=501,
     smoothpts=3,
     edgepad=5,
-    glmderivs=1,
+    regressderivs=1,
+    LGR=None,
+    TimingLGR=None,
+    verbose=False,
     debug=False,
 ):
-    global ratiotooffsetfunc, maplimits
+    global ratiotooffsetfunc, funcoffsets, maplimits
 
     if debug:
         print("ratiotooffsetfunc:")
         lagtcgenerator.info(prefix="\t")
         print("\ttimeaxis:", timeaxis)
         print("\toutputname:", outputname)
+        print("\ttrainlagmin:", trainlagmin)
+        print("\ttrainlagmax:", trainlagmax)
+        print("\ttrainlagstep:", trainlagstep)
         print("\tmindelay:", mindelay)
         print("\tmaxdelay:", maxdelay)
         print("\tsmoothpts:", smoothpts)
         print("\tedgepad:", edgepad)
-        print("\tglmderivs:", glmderivs)
+        print("\tregressderivs:", regressderivs)
         print("\tlagtcgenerator:", lagtcgenerator)
+
     # make a delay map
     delaystep = (maxdelay - mindelay) / (numpoints - 1)
-    if debug:
-        print(f"{delaystep=}")
-        print(f"{mindelay=}")
-        print(f"{maxdelay=}")
     lagtimes = np.linspace(
         mindelay - edgepad * delaystep,
         maxdelay + edgepad * delaystep,
@@ -76,18 +82,16 @@ def trainratiotooffset(
     if debug:
         print(f"{mindelay=}")
         print(f"{maxdelay=}")
+        print(f"{delaystep=}")
         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)
@@ -97,10 +101,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,
@@ -110,96 +114,204 @@ def trainratiotooffset(
         "textio": False,
     }
 
-    glmderivratios = getderivratios(
-        fmridata,
-        validvoxels,
-        timeaxis,
-        0.0 * lagtimes,
-        fmrimask,
-        lagtcgenerator,
-        "glm",
-        "refinedelaytest",
-        sampletime,
-        glmmean,
-        rvalue,
-        r2value,
-        fitNorm[:, :2],
-        fitcoeff[:, :2],
-        movingsignal,
-        lagtc,
-        filtereddata,
-        None,
-        None,
-        optiondict,
-        glmderivs=glmderivs,
-        debug=debug,
-    )
-    if debug:
-        print("before trimming")
-        print(f"{glmderivratios.shape=}")
-        print(f"{lagtimes.shape=}")
-    if glmderivs == 1:
-        smoothglmderivratios = tide_filt.unpadvec(
-            smooth(tide_filt.padvec(glmderivratios, padlen=20, padtype="constant"), smoothpts),
-            padlen=20,
+    if trainlagmax - trainlagmin > 0.0:
+        numnegoffsets = np.max((-int(np.round(trainlagmin / trainlagstep, 0)), 1))
+        numposoffsets = np.max((int(np.round(trainlagmax / trainlagstep, 0)), 1))
+        numoffsets = numnegoffsets + 1 + numposoffsets
+        trainoffsets = (
+            np.linspace(0, (numoffsets - 1) * trainlagstep, numoffsets, endpoint=True)
+            - numnegoffsets * trainlagstep
         )
-        glmderivratios = glmderivratios[edgepad:-edgepad]
-        smoothglmderivratios = smoothglmderivratios[edgepad:-edgepad]
     else:
-        smoothglmderivratios = np.zeros_like(glmderivratios)
-        for i in range(glmderivs):
-            smoothglmderivratios[i, :] = tide_filt.unpadvec(
+        trainoffsets = np.array([0.0], dtype=float)
+        numoffsets = 1
+    if debug:
+        print("trainoffsets:", trainoffsets)
+    allsmoothregressderivratios = np.zeros(
+        (numpoints + 2 * edgepad, numoffsets), dtype=rt_floattype
+    )
+    theEVs = np.zeros((numoffsets, timeaxis.shape[0]), dtype=float)
+
+    if verbose and (LGR is not None):
+        thisLGR = LGR
+        thisTimingLGR = TimingLGR
+    else:
+        thisLGR = None
+        thisTimingLGR = None
+
+    for whichoffset in range(numoffsets):
+        thisoffset = trainoffsets[whichoffset]
+
+        # now make synthetic fMRI data
+        for i in range(numpoints + 2 * edgepad):
+            fmridata[i, :] = lagtcgenerator.yfromx(timeaxis - lagtimes[i] + thisoffset)
+
+        theEVs[whichoffset, :] = lagtcgenerator.yfromx(timeaxis + thisoffset)
+
+        regressderivratios, regressrvalues = getderivratios(
+            fmridata,
+            validvoxels,
+            timeaxis + thisoffset,
+            0.0 * lagtimes,
+            fmrimask,
+            lagtcgenerator,
+            "glm",
+            "refinedelaytest",
+            sampletime,
+            sLFOfitmean,
+            rvalue,
+            r2value,
+            fitNorm[:, :2],
+            fitcoeff[:, :2],
+            movingsignal,
+            lagtc,
+            filtereddata,
+            thisLGR,
+            thisTimingLGR,
+            optiondict,
+            regressderivs=regressderivs,
+            debug=debug,
+        )
+        if debug:
+            print("before trimming")
+            print(f"{regressderivratios.shape=}")
+            print(f"{lagtimes.shape=}")
+        if regressderivs == 1:
+            smoothregressderivratios = tide_filt.unpadvec(
                 smooth(
-                    tide_filt.padvec(glmderivratios[i, :], padlen=20, padtype="constant"),
-                    smoothpts,
+                    tide_filt.padvec(regressderivratios, padlen=20, padtype="constant"), smoothpts
                 ),
                 padlen=20,
             )
-        glmderivratios = glmderivratios[:, edgepad:-edgepad]
-        smoothglmderivratios = smoothglmderivratios[:, edgepad:-edgepad]
+            # regressderivratios = regressderivratios[edgepad:-edgepad]
+            allsmoothregressderivratios[:, whichoffset] = smoothregressderivratios + 0.0
+        else:
+            smoothregressderivratios = np.zeros_like(regressderivratios)
+            for i in range(regressderivs):
+                allsmoothregressderivratios[i, :] = tide_filt.unpadvec(
+                    smooth(
+                        tide_filt.padvec(regressderivratios[i, :], padlen=20, padtype="constant"),
+                        smoothpts,
+                    ),
+                    padlen=20,
+                )
+            # regressderivratios = regressderivratios[:, edgepad:-edgepad]
+            allsmoothregressderivratios = smoothregressderivratios + 0.0
+
+    allsmoothregressderivratios = allsmoothregressderivratios[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"{allsmoothregressderivratios.shape=}")
         print(f"{lagtimes.shape=}")
 
-    # make sure the mapping function is legal
-    xaxis = smoothglmderivratios[::-1]
-    yaxis = lagtimes[::-1]
-    midpoint = int(len(xaxis) // 2)
-    lowerlim = midpoint + 0
-    while (lowerlim > 1) and xaxis[lowerlim] > xaxis[lowerlim - 1]:
-        lowerlim -= 1
-    upperlim = midpoint + 0
-    while (upperlim < len(xaxis) - 2) and xaxis[upperlim] < xaxis[upperlim + 1]:
-        upperlim += 1
-    xaxis = xaxis[lowerlim : upperlim + 1]
-    yaxis = yaxis[lowerlim : upperlim + 1]
-    ratiotooffsetfunc = CubicSpline(xaxis, yaxis)
+    # find the minimum legal limits of the mapping function
+    highestlowerlim = 0
+    lowestupperlim = numpoints
+    for whichoffset in range(numoffsets):
+        xaxis = allsmoothregressderivratios[::-1, whichoffset]
+        midpoint = int(len(xaxis) // 2)
+        lowerlim = midpoint + 0
+        while (lowerlim > 1) and xaxis[lowerlim] > xaxis[lowerlim - 1]:
+            lowerlim -= 1
+        upperlim = midpoint + 0
+        while (upperlim < len(xaxis) - 2) and xaxis[upperlim] < xaxis[upperlim + 1]:
+            upperlim += 1
+        if lowerlim > highestlowerlim:
+            highestlowerlim = lowerlim
+        if upperlim < lowestupperlim:
+            lowestupperlim = upperlim
+
+    ratiotooffsetfunc = []
+    funcoffsets = []
+    for whichoffset in range(numoffsets):
+        xaxis = allsmoothregressderivratios[::-1, whichoffset]
+        yaxis = lagtimes[::-1]
+        xaxis = xaxis[highestlowerlim : lowestupperlim + 1]
+        yaxis = yaxis[highestlowerlim : lowestupperlim + 1]
+        ratiotooffsetfunc.append(CubicSpline(xaxis, yaxis))
+        funcoffsets.append(trainoffsets[whichoffset] + 0.0)
     maplimits = (xaxis[0], xaxis[-1])
 
     if outputlevel != "min":
         resampaxis = np.linspace(xaxis[0], xaxis[-1], num=len(xaxis), endpoint=True)
+        outputfuncs = np.zeros((resampaxis.size, numoffsets), dtype=float)
+        colnames = []
+        for whichoffset in range(numoffsets):
+            colnames.append(f"{funcoffsets[whichoffset]}")
+            outputfuncs[:, whichoffset] = ratiotooffsetfunc[whichoffset](resampaxis)
+        if debug:
+            print(f"{colnames=}")
+            print(f"{outputfuncs.shape=}")
         tide_io.writebidstsv(
             f"{outputname}_desc-ratiotodelayfunc_timeseries",
-            ratiotooffsetfunc(resampaxis),
+            np.transpose(outputfuncs),
             1.0 / (resampaxis[1] - resampaxis[0]),
             starttime=resampaxis[0],
-            columns=["delay"],
-            extraheaderinfo={"Description": "The function mapping derivative ratio to delay"},
+            columns=colnames,
+            extraheaderinfo={
+                "Description": "The function mapping derivative ratio to delay",
+                "minratio": f"{resampaxis[0]}",
+                "maxratio": f"{resampaxis[-1]}",
+            },
+            xaxislabel="coefficientratio",
+            yaxislabel="time",
             append=False,
         )
+        if numoffsets > 1:
+            print(f"{theEVs.shape=}, {numoffsets=}, {(numoffsets>1)=}")
+            tide_io.writebidstsv(
+                f"{outputname}_desc-trainratioEV_timeseries",
+                theEVs,
+                1.0 / (timeaxis[1] - timeaxis[0]),
+                starttime=timeaxis[0],
+                columns=colnames,
+                extraheaderinfo={"Description": f"EVs used for each offset"},
+                append=False,
+            )
+
 
+def ratiotodelay(theratio, offset=0.0, debug=False):
+    global ratiotooffsetfunc, funcoffsets, maplimits
+
+    # find the closest calculated offset
+    closestindex = 0
+    for offsetindex in range(1, len(funcoffsets)):
+        if np.fabs(funcoffsets[offsetindex] - offset) < np.fabs(
+            funcoffsets[closestindex] - offset
+        ):
+            closestindex = offsetindex
+    closestoffset = funcoffsets[closestindex]
+    distance = np.fabs(funcoffsets[closestindex] - offset)
+    """if (maplimits[0] < theratio < maplimits[1]) and (
+        distance < (funcoffsets[1] - funcoffsets[0]) / 2
+    ):
+        return (
+            ratiotooffsetfunc[closestindex](theratio) + (offset - closestoffset),
+            closestoffset,
+        )
+    else:
+        return (
+            0.0,
+            closestoffset,
+        )"""
 
-def ratiotodelay(theratio):
-    global ratiotooffsetfunc, maplimits
     if theratio < maplimits[0]:
-        return ratiotooffsetfunc(maplimits[0])
+        return (
+            ratiotooffsetfunc[closestindex](maplimits[0]) + (offset - closestoffset),
+            closestoffset,
+        )
     elif theratio > maplimits[1]:
-        return ratiotooffsetfunc(maplimits[1])
+        return (
+            ratiotooffsetfunc[closestindex](maplimits[1]),
+            closestoffset,
+        )
     else:
-        return ratiotooffsetfunc(theratio)
+        return (
+            ratiotooffsetfunc[closestindex](theratio),
+            closestoffset,
+        )
 
 
 def coffstodelay(thecoffs, mindelay=-3.0, maxdelay=3.0, debug=False):
@@ -240,7 +352,7 @@ def getderivratios(
     mode,
     outputname,
     oversamptr,
-    glmmean,
+    sLFOfitmean,
     rvalue,
     r2value,
     fitNorm,
@@ -251,25 +363,34 @@ def getderivratios(
     LGR,
     TimingLGR,
     optiondict,
-    glmderivs=1,
+    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=}")
-        print(f"{glmderivs=}")
-    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,
@@ -279,11 +400,11 @@ def getderivratios(
         filtereddata,
         LGR,
         TimingLGR,
-        optiondict["glmthreshval"],
-        optiondict["saveminimumglmfiles"],
+        optiondict["regressfiltthreshval"],
+        False,
         nprocs_makelaggedtcs=optiondict["nprocs_makelaggedtcs"],
-        nprocs_glm=optiondict["nprocs_glm"],
-        glmderivs=glmderivs,
+        nprocs_regressionfilt=optiondict["nprocs_regressionfilt"],
+        regressderivs=regressderivs,
         mp_chunksize=optiondict["mp_chunksize"],
         showprogressbar=optiondict["showprogressbar"],
         alwaysmultiproc=optiondict["alwaysmultiproc"],
@@ -292,19 +413,19 @@ def getderivratios(
     )
 
     # calculate the ratio of the first derivative to the main regressor
-    if glmderivs == 1:
-        glmderivratios = 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]
-        glmderivratios = np.zeros((glmderivs, numvoxels), dtype=np.float64)
-        for i in range(glmderivs):
-            glmderivratios[i, :] = np.nan_to_num(fitcoeff[:, i + 1] / fitcoeff[:, 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 glmderivratios
+    return regressderivratios, rvalue
 
 
 def filterderivratios(
-    glmderivratios,
+    regressderivratios,
     nativespaceshape,
     validvoxels,
     thedims,
@@ -313,6 +434,7 @@ def filterderivratios(
     fileiscifti=False,
     textio=False,
     rt_floattype="float64",
+    verbose=True,
     debug=False,
 ):
 
@@ -323,32 +445,35 @@ def filterderivratios(
         print(f"\t{nativespaceshape=}")
 
     # filter the ratio to find weird values
-    themad = mad(glmderivratios).astype(np.float64)
-    print(f"MAD of GLM derivative ratios = {themad}")
+    themad = mad(regressderivratios).astype(np.float64)
+    if verbose:
+        print(f"MAD of regression fit derivative ratios = {themad}")
     outmaparray, internalspaceshape = tide_io.makedestarray(
         nativespaceshape,
         textio=textio,
         fileiscifti=fileiscifti,
         rt_floattype=rt_floattype,
     )
-    mappedglmderivratios = tide_io.populatemap(
-        glmderivratios,
+    mappedregressderivratios = tide_io.populatemap(
+        regressderivratios,
         internalspaceshape,
         validvoxels,
         outmaparray,
         debug=debug,
     )
     if textio or fileiscifti:
-        medfilt = glmderivratios
-        filteredarray = glmderivratios
+        medfilt = regressderivratios
+        filteredarray = regressderivratios
     else:
         if debug:
-            print(f"{glmderivratios.shape=}, {mappedglmderivratios.shape=}")
+            print(f"{regressderivratios.shape=}, {mappedregressderivratios.shape=}")
         medfilt = median_filter(
-            mappedglmderivratios.reshape(nativespaceshape), size=(3, 3, 3)
+            mappedregressderivratios.reshape(nativespaceshape), size=(3, 3, 3)
         ).reshape(internalspaceshape)[validvoxels]
         filteredarray = np.where(
-            np.fabs(glmderivratios - medfilt) > patchthresh * themad, medfilt, glmderivratios
+            np.fabs(regressderivratios - medfilt) > patchthresh * themad,
+            medfilt,
+            regressderivratios,
         )
         if gausssigma > 0:
             mappedfilteredarray = tide_io.populatemap(

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__":

rapidtide/scripts/retroregress.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#   Copyright 2016-2024 Blaise Frederick
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+#
+import rapidtide.workflows.parser_funcs as pf
+import rapidtide.workflows.retroregress as theworkflow
+
+
+def entrypoint():
+    pf.generic_init(theworkflow._get_parser, theworkflow.retroregress)
+
+
+if __name__ == "__main__":
+    entrypoint()

rapidtide/scripts/stupidramtricks.py

@@ -29,7 +29,7 @@ import rapidtide.workflows.parser_funcs as pf
 
 def _get_parser():
     """
-    Argument parser for glmfilt
+    Argument parser for stupidramtricks
     """
     parser = argparse.ArgumentParser(
         prog="stupidramtricks",
@@ -141,7 +141,9 @@ def stupidramtricks(args):
         fmridata, fmridata_shm = tide_util.numpy2shared(
             fmridata, rt_floatset, name=f"fmridata_{args.pid}"
         )
-        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)
@@ -160,7 +162,7 @@ def stupidramtricks(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)
@@ -172,7 +174,7 @@ def stupidramtricks(args):
 
     totalbytes = (
         fmridata.nbytes
-        + glmmean.nbytes
+        + sLFOfitmean.nbytes
         + rvalue.nbytes
         + r2value.nbytes
         + fitNorm.nbytes
@@ -185,7 +187,7 @@ def stupidramtricks(args):
     thesize, theunit = tide_util.format_bytes(totalbytes)
     print(f"allocated {thesize:.3f} {theunit} {location}")
 
-    """glmderivratios = tide_refinedelay.getderivratios(
+    """regressderivratios, regressrvalues = tide_refinedelay.getderivratios(
         fmri_data_valid,
         validvoxels,
         initial_fmri_x,
@@ -195,7 +197,7 @@ def stupidramtricks(args):
         mode,
         outputname,
         oversamptr,
-        glmmean,
+        sLFOfitmean,
         rvalue,
         r2value,
         fitNorm[:, :2],
@@ -212,7 +214,7 @@ def stupidramtricks(args):
     # clean up shared memory
     if args.usesharedmem:
         tide_util.cleanup_shm(fmridata_shm)
-        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)

rapidtide/simfuncfit.py

@@ -43,7 +43,7 @@ def onesimfuncfit(
 ):
     if initiallag is not None:
         thefitter.setguess(True, maxguess=initiallag)
-        thefitter.setrange(-despeckle_thresh/2.0, despeckle_thresh/2.0)
+        thefitter.setrange(-despeckle_thresh / 2.0, despeckle_thresh / 2.0)
     else:
         thefitter.setguess(False)
 

rapidtide/tests/cleanposttest

@@ -0,0 +1,21 @@
+#!/bin/sh
+#
+#   Copyright 2016-2021 Blaise Frederick
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+#
+
+rm tmp/*
+rm testdata/*
+rm .coveragerc.*