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

rapidtide/DerivativeDelay.py

@@ -161,7 +161,9 @@ class DerivativeDelay:
             if args.focaldebug:
                 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], closestoffset = tide_refinedelay.ratiotodelay(
+                    filteredregressderivratios[i]
+                )
             refinedvoxelstoreport = filteredregressderivratios.shape[0]
         else:
             medfiltregressderivratios = np.zeros_like(regressderivratios)

rapidtide/data/examples/src/testdelayvar

@@ -5,8 +5,9 @@ delayvar \
     ../dst/sub-RAPIDTIDETEST \
     --alternateoutput ../dst/delayvartest \
     --nprocs -1 \
-    --windowsize 20 \
+    --windowsize 30 \
     --systemicfittype pca \
+    --trainrange -999 -999 \
     --pcacomponents 0.8 \
     --outputlevel max \
     --focaldebug \

rapidtide/linfitfiltpass.py

@@ -97,6 +97,7 @@ def linfitfiltpass(
     mp_chunksize=1000,
     rt_floatset=np.float64,
     rt_floattype="float64",
+    verbose=True,
     debug=False,
 ):
     inputshape = np.shape(fmri_data)
@@ -184,6 +185,7 @@ def linfitfiltpass(
             GLM_consumer,
             inputshape,
             themask,
+            verbose=verbose,
             nprocs=nprocs,
             procbyvoxel=procbyvoxel,
             showprogressbar=showprogressbar,

rapidtide/makelaggedtcs.py

@@ -24,8 +24,6 @@ from tqdm import tqdm
 
 import rapidtide.multiproc as tide_multiproc
 
-LGR = logging.getLogger("GENERAL")
-
 
 def _procOneVoxelMakelagtc(
     vox,
@@ -51,6 +49,7 @@ def makelaggedtcs(
     lagmask,
     lagtimes,
     lagtc,
+    LGR=None,
     nprocs=1,
     alwaysmultiproc=False,
     showprogressbar=True,
@@ -90,6 +89,7 @@ def makelaggedtcs(
             makelagtc_consumer,
             inputshape,
             lagmask,
+            verbose=(LGR is not None),
             nprocs=nprocs,
             showprogressbar=showprogressbar,
             chunksize=chunksize,
@@ -127,13 +127,16 @@ def makelaggedtcs(
                 )
                 volumetotal += 1
 
-    LGR.info(f"\nLagged timecourses created for {volumetotal} voxels")
+    if LGR is not None:
+        LGR.info(f"\nLagged timecourses created for {volumetotal} voxels")
 
     # garbage collect
     uncollected = gc.collect()
     if uncollected != 0:
-        LGR.info(f"garbage collected - unable to collect {uncollected} objects")
+        if LGR is not None:
+            LGR.info(f"garbage collected - unable to collect {uncollected} objects")
     else:
-        LGR.info("garbage collected")
+        if LGR is not None:
+            LGR.info("garbage collected")
 
     return volumetotal

rapidtide/multiproc.py

@@ -77,8 +77,8 @@ def _process_data(data_in, inQ, outQ, showprogressbar=True, reportstep=1000, chu
                 pbar.update(1)
                 if numreturned > remainder - 1:
                     break
-
-    print()
+    if showprogressbar:
+        print()
 
     return data_out
 
@@ -88,6 +88,7 @@ def run_multiproc(
     inputshape,
     maskarray,
     nprocs=1,
+    verbose=True,
     procbyvoxel=True,
     showprogressbar=True,
     chunksize=1000,
@@ -105,13 +106,6 @@ def run_multiproc(
         workers = [ctx.Process(target=consumerfunc, args=(inQ, outQ)) for i in range(n_workers)]
         # signal.signal(signal.SIGINT, original_sigint_handler)
     else:
-        """# try adding this magic incantation to get coverage to record multiprocessing properly
-        # This fails for python 3.8 and above
-        try:
-            from pytest_cov.embed import cleanup
-        except ImportError:
-            cleanup = None
-        """
         cleanup = None  # just disable this for now
         inQ = mp.Queue()
         outQ = mp.Queue()
@@ -141,7 +135,8 @@ def run_multiproc(
             data_in.append(d)
         elif maskarray[d] > 0.5:
             data_in.append(d)
-    print("processing", len(data_in), procunit + " with", n_workers, "processes")
+    if verbose:
+        print("processing", len(data_in), procunit + " with", n_workers, "processes")
     data_out = _process_data(
         data_in, inQ, outQ, showprogressbar=showprogressbar, chunksize=chunksize
     )
@@ -162,6 +157,7 @@ def run_multithread(
     consumerfunc,
     inputshape,
     maskarray,
+    verbose=True,
     nprocs=1,
     procbyvoxel=True,
     showprogressbar=True,
@@ -197,7 +193,8 @@ def run_multithread(
             data_in.append(d)
         elif maskarray[d] > 0:
             data_in.append(d)
-    print("processing", len(data_in), procunit + " with", n_workers, "threads")
+    if verbose:
+        print("processing", len(data_in), procunit + " with", n_workers, "threads")
     data_out = _process_data(
         data_in, inQ, outQ, showprogressbar=showprogressbar, chunksize=chunksize
     )

rapidtide/refinedelay.py

@@ -26,7 +26,7 @@ import rapidtide.filter as tide_filt
 import rapidtide.io as tide_io
 import rapidtide.workflows.regressfrommaps as tide_regressfrommaps
 
-global ratiotooffsetfunc, maplimits
+global ratiotooffsetfunc, funcoffsets, maplimits
 
 
 def smooth(y, box_pts):
@@ -40,37 +40,39 @@ def trainratiotooffset(
     timeaxis,
     outputname,
     outputlevel,
-    trainwidth=0.0,
-    trainstep=0.5,
+    trainlagmin=0.0,
+    trainlagmax=0.0,
+    trainlagstep=0.5,
     mindelay=-3.0,
     maxdelay=3.0,
     numpoints=501,
     smoothpts=3,
     edgepad=5,
     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("\ttrainwidth:", trainwidth)
-        print("\ttrainstep:", trainstep)
+        print("\ttrainlagmin:", trainlagmin)
+        print("\ttrainlagmax:", trainlagmax)
+        print("\ttrainlagstep:", trainlagstep)
         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)
-    if debug:
-        print(f"{delaystep=}")
-        print(f"{mindelay=}")
-        print(f"{maxdelay=}")
     lagtimes = np.linspace(
         mindelay - edgepad * delaystep,
         maxdelay + edgepad * delaystep,
@@ -80,6 +82,7 @@ def trainratiotooffset(
     if debug:
         print(f"{mindelay=}")
         print(f"{maxdelay=}")
+        print(f"{delaystep=}")
         print("lagtimes=", lagtimes)
 
     # set up for getratioderivs call
@@ -111,103 +114,142 @@ def trainratiotooffset(
         "textio": False,
     }
 
-    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
+    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, numsteps * trainstep, numsteps, endpoint=True)
-            - (numsteps // 2) * trainstep
+            np.linspace(0, (numoffsets - 1) * trainlagstep, numoffsets, endpoint=True)
+            - numnegoffsets * trainlagstep
         )
     else:
         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)
 
-    for i in range(len(trainoffsets)):
-        pass
+    if verbose and (LGR is not None):
+        thisLGR = LGR
+        thisTimingLGR = TimingLGR
+    else:
+        thisLGR = None
+        thisTimingLGR = None
 
-    # now make synthetic fMRI data
-    for i in range(numpoints + 2 * edgepad):
-        fmridata[i, :] = lagtcgenerator.yfromx(timeaxis - lagtimes[i])
+    for whichoffset in range(numoffsets):
+        thisoffset = trainoffsets[whichoffset]
 
-    regressderivratios, regressrvalues = getderivratios(
-        fmridata,
-        validvoxels,
-        timeaxis,
-        0.0 * lagtimes,
-        fmrimask,
-        lagtcgenerator,
-        "glm",
-        "refinedelaytest",
-        sampletime,
-        sLFOfitmean,
-        rvalue,
-        r2value,
-        fitNorm[:, :2],
-        fitcoeff[:, :2],
-        movingsignal,
-        lagtc,
-        filtereddata,
-        None,
-        None,
-        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(regressderivratios, padlen=20, padtype="constant"), smoothpts),
-            padlen=20,
+        # 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,
         )
-        regressderivratios = regressderivratios[edgepad:-edgepad]
-        smoothregressderivratios = smoothregressderivratios[edgepad:-edgepad]
-    else:
-        smoothregressderivratios = np.zeros_like(regressderivratios)
-        for i in range(regressderivs):
-            smoothregressderivratios[i, :] = tide_filt.unpadvec(
+        if debug:
+            print("before trimming")
+            print(f"{regressderivratios.shape=}")
+            print(f"{lagtimes.shape=}")
+        if regressderivs == 1:
+            smoothregressderivratios = tide_filt.unpadvec(
                 smooth(
-                    tide_filt.padvec(regressderivratios[i, :], padlen=20, padtype="constant"),
-                    smoothpts,
+                    tide_filt.padvec(regressderivratios, padlen=20, padtype="constant"), smoothpts
                 ),
                 padlen=20,
             )
-        regressderivratios = regressderivratios[:, edgepad:-edgepad]
-        smoothregressderivratios = smoothregressderivratios[:, 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"{regressderivratios.shape=}")
-        print(f"{smoothregressderivratios.shape=}")
+        print(f"{allsmoothregressderivratios.shape=}")
         print(f"{lagtimes.shape=}")
 
-    # make sure the mapping function is legal
-    xaxis = smoothregressderivratios[::-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"],
+            columns=colnames,
             extraheaderinfo={
                 "Description": "The function mapping derivative ratio to delay",
                 "minratio": f"{resampaxis[0]}",
@@ -217,16 +259,59 @@ def trainratiotooffset(
             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):
@@ -316,7 +401,7 @@ def getderivratios(
         LGR,
         TimingLGR,
         optiondict["regressfiltthreshval"],
-        optiondict["saveminimumsLFOfiltfiles"],
+        False,
         nprocs_makelaggedtcs=optiondict["nprocs_makelaggedtcs"],
         nprocs_regressionfilt=optiondict["nprocs_regressionfilt"],
         regressderivs=regressderivs,
@@ -349,6 +434,7 @@ def filterderivratios(
     fileiscifti=False,
     textio=False,
     rt_floattype="float64",
+    verbose=True,
     debug=False,
 ):
 
@@ -360,7 +446,8 @@ def filterderivratios(
 
     # filter the ratio to find weird values
     themad = mad(regressderivratios).astype(np.float64)
-    print(f"MAD of regression fit derivative ratios = {themad}")
+    if verbose:
+        print(f"MAD of regression fit derivative ratios = {themad}")
     outmaparray, internalspaceshape = tide_io.makedestarray(
         nativespaceshape,
         textio=textio,

rapidtide/tests/test_fullrunhappy_v1.py

@@ -25,12 +25,20 @@ import rapidtide.workflows.happy_parser as happy_parser
 from rapidtide.tests.utils import create_dir, get_examples_path, get_test_temp_path, mse
 
 
-def test_fullrunhappy_v1(debug=False, displayplots=False):
+def test_fullrunhappy_v1(debug=False, local=False, displayplots=False):
+    # set input and output directories
+    if local:
+        exampleroot = "../data/examples/src"
+        testtemproot = "./tmp"
+    else:
+        exampleroot = get_examples_path()
+        testtemproot = get_test_temp_path()
+
     # run happy
     inputargs = [
-        os.path.join(get_examples_path(), "sub-HAPPYTEST.nii.gz"),
-        os.path.join(get_examples_path(), "sub-HAPPYTEST.json"),
-        os.path.join(get_test_temp_path(), "happyout1"),
+        os.path.join(exampleroot, "sub-HAPPYTEST.nii.gz"),
+        os.path.join(exampleroot, "sub-HAPPYTEST.json"),
+        os.path.join(testtemproot, "happyout1"),
         "--mklthreads",
         "-1",
         "--spatialregression",
@@ -42,4 +50,4 @@ def test_fullrunhappy_v1(debug=False, displayplots=False):
 
 if __name__ == "__main__":
     mpl.use("TkAgg")
-    test_fullrunhappy_v1(debug=True, displayplots=True)
+    test_fullrunhappy_v1(debug=True, local=True, displayplots=True)

rapidtide/tests/test_fullrunhappy_v2.py

@@ -25,16 +25,24 @@ import rapidtide.workflows.happy_parser as happy_parser
 from rapidtide.tests.utils import get_examples_path, get_test_temp_path
 
 
-def test_fullrunhappy_v2(debug=False, displayplots=False):
+def test_fullrunhappy_v2(debug=False, local=False, displayplots=False):
+    # set input and output directories
+    if local:
+        exampleroot = "../data/examples/src"
+        testtemproot = "./tmp"
+    else:
+        exampleroot = get_examples_path()
+        testtemproot = get_test_temp_path()
+
     # run happy
     inputargs = [
-        os.path.join(get_examples_path(), "sub-HAPPYTEST.nii.gz"),
-        os.path.join(get_examples_path(), "sub-HAPPYTEST.json"),
-        os.path.join(get_test_temp_path(), "happyout2"),
+        os.path.join(exampleroot, "sub-HAPPYTEST.nii.gz"),
+        os.path.join(exampleroot, "sub-HAPPYTEST.json"),
+        os.path.join(testtemproot, "happyout2"),
         "--estweights",
-        os.path.join(get_examples_path(), "sub-HAPPYTEST_smallmask.nii.gz"),
+        os.path.join(exampleroot, "sub-HAPPYTEST_smallmask.nii.gz"),
         "--projmask",
-        os.path.join(get_examples_path(), "sub-HAPPYTEST_smallmask.nii.gz"),
+        os.path.join(exampleroot, "sub-HAPPYTEST_smallmask.nii.gz"),
         "--mklthreads",
         "-1",
         "--model",
@@ -43,7 +51,7 @@ def test_fullrunhappy_v2(debug=False, displayplots=False):
         "--temporalregression",
         "--cardiacfile",
         os.path.join(
-            get_examples_path(),
+            exampleroot,
             "sub-HAPPYTEST_desc-slicerescardfromfmri_timeseries.json:cardiacfromfmri_dlfiltered",
         ),
         "--increaseoutputlevel",
@@ -54,4 +62,4 @@ def test_fullrunhappy_v2(debug=False, displayplots=False):
 
 if __name__ == "__main__":
     mpl.use("TkAgg")
-    test_fullrunhappy_v2(debug=True, displayplots=True)
+    test_fullrunhappy_v2(debug=True, local=True, displayplots=True)

rapidtide/tests/test_fullrunhappy_v3.py

@@ -25,16 +25,24 @@ import rapidtide.workflows.happy_parser as happy_parser
 from rapidtide.tests.utils import get_examples_path, get_test_temp_path
 
 
-def test_fullrunhappy_v3(debug=False, displayplots=False):
+def test_fullrunhappy_v3(debug=False, local=False, displayplots=False):
+    # set input and output directories
+    if local:
+        exampleroot = "../data/examples/src"
+        testtemproot = "./tmp"
+    else:
+        exampleroot = get_examples_path()
+        testtemproot = get_test_temp_path()
+
     # run happy
     inputargs = [
-        os.path.join(get_examples_path(), "sub-HAPPYTEST.nii.gz"),
-        os.path.join(get_examples_path(), "sub-HAPPYTEST.json"),
-        os.path.join(get_test_temp_path(), "happyout3"),
+        os.path.join(exampleroot, "sub-HAPPYTEST.nii.gz"),
+        os.path.join(exampleroot, "sub-HAPPYTEST.json"),
+        os.path.join(testtemproot, "happyout3"),
         "--estweights",
-        os.path.join(get_examples_path(), "sub-HAPPYTEST_smallmask.nii.gz"),
+        os.path.join(exampleroot, "sub-HAPPYTEST_smallmask.nii.gz"),
         "--projmask",
-        os.path.join(get_examples_path(), "sub-HAPPYTEST_smallmask.nii.gz"),
+        os.path.join(exampleroot, "sub-HAPPYTEST_smallmask.nii.gz"),
         "--mklthreads",
         "-1",
         "--model",
@@ -42,10 +50,10 @@ def test_fullrunhappy_v3(debug=False, displayplots=False):
         "--cardcalconly",
     ]
     # "--motionfile",
-    # os.path.join(get_examples_path(), "sub-HAPPYTEST_mcf.par"),
+    # os.path.join(exampleroot, "sub-HAPPYTEST_mcf.par"),
     happy_workflow.happy_main(happy_parser.process_args(inputargs=inputargs))
 
 
 if __name__ == "__main__":
     mpl.use("TkAgg")
-    test_fullrunhappy_v3(debug=True, displayplots=True)
+    test_fullrunhappy_v3(debug=True, local=True, displayplots=True)