rapidtide 3.0.7.1__py3-none-any.whl → 3.0.9__py3-none-any.whl

rapidtide/workflows/calcSimFuncMap.py

@@ -0,0 +1,271 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#   Copyright 2016-2025 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 numpy as np
+
+import rapidtide.calcsimfunc as tide_calcsimfunc
+import rapidtide.io as tide_io
+import rapidtide.linfitfiltpass as tide_linfitfiltpass
+import rapidtide.makelaggedtcs as tide_makelagged
+import rapidtide.stats as tide_stats
+import rapidtide.util as tide_util
+
+
+def makeRIPTiDeRegressors(
+    initial_fmri_x,
+    lagmin,
+    lagmax,
+    lagtcgenerator,
+    LGR,
+    nprocs=1,
+    alwaysmultiproc=False,
+    showprogressbar=True,
+    chunksize=1000,
+    targetstep=2.5,
+    edgepad=0,
+    rt_floatset=np.float64,
+    rt_floattype="float64",
+    debug=False,
+):
+    # make the RIPTiDe evs
+    numdelays = int(np.round((lagmax - lagmin) / targetstep, 0))
+    numregressors = numdelays + 2 * edgepad
+    delaystep = (lagmax - lagmin) / numdelays
+    delaystouse = np.linspace(
+        lagmin - edgepad * delaystep,
+        lagmax + edgepad * delaystep,
+        numdelays + 2 * edgepad,
+        endpoint=True,
+    )
+    if debug:
+        print(f"{lagmin=}")
+        print(f"{lagmax=}")
+        print(f"{numdelays=}")
+        print(f"{edgepad=}")
+        print(f"{numregressors=}")
+        print(f"{delaystep=}")
+        print(f"{delaystouse=}, {len(delaystouse)}")
+        print(f"{len(initial_fmri_x)}")
+
+    regressorset = np.zeros((len(delaystouse), len(initial_fmri_x)), dtype=rt_floatset)
+
+    dummy = tide_makelagged.makelaggedtcs(
+        lagtcgenerator,
+        initial_fmri_x,
+        np.ones_like(delaystouse, dtype=np.float64),
+        delaystouse,
+        regressorset,
+        LGR=LGR,
+        nprocs=nprocs,
+        alwaysmultiproc=alwaysmultiproc,
+        showprogressbar=showprogressbar,
+        chunksize=chunksize,
+        rt_floatset=rt_floatset,
+        rt_floattype=rt_floattype,
+        debug=debug,
+    )
+
+    if debug:
+        print(regressorset)
+
+    return regressorset, delaystouse
+
+
+def calcSimFunc(
+    numvalidspatiallocs,
+    fmri_data_valid,
+    validsimcalcstart,
+    validsimcalcend,
+    osvalidsimcalcstart,
+    osvalidsimcalcend,
+    initial_fmri_x,
+    os_fmri_x,
+    theCorrelator,
+    theMutualInformationator,
+    cleaned_referencetc,
+    corrout,
+    regressorset,
+    delayvals,
+    sLFOfitmean,
+    r2value,
+    fitcoeff,
+    fitNorm,
+    meanval,
+    corrscale,
+    outputname,
+    outcorrarray,
+    validvoxels,
+    nativecorrshape,
+    theinputdata,
+    theheader,
+    lagmininpts,
+    lagmaxinpts,
+    thepass,
+    optiondict,
+    LGR,
+    TimingLGR,
+    similaritymetric="correlation",
+    simcalcoffset=0,
+    echocancel=False,
+    checkpoint=False,
+    nprocs=1,
+    alwaysmultiproc=False,
+    oversampfactor=2,
+    interptype="univariate",
+    showprogressbar=True,
+    chunksize=1000,
+    rt_floatset=np.float64,
+    rt_floattype="float64",
+    mklthreads=1,
+    threaddebug=False,
+    debug=False,
+):
+    # Step 1 - Correlation step
+    if similaritymetric == "mutualinfo":
+        similaritytype = "Mutual information"
+    elif similaritymetric == "correlation":
+        similaritytype = "Correlation"
+    elif similaritymetric == "riptide":
+        similaritytype = "RIPTiDe"
+    else:
+        similaritytype = "MI enhanced correlation"
+    LGR.info(f"\n\n{similaritytype} calculation, pass {thepass}")
+    TimingLGR.info(f"{similaritytype} calculation start, pass {thepass}")
+
+    tide_util.disablemkl(nprocs, debug=threaddebug)
+    if similaritymetric == "mutualinfo":
+        theMutualInformationator.setlimits(lagmininpts, lagmaxinpts)
+        (
+            voxelsprocessed_cp,
+            theglobalmaxlist,
+            trimmedcorrscale,
+        ) = tide_calcsimfunc.correlationpass(
+            fmri_data_valid[:, validsimcalcstart : validsimcalcend + 1],
+            cleaned_referencetc,
+            theMutualInformationator,
+            initial_fmri_x[validsimcalcstart : validsimcalcend + 1],
+            os_fmri_x[osvalidsimcalcstart : osvalidsimcalcend + 1],
+            lagmininpts,
+            lagmaxinpts,
+            corrout,
+            meanval,
+            nprocs=nprocs,
+            alwaysmultiproc=alwaysmultiproc,
+            oversampfactor=oversampfactor,
+            interptype=interptype,
+            showprogressbar=showprogressbar,
+            chunksize=chunksize,
+            rt_floatset=rt_floatset,
+            rt_floattype=rt_floattype,
+            debug=debug,
+        )
+    elif (similaritymetric == "correlation") or (similaritymetric == "hybrid"):
+        (
+            voxelsprocessed_cp,
+            theglobalmaxlist,
+            trimmedcorrscale,
+        ) = tide_calcsimfunc.correlationpass(
+            fmri_data_valid[:, validsimcalcstart : validsimcalcend + 1],
+            cleaned_referencetc,
+            theCorrelator,
+            initial_fmri_x[validsimcalcstart : validsimcalcend + 1],
+            os_fmri_x[osvalidsimcalcstart : osvalidsimcalcend + 1],
+            lagmininpts,
+            lagmaxinpts,
+            corrout,
+            meanval,
+            nprocs=nprocs,
+            alwaysmultiproc=alwaysmultiproc,
+            oversampfactor=oversampfactor,
+            interptype=interptype,
+            showprogressbar=showprogressbar,
+            chunksize=chunksize,
+            rt_floatset=rt_floatset,
+            rt_floattype=rt_floattype,
+            debug=debug,
+        )
+    elif similaritymetric == "riptide":
+        # do the linear fit to the comb of delayed regressors
+        for thedelay in range(len(delayvals)):
+            print(f"Fitting delay {delayvals[thedelay]:.2f}")
+            voxelsprocessed_cp = tide_linfitfiltpass.linfitfiltpass(
+                numvalidspatiallocs,
+                fmri_data_valid[:, validsimcalcstart : validsimcalcend + 1],
+                0.0,
+                regressorset[thedelay, validsimcalcstart : validsimcalcend + 1],
+                sLFOfitmean,
+                corrout[:, thedelay],
+                r2value,
+                fitcoeff,
+                fitNorm,
+                None,
+                None,
+                coefficientsonly=True,
+                voxelspecific=False,
+                nprocs=nprocs,
+                alwaysmultiproc=alwaysmultiproc,
+                showprogressbar=showprogressbar,
+                verbose=(LGR is not None),
+                chunksize=chunksize,
+                rt_floatset=rt_floatset,
+                rt_floattype=rt_floattype,
+                debug=debug,
+            )
+    else:
+        print("illegal similarity metric")
+
+    tide_util.enablemkl(mklthreads, debug=threaddebug)
+
+    if similaritymetric != "riptide":
+        for i in range(len(theglobalmaxlist)):
+            theglobalmaxlist[i] = corrscale[theglobalmaxlist[i]] - simcalcoffset
+        namesuffix = "_desc-globallag_hist"
+        tide_stats.makeandsavehistogram(
+            np.asarray(theglobalmaxlist),
+            len(corrscale),
+            0,
+            outputname + namesuffix,
+            displaytitle="Histogram of lag times from global lag calculation",
+            therange=(corrscale[0], corrscale[-1]),
+            refine=False,
+            dictvarname="globallaghist_pass" + str(thepass),
+            append=(echocancel or (thepass > 1)),
+            thedict=optiondict,
+        )
+
+    if checkpoint:
+        outcorrarray[:, :] = 0.0
+        outcorrarray[validvoxels, :] = corrout[:, :]
+        if theinputdata.filetype == "text":
+            tide_io.writenpvecs(
+                outcorrarray.reshape(nativecorrshape),
+                f"{outputname}_corrout_prefit_pass" + str(thepass) + ".txt",
+            )
+        else:
+            savename = f"{outputname}_desc-corroutprefit_pass-" + str(thepass)
+            tide_io.savetonifti(outcorrarray.reshape(nativecorrshape), theheader, savename)
+
+    TimingLGR.info(
+        f"{similaritytype} calculation end, pass {thepass}",
+        {
+            "message2": voxelsprocessed_cp,
+            "message3": "voxels",
+        },
+    )
+
+    return similaritytype

rapidtide/workflows/cleanregressor.py

@@ -20,9 +20,9 @@ import numpy as np
 
 import rapidtide.correlate as tide_corr
 import rapidtide.filter as tide_filt
-import rapidtide.helper_classes as tide_classes
 import rapidtide.io as tide_io
 import rapidtide.miscmath as tide_math
+import rapidtide.simFuncClasses as tide_simFuncClasses
 import rapidtide.simfuncfit as tide_simfuncfit
 
 
@@ -81,7 +81,7 @@ def cleanregressor(
     dolagmod = True
     doreferencenotch = True
     if respdelete:
-        resptracker = tide_classes.FrequencyTracker(nperseg=64)
+        resptracker = tide_simFuncClasses.FrequencyTracker(nperseg=64)
         thetimes, thefreqs = resptracker.track(resampref_y, oversampfreq)
         tide_io.writevec(thefreqs, f"{outputname}_peakfreaks_pass{thepass}.txt")
         resampref_y = resptracker.clean(resampref_y, oversampfreq, thetimes, thefreqs)

rapidtide/workflows/delayvar.py

@@ -614,38 +614,32 @@ def delayvar(args):
     windowedfilteredregressderivratios = np.zeros(internalwinspaceshape, dtype=float)
     windoweddelayoffset = np.zeros(internalwinspaceshape, dtype=float)
     windowedclosestoffset = np.zeros(internalwinspaceshape, dtype=float)
+
+    winsLFOfitmean, winsLFOfitmean_shm = tide_util.allocarray(
+        internalwinspaceshape, rt_outfloattype, shared=usesharedmem
+    )
+    winrvalue, winrvalue_shm = tide_util.allocarray(internalwinspaceshape, rt_outfloattype, shared=usesharedmem)
+    winr2value, winr2value_shm = tide_util.allocarray(internalwinspaceshape, rt_outfloattype, shared=usesharedmem)
+    winfitNorm, winfitNorm_shm = tide_util.allocarray(
+        internalwinspaceshapederivs, rt_outfloattype, shared=usesharedmem
+    )
+    winfitcoeff, winitcoeff_shm = tide_util.allocarray(
+        internalwinspaceshapederivs, rt_outfloattype, shared=usesharedmem
+    )
+    winmovingsignal, winmovingsignal_shm = tide_util.allocarray(
+        internalwinfmrishape, rt_outfloattype, shared=usesharedmem
+    )
+    winlagtc, winlagtc_shm = tide_util.allocarray(internalwinfmrishape, rt_floattype, shared=usesharedmem)
+    winfiltereddata, winfiltereddata_shm = tide_util.allocarray(
+        internalwinfmrishape, rt_outfloattype, shared=usesharedmem
+    )
     if usesharedmem:
         if args.debug:
             print("allocating shared memory")
-        winsLFOfitmean, winsLFOfitmean_shm = tide_util.allocshared(
-            internalwinspaceshape, rt_outfloatset
-        )
-        winrvalue, winrvalue_shm = tide_util.allocshared(internalwinspaceshape, rt_outfloatset)
-        winr2value, winr2value_shm = tide_util.allocshared(internalwinspaceshape, rt_outfloatset)
-        winfitNorm, winfitNorm_shm = tide_util.allocshared(
-            internalwinspaceshapederivs, rt_outfloatset
-        )
-        winfitcoeff, winitcoeff_shm = tide_util.allocshared(
-            internalwinspaceshapederivs, rt_outfloatset
-        )
-        winmovingsignal, winmovingsignal_shm = tide_util.allocshared(
-            internalwinfmrishape, rt_outfloatset
-        )
-        winlagtc, winlagtc_shm = tide_util.allocshared(internalwinfmrishape, rt_floatset)
-        winfiltereddata, winfiltereddata_shm = tide_util.allocshared(
-            internalwinfmrishape, rt_outfloatset
-        )
     else:
         if args.debug:
             print("allocating memory")
-        winsLFOfitmean = np.zeros(internalwinspaceshape, dtype=rt_outfloattype)
-        winrvalue = np.zeros(internalwinspaceshape, dtype=rt_outfloattype)
-        winr2value = np.zeros(internalwinspaceshape, dtype=rt_outfloattype)
-        winfitNorm = np.zeros(internalwinspaceshapederivs, dtype=rt_outfloattype)
-        winfitcoeff = np.zeros(internalwinspaceshapederivs, dtype=rt_outfloattype)
-        winmovingsignal = np.zeros(internalwinfmrishape, dtype=rt_outfloattype)
-        winlagtc = np.zeros(internalwinfmrishape, dtype=rt_floattype)
-        winfiltereddata = np.zeros(internalwinfmrishape, dtype=rt_outfloattype)
+
     if args.debug:
         print(f"wintrs={wintrs}, winskip={winskip}, numtrs={numtrs}, numwins={numwins}")
     thewindowprocoptions = therunoptions
@@ -831,7 +825,7 @@ def delayvar(args):
                 sys.exit()
         print(
             f"Using {len(thefit.components_)} component(s), accounting for "
-            + f"{100.0 * np.cumsum(thefit.explained_variance_ratio_)[len(thefit.components_) - 1]}% of the variance"
+            + f"{100.0 * np.cumsum(thefit.explained_variance_ratio_)[len(thefit.components_) - 1]:.2f}% of the variance"
         )
         reduceddata = thefit.inverse_transform(thefit.transform(scaledvoxels))
         # unscale the PCA cleaned data
@@ -872,44 +866,36 @@ def delayvar(args):
 
     doregress = False
     if doregress:
+        systemicsLFOfitmean, systemicsLFOfitmean_shm = tide_util.allocarray(
+            internalwinspaceshape, rt_outfloattype, shared=usesharedmem
+        )
+        systemicrvalue, systemicrvalue_shm = tide_util.allocarray(
+            internalwinspaceshape, rt_outfloattype, shared=usesharedmem
+        )
+        systemicr2value, systemicr2value_shm = tide_util.allocarray(
+            internalwinspaceshape, rt_outfloattype, shared=usesharedmem
+        )
+        systemicfitNorm, systemicfitNorm_shm = tide_util.allocarray(
+            internalwinspaceshapederivs, rt_outfloattype, shared=usesharedmem
+        )
+        systemicfitcoeff, systemicitcoeff_shm = tide_util.allocarray(
+            internalwinspaceshapederivs, rt_outfloattype, shared=usesharedmem
+        )
+        systemicmovingsignal, systemicmovingsignal_shm = tide_util.allocarray(
+            internalwinspaceshape, rt_outfloattype, shared=usesharedmem
+        )
+        systemiclagtc, systemiclagtc_shm = tide_util.allocarray(
+            internalwinspaceshape, rt_floattype, shared=usesharedmem
+        )
+        systemicfiltereddata, systemicfiltereddata_shm = tide_util.allocarray(
+            internalwinspaceshape, rt_outfloattype, shared=usesharedmem
+        )
         if usesharedmem:
             if args.debug:
                 print("allocating shared memory")
-            systemicsLFOfitmean, systemicsLFOfitmean_shm = tide_util.allocshared(
-                internalwinspaceshape, rt_outfloatset
-            )
-            systemicrvalue, systemicrvalue_shm = tide_util.allocshared(
-                internalwinspaceshape, rt_outfloatset
-            )
-            systemicr2value, systemicr2value_shm = tide_util.allocshared(
-                internalwinspaceshape, rt_outfloatset
-            )
-            systemicfitNorm, systemicfitNorm_shm = tide_util.allocshared(
-                internalwinspaceshapederivs, rt_outfloatset
-            )
-            systemicfitcoeff, systemicitcoeff_shm = tide_util.allocshared(
-                internalwinspaceshapederivs, rt_outfloatset
-            )
-            systemicmovingsignal, systemicmovingsignal_shm = tide_util.allocshared(
-                internalwinspaceshape, rt_outfloatset
-            )
-            systemiclagtc, systemiclagtc_shm = tide_util.allocshared(
-                internalwinspaceshape, rt_floatset
-            )
-            systemicfiltereddata, systemicfiltereddata_shm = tide_util.allocshared(
-                internalwinspaceshape, rt_outfloatset
-            )
         else:
             if args.debug:
                 print("allocating memory")
-            systemicsLFOfitmean = np.zeros(internalwinspaceshape, dtype=rt_outfloattype)
-            systemicrvalue = np.zeros(internalwinspaceshape, dtype=rt_outfloattype)
-            systemicr2value = np.zeros(internalwinspaceshape, dtype=rt_outfloattype)
-            systemicfitNorm = np.zeros(internalwinspaceshapederivs, dtype=rt_outfloattype)
-            systemicfitcoeff = np.zeros(internalwinspaceshapederivs, dtype=rt_outfloattype)
-            systemicmovingsignal = np.zeros(internalwinspaceshape, dtype=rt_outfloattype)
-            systemiclagtc = np.zeros(internalwinspaceshape, dtype=rt_floattype)
-            systemicfiltereddata = np.zeros(internalwinspaceshape, dtype=rt_outfloattype)
 
         windowlocs = np.linspace(0.0, winspace * numwins, num=numwins, endpoint=False) + skiptime
         voxelsprocessed_regressionfilt, regressorset, evset = tide_regressfrommaps.regressfrommaps(