rapidtide 3.0.1__py3-none-any.whl → 3.0.3__py3-none-any.whl

rapidtide/workflows/rapidtide.py

@@ -71,75 +71,6 @@ ErrorLGR = logging.getLogger("ERROR")
 TimingLGR = logging.getLogger("TIMING")
 
 
-def getglobalsignal(
-    indata, optiondict, includemask=None, excludemask=None, pcacomponents=0.8, debug=False
-):
-    # Start with all voxels
-    themask = indata[:, 0] * 0 + 1
-
-    # modify the mask if needed
-    if includemask is not None:
-        themask = themask * includemask
-    if excludemask is not None:
-        themask = themask * (1 - excludemask)
-
-    # combine all the voxels using one of the three methods
-    global rt_floatset, rt_floattype
-    globalmean = rt_floatset(indata[0, :])
-    thesize = np.shape(themask)
-    numvoxelsused = int(np.sum(np.where(themask > 0.0, 1, 0)))
-    selectedvoxels = indata[np.where(themask > 0.0), :][0]
-    if debug:
-        print(f"getglobalsignal: {selectedvoxels.shape=}")
-    LGR.info(f"constructing global mean signal using {optiondict['globalsignalmethod']}")
-    if optiondict["globalsignalmethod"] == "sum":
-        globalmean = np.mean(selectedvoxels, axis=0)
-        globalmean -= np.mean(globalmean)
-    elif optiondict["globalsignalmethod"] == "meanscale":
-        themean = np.mean(indata, axis=1)
-        for vox in range(0, thesize[0]):
-            if themask[vox] > 0.0:
-                if themean[vox] != 0.0:
-                    globalmean += indata[vox, :] / themean[vox] - 1.0
-    elif optiondict["globalsignalmethod"] == "pca":
-        themean = np.mean(indata, axis=1)
-        thevar = np.var(indata, axis=1)
-        scaledvoxels = selectedvoxels * 0.0
-        for vox in range(0, selectedvoxels.shape[0]):
-            scaledvoxels[vox, :] = selectedvoxels[vox, :] - themean[vox]
-            if thevar[vox] > 0.0:
-                scaledvoxels[vox, :] = selectedvoxels[vox, :] / thevar[vox]
-        try:
-            thefit = PCA(n_components=pcacomponents).fit(np.transpose(scaledvoxels))
-        except ValueError:
-            if pcacomponents == "mle":
-                LGR.warning("mle estimation failed - falling back to pcacomponents=0.8")
-                thefit = PCA(n_components=0.8).fit(np.transpose(scaledvoxels))
-            else:
-                raise ValueError("unhandled math exception in PCA refinement - exiting")
-
-        varex = 100.0 * np.cumsum(thefit.explained_variance_ratio_)[len(thefit.components_) - 1]
-        thetransform = thefit.transform(np.transpose(scaledvoxels))
-        if debug:
-            print(f"getglobalsignal: {thetransform.shape=}")
-        globalmean = np.mean(thetransform, axis=0)
-        globalmean -= np.mean(globalmean)
-        if debug:
-            print(f"getglobalsignal: {varex=}")
-        LGR.info(
-            f"Using {len(thefit.components_)} component(s), accounting for "
-            f"{varex:.2f}% of the variance"
-        )
-    elif optiondict["globalsignalmethod"] == "random":
-        globalmean = np.random.standard_normal(size=len(globalmean))
-    else:
-        raise ValueError(f"illegal globalsignalmethod: {optiondict['globalsignalmethod']}")
-    LGR.info(f"used {numvoxelsused} voxels to calculate global mean signal")
-    if debug:
-        print(f"getglobalsignal: {globalmean=}")
-    return tide_math.stdnormalize(globalmean), themask
-
-
 def checkforzeromean(thedataset):
     themean = np.mean(thedataset, axis=1)
     thestd = np.std(thedataset, axis=1)
@@ -227,7 +158,7 @@ def rapidtide_main(argparsingfunc):
         gc.enable()
         print("turning on garbage collection")
 
-    # if running in Docker or Apptainer/Singularity, this is necessary to enforce memory limits properly
+    # If running in Docker or Apptainer/Singularity, this is necessary to enforce memory limits properly
     # otherwise likely to  error out in gzip.py or at voxelnormalize step.  But do nothing if running in CircleCI
     # because it does NOT like you messing with the container.
     optiondict["containertype"] = tide_util.checkifincontainer()
@@ -364,16 +295,13 @@ def rapidtide_main(argparsingfunc):
     theinputdata = tide_voxelData.VoxelData(inputdatafilename, timestep=optiondict["realtr"])
     if optiondict["debug"]:
         theinputdata.summarize()
-    nim = theinputdata.nim
-    nim_hdr = theinputdata.nim_hdr
-    nim_affine = theinputdata.nim_affine
     xsize, ysize, numslices, timepoints = theinputdata.getdims()
     thesizes = theinputdata.thesizes
     xdim, ydim, slicethickness, fmritr = theinputdata.getsizes()
     numspatiallocs = theinputdata.numspatiallocs
     nativespaceshape = theinputdata.nativespaceshape
-    cifti_hdr = theinputdata.cifti_hdr
     fmritr = theinputdata.timestep
+    optiondict["filetype"] = theinputdata.filetype
     if theinputdata.filetype == "cifti":
         fileiscifti = True
         optiondict["textio"] = False
@@ -440,6 +368,7 @@ def rapidtide_main(argparsingfunc):
         ["brainmaskincludename", "brainmaskincludevals", "brainmask"],
         ["graymatterincludename", "graymatterincludevals", "graymattermask"],
         ["whitematterincludename", "whitematterincludevals", "whitemattermask"],
+        ["csfincludename", "csfincludevals", "csfmask"],
     ]
     anatomicmasks = []
     for thisanatomic in anatomiclist:
@@ -447,12 +376,13 @@ def rapidtide_main(argparsingfunc):
             anatomicmasks.append(
                 tide_mask.readamask(
                     optiondict[thisanatomic[0]],
-                    nim_hdr,
+                    theinputdata.nim_hdr,
                     xsize,
-                    istext=optiondict["textio"],
+                    istext=(theinputdata.filetype == "text"),
                     valslist=optiondict[thisanatomic[1]],
                     maskname=thisanatomic[2],
                     tolerance=optiondict["spatialtolerance"],
+                    debug=optiondict["focaldebug"],
                 )
             )
             anatomicmasks[-1] = np.uint16(np.where(anatomicmasks[-1] > 0.1, 1, 0))
@@ -462,6 +392,7 @@ def rapidtide_main(argparsingfunc):
     brainmask = anatomicmasks[0]
     graymask = anatomicmasks[1]
     whitemask = anatomicmasks[2]
+    csfmask = anatomicmasks[3]
 
     # do spatial filtering if requested
     optiondict["gausssigma"] = theinputdata.smooth(
@@ -476,8 +407,8 @@ def rapidtide_main(argparsingfunc):
     if optiondict["gausssigma"] > 0.0:
         TimingLGR.info("End 3D smoothing")
 
-    # reshape the data and trim to a time range, if specified.  Check for special case of no trimming to save RAM
-    fmri_data = theinputdata.voxelbytime()
+    # Reshape the data and trim to a time range, if specified.  Check for special case of no trimming to save RAM
+    fmri_data = theinputdata.byvoxel()
     print(f"{fmri_data.shape=}")
 
     # detect zero mean data
@@ -492,7 +423,7 @@ def rapidtide_main(argparsingfunc):
         )
         optiondict["refineprenorm"] = "None"
 
-    # reformat the brain mask, if it exists
+    # reformat the anatomic masks, if they exist
     if brainmask is None:
         invbrainmask = None
 
@@ -506,22 +437,25 @@ def rapidtide_main(argparsingfunc):
     # read in the optional masks
     tide_util.logmem("before setting masks")
 
-    internalglobalmeanincludemask, internalglobalmeanexcludemask, dummy = tide_mask.getmaskset(
-        "global mean",
-        optiondict["globalmeanincludename"],
-        optiondict["globalmeanincludevals"],
-        optiondict["globalmeanexcludename"],
-        optiondict["globalmeanexcludevals"],
-        nim_hdr,
-        numspatiallocs,
-        istext=optiondict["textio"],
-        tolerance=optiondict["spatialtolerance"],
+    internalinitregressorincludemask, internalinitregressorexcludemask, dummy = (
+        tide_mask.getmaskset(
+            "global mean",
+            optiondict["initregressorincludename"],
+            optiondict["initregressorincludevals"],
+            optiondict["initregressorexcludename"],
+            optiondict["initregressorexcludevals"],
+            theinputdata.nim_hdr,
+            numspatiallocs,
+            istext=(theinputdata.filetype == "text"),
+            tolerance=optiondict["spatialtolerance"],
+            debug=optiondict["focaldebug"],
+        )
     )
     if internalinvbrainmask is not None:
-        if internalglobalmeanexcludemask is not None:
-            internalglobalmeanexcludemask *= internalinvbrainmask
+        if internalinitregressorexcludemask is not None:
+            internalinitregressorexcludemask *= internalinvbrainmask
         else:
-            internalglobalmeanexcludemask = internalinvbrainmask
+            internalinitregressorexcludemask = internalinvbrainmask
 
     internalrefineincludemask, internalrefineexcludemask, dummy = tide_mask.getmaskset(
         "refine",
@@ -529,10 +463,11 @@ def rapidtide_main(argparsingfunc):
         optiondict["refineincludevals"],
         optiondict["refineexcludename"],
         optiondict["refineexcludevals"],
-        nim_hdr,
+        theinputdata.nim_hdr,
         numspatiallocs,
-        istext=optiondict["textio"],
+        istext=(theinputdata.filetype == "text"),
         tolerance=optiondict["spatialtolerance"],
+        debug=optiondict["focaldebug"],
     )
     if internalinvbrainmask is not None:
         if internalrefineexcludemask is not None:
@@ -546,10 +481,11 @@ def rapidtide_main(argparsingfunc):
         optiondict["offsetincludevals"],
         optiondict["offsetexcludename"],
         optiondict["offsetexcludevals"],
-        nim_hdr,
+        theinputdata.nim_hdr,
         numspatiallocs,
-        istext=optiondict["textio"],
+        istext=(theinputdata.filetype == "text"),
         tolerance=optiondict["spatialtolerance"],
+        debug=optiondict["focaldebug"],
     )
     if internalinvbrainmask is not None:
         if internaloffsetexcludemask is not None:
@@ -565,19 +501,20 @@ def rapidtide_main(argparsingfunc):
     if optiondict["corrmaskincludename"] is not None:
         thecorrmask = tide_mask.readamask(
             optiondict["corrmaskincludename"],
-            nim_hdr,
+            theinputdata.nim_hdr,
             xsize,
-            istext=optiondict["textio"],
+            istext=(theinputdata.filetype == "text"),
             valslist=optiondict["corrmaskincludevals"],
             maskname="correlation",
             tolerance=optiondict["spatialtolerance"],
+            debug=optiondict["focaldebug"],
         )
 
         corrmask = np.uint16(np.where(thecorrmask > 0, 1, 0).reshape(numspatiallocs))
 
         # last line sanity check - if data is 0 over all time in a voxel, force corrmask to zero.
         datarange = np.max(fmri_data, axis=1) - np.min(fmri_data, axis=1)
-        if optiondict["textio"]:
+        if theinputdata.filetype == "text":
             tide_io.writenpvecs(
                 datarange.reshape((numspatiallocs)),
                 f"{outputname}_motionr2.txt",
@@ -586,18 +523,20 @@ def rapidtide_main(argparsingfunc):
             savename = f"{outputname}_desc-datarange"
             tide_io.savetonifti(
                 datarange.reshape((xsize, ysize, numslices)),
-                nim_hdr,
+                theinputdata.nim_hdr,
                 savename,
             )
         corrmask[np.where(datarange == 0)] = 0.0
     else:
         # check to see if the data has been demeaned
-        if fileiscifti or optiondict["textio"]:
-            corrmask = np.uint(theinputdata.voxelbytime()[:, 0] * 0 + 1)
+        if theinputdata.filetype != "nifti":
+            corrmask = np.uint(theinputdata.byvoxel()[:, 0] * 0 + 1)
         else:
             if not optiondict["dataiszeromean"]:
                 LGR.verbose("generating correlation mask from mean image")
-                corrmask = np.uint16(tide_mask.makeepimask(nim).dataobj.reshape(numspatiallocs))
+                corrmask = np.uint16(
+                    tide_mask.makeepimask(theinputdata.nim).dataobj.reshape(numspatiallocs)
+                )
             else:
                 LGR.verbose("generating correlation mask from std image")
                 corrmask = np.uint16(
@@ -605,8 +544,8 @@ def rapidtide_main(argparsingfunc):
                         np.std(fmri_data, axis=1), threshpct=optiondict["corrmaskthreshpct"]
                     )
                 )
-    if internalbrainmask is not None:
-        corrmask = internalbrainmask
+        if internalbrainmask is not None:
+            corrmask = internalbrainmask
     if tide_stats.getmasksize(corrmask) == 0:
         raise ValueError("ERROR: there are no voxels in the correlation mask - exiting")
 
@@ -638,11 +577,8 @@ def rapidtide_main(argparsingfunc):
         corrmask *= 0
         corrmask += 1
         threshval = -10000000.0
-    if not (fileiscifti or optiondict["textio"]):
-        theheader = copy.deepcopy(nim_hdr)
-        theheader["dim"][0] = 3
-        theheader["dim"][4] = 1
-        theheader["pixdim"][4] = 1.0
+    if theinputdata.filetype == "nifti":
+        theheader = theinputdata.copyheader(numtimepoints=1)
         savename = f"{outputname}_desc-processed_mask"
         tide_io.savetonifti(corrmask.reshape(xsize, ysize, numslices), theheader, savename)
 
@@ -654,7 +590,7 @@ def rapidtide_main(argparsingfunc):
     numvalidspatiallocs = np.shape(validvoxels)[0]
     LGR.debug(f"validvoxels shape = {numvalidspatiallocs}")
     theinputdata.setvalidvoxels(validvoxels)
-    fmri_data_valid = theinputdata.getvalidvoxels() + 0.0
+    fmri_data_valid = theinputdata.validdata() + 0.0
     LGR.verbose(
         f"original size = {np.shape(fmri_data)}, trimmed size = {np.shape(fmri_data_valid)}"
     )
@@ -714,7 +650,7 @@ def rapidtide_main(argparsingfunc):
             ),
             labels=["xtrans", "ytrans", "ztrans", "xrot", "yrot", "zrot"],
             deriv=optiondict["mot_deriv"],
-            order=1,
+            order=optiondict["mot_power"],
         )
         domotion = True
     else:
@@ -757,7 +693,7 @@ def rapidtide_main(argparsingfunc):
             append=False,
         )
 
-        if optiondict["focaldebug"]:
+        if optiondict["debug"]:
             print(f"{mergedregressors.shape=}")
             print(f"{mergedregressorlabels}")
             print(f"{fmri_data_valid.shape=}")
@@ -794,8 +730,8 @@ def rapidtide_main(argparsingfunc):
             },
         )
         # save the confound filter R2 map
-        if not optiondict["textio"]:
-            if fileiscifti:
+        if theinputdata.filetype != "text":
+            if theinputdata.filetype == "cifti":
                 timeindex = theheader["dim"][0] - 1
                 spaceindex = theheader["dim"][0]
                 theheader["dim"][timeindex] = 1
@@ -814,10 +750,9 @@ def rapidtide_main(argparsingfunc):
             nativespaceshape,
             theheader,
             bidsbasedict,
-            textio=optiondict["textio"],
-            fileiscifti=fileiscifti,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
-            cifti_hdr=cifti_hdr,
+            cifti_hdr=theinputdata.cifti_hdr,
         )
         tide_stats.makeandsavehistogram(
             confoundr2,
@@ -843,23 +778,7 @@ def rapidtide_main(argparsingfunc):
         tide_util.logmem("after confound sLFO filter")
 
         if optiondict["saveconfoundfiltered"]:
-            if not optiondict["textio"]:
-                theheader = copy.deepcopy(nim_hdr)
-                if fileiscifti:
-                    nativefmrishape = (1, 1, 1, validtimepoints, numspatiallocs)
-                    timeindex = theheader["dim"][0] - 1
-                    spaceindex = theheader["dim"][0]
-                    theheader["dim"][timeindex] = validtimepoints
-                    theheader["dim"][spaceindex] = numspatiallocs
-                else:
-                    nativefmrishape = (xsize, ysize, numslices, validtimepoints)
-                    theheader["dim"][4] = validtimepoints
-                    theheader["pixdim"][4] = fmritr
-            else:
-                nativefmrishape = (xsize, validtimepoints)
-                theheader = None
-                cifti_hdr = None
-
+            theheader = theinputdata.copyheader(numtimepoints=validtimepoints, tr=fmritr)
             maplist = [
                 (
                     fmri_data_valid,
@@ -873,23 +792,22 @@ def rapidtide_main(argparsingfunc):
                 outputname,
                 maplist,
                 validvoxels,
-                nativefmrishape,
+                theinputdata.nativefmrishape,
                 theheader,
                 bidsbasedict,
-                textio=optiondict["textio"],
-                fileiscifti=fileiscifti,
+                filetype=theinputdata.filetype,
                 rt_floattype=rt_floattype,
-                cifti_hdr=cifti_hdr,
+                cifti_hdr=theinputdata.cifti_hdr,
             )
 
     # get rid of memory we aren't using
     tide_util.logmem("before purging full sized fmri data")
     meanvalue = np.mean(
-        theinputdata.voxelbytime(),
+        theinputdata.byvoxel(),
         axis=1,
     )
     stddevvalue = np.std(
-        theinputdata.voxelbytime(),
+        theinputdata.byvoxel(),
         axis=1,
     )
     covvalue = np.where(meanvalue > 0.0, stddevvalue / meanvalue, 0.0)
@@ -902,15 +820,86 @@ def rapidtide_main(argparsingfunc):
     meanfreq = 1.0 / fmritr
     meanperiod = 1.0 * fmritr
     meanstarttime = 0.0
-    meanvec, meanmask = getglobalsignal(
+    meanvec, meanmask = tide_mask.saveregionaltimeseries(
+        "initial regressor",
+        "startregressormask",
         fmri_data,
-        optiondict,
-        includemask=internalglobalmeanincludemask,
-        excludemask=internalglobalmeanexcludemask,
-        pcacomponents=optiondict["globalpcacomponents"],
-        debug=False,
+        internalinitregressorincludemask,
+        meanfreq,
+        outputname,
+        initfile=True,
+        signalgenmethod=optiondict["initregressorsignalmethod"],
+        pcacomponents=optiondict["initregressorpcacomponents"],
+        excludemask=internalinitregressorexcludemask,
+        filedesc="regionalprefilter",
+        suffix="",
+        debug=optiondict["debug"],
     )
 
+    if brainmask is not None:
+        brainvec, dummy = tide_mask.saveregionaltimeseries(
+            "whole brain",
+            "brain",
+            fmri_data,
+            internalbrainmask,
+            meanfreq,
+            outputname,
+            filedesc="regionalprefilter",
+            suffix="",
+            debug=optiondict["debug"],
+        )
+
+    if graymask is None:
+        internalgraymask = None
+    else:
+        internalgraymask = graymask.reshape((numspatiallocs))
+        grayvec, dummy = tide_mask.saveregionaltimeseries(
+            "gray matter",
+            "GM",
+            fmri_data,
+            internalgraymask,
+            meanfreq,
+            outputname,
+            excludemask=internalinvbrainmask,
+            filedesc="regionalprefilter",
+            suffix="",
+            debug=optiondict["debug"],
+        )
+
+    if whitemask is None:
+        internalwhitemask = None
+    else:
+        internalwhitemask = whitemask.reshape((numspatiallocs))
+        whitevec, dummy = tide_mask.saveregionaltimeseries(
+            "white matter",
+            "WM",
+            fmri_data,
+            internalwhitemask,
+            meanfreq,
+            outputname,
+            excludemask=internalinvbrainmask,
+            filedesc="regionalprefilter",
+            suffix="",
+            debug=optiondict["debug"],
+        )
+
+    if csfmask is None:
+        internalcsfmask = None
+    else:
+        internalcsfmask = csfmask.reshape((numspatiallocs))
+        csfvec, dummy = tide_mask.saveregionaltimeseries(
+            "CSF",
+            "CSF",
+            fmri_data,
+            internalcsfmask,
+            meanfreq,
+            outputname,
+            excludemask=internalinvbrainmask,
+            filedesc="regionalprefilter",
+            suffix="",
+            debug=optiondict["debug"],
+        )
+
     # get rid of more memory we aren't using
     theinputdata.unload()
     uncollected = gc.collect()
@@ -925,31 +914,23 @@ def rapidtide_main(argparsingfunc):
     TimingLGR.info("Start of reference prep")
     if regressorfilename is None:
         LGR.info("no regressor file specified - will use the global mean regressor")
-        optiondict["useglobalref"] = True
+        optiondict["useinitregressorref"] = True
     else:
-        optiondict["useglobalref"] = False
+        optiondict["useinitregressorref"] = False
 
     # now set the regressor that we'll use
-    if optiondict["useglobalref"]:
+    if optiondict["useinitregressorref"]:
         LGR.verbose("using global mean as probe regressor")
         inputfreq = meanfreq
         inputperiod = meanperiod
         inputstarttime = meanstarttime
         inputvec = meanvec
-        theheader = copy.deepcopy(nim_hdr)
 
         # save the meanmask
-        if not optiondict["textio"]:
-            if fileiscifti:
-                timeindex = theheader["dim"][0] - 1
-                spaceindex = theheader["dim"][0]
-                theheader["dim"][timeindex] = 1
-                theheader["dim"][spaceindex] = numspatiallocs
-            else:
-                theheader["dim"][0] = 3
-                theheader["dim"][4] = 1
-                theheader["pixdim"][4] = 1.0
-        masklist = [(meanmask, "globalmean", "mask", None, "Voxels used to calculate global mean")]
+        theheader = theinputdata.copyheader(numtimepoints=1)
+        masklist = [
+            (meanmask, "initregressor", "mask", None, "Voxels used to calculate initial regressor")
+        ]
         tide_io.savemaplist(
             outputname,
             masklist,
@@ -957,10 +938,9 @@ def rapidtide_main(argparsingfunc):
             nativespaceshape,
             theheader,
             bidsbasedict,
-            textio=optiondict["textio"],
-            fileiscifti=fileiscifti,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
-            cifti_hdr=cifti_hdr,
+            cifti_hdr=theinputdata.cifti_hdr,
         )
         optiondict["preprocskip"] = 0
     else:
@@ -1001,7 +981,7 @@ def rapidtide_main(argparsingfunc):
     LGR.verbose(f"input freq: {inputfreq}")
     LGR.verbose(f"input start time: {inputstarttime:.3f}")
 
-    if not optiondict["useglobalref"]:
+    if not optiondict["useinitregressorref"]:
         globalcorrx, globalcorry, dummy, dummy = tide_corr.arbcorr(
             meanvec, meanfreq, inputvec, inputfreq, start2=(inputstarttime)
         )
@@ -1286,6 +1266,10 @@ def rapidtide_main(argparsingfunc):
         corrpadding=optiondict["corrpadding"],
         debug=optiondict["debug"],
     )
+    if optiondict["focaldebug"]:
+        print(
+            f"calling setreftc during initialization with length {optiondict['oversampfactor'] * validtimepoints}"
+        )
     theCorrelator.setreftc(
         np.zeros((optiondict["oversampfactor"] * validtimepoints), dtype=np.float64)
     )
@@ -1387,10 +1371,10 @@ def rapidtide_main(argparsingfunc):
     tide_util.logmem("after main array allocation")
 
     corroutlen = np.shape(trimmedcorrscale)[0]
-    if optiondict["textio"]:
+    if theinputdata.filetype == "text":
         nativecorrshape = (xsize, corroutlen)
     else:
-        if fileiscifti:
+        if theinputdata.filetype == "cifti":
             nativecorrshape = (1, 1, 1, corroutlen, numspatiallocs)
         else:
             nativecorrshape = (xsize, ysize, numslices, corroutlen)
@@ -1438,17 +1422,7 @@ def rapidtide_main(argparsingfunc):
                 initialdelay_dims,
                 initialdelay_sizes,
             ) = tide_io.readfromnifti(optiondict["initialdelayvalue"])
-            theheader = copy.deepcopy(nim_hdr)
-            if not optiondict["textio"]:
-                if fileiscifti:
-                    timeindex = theheader["dim"][0] - 1
-                    spaceindex = theheader["dim"][0]
-                    theheader["dim"][timeindex] = 1
-                    theheader["dim"][spaceindex] = numspatiallocs
-                else:
-                    theheader["dim"][0] = 3
-                    theheader["dim"][4] = 1
-                    theheader["pixdim"][4] = 1.0
+            theheader = theinputdata.copyheader(numtimepoints=1)
             if not tide_io.checkspacematch(theheader, initialdelay_header):
                 raise ValueError("fixed delay map dimensions do not match fmri dimensions")
             theinitialdelay = initialdelay.reshape(numspatiallocs)[validvoxels]
@@ -1478,9 +1452,9 @@ def rapidtide_main(argparsingfunc):
         - fmritr * numpadtrs
     )
 
-    if optiondict["textio"]:
+    if theinputdata.filetype == "text":
         nativefmrishape = (xsize, np.shape(initial_fmri_x)[0])
-    elif fileiscifti:
+    elif theinputdata.filetype == "cifti":
         nativefmrishape = (1, 1, 1, np.shape(initial_fmri_x)[0], numspatiallocs)
     else:
         nativefmrishape = (xsize, ysize, numslices, np.shape(initial_fmri_x)[0])
@@ -1495,7 +1469,7 @@ def rapidtide_main(argparsingfunc):
     # prepare for regressor refinement, if we're doing it
     if (
         optiondict["passes"] > 1
-        or optiondict["globalpreselect"]
+        or optiondict["initregressorpreselect"]
         or optiondict["dofinalrefine"]
         or optiondict["convergencethresh"] is not None
     ):
@@ -1710,6 +1684,10 @@ def rapidtide_main(argparsingfunc):
             rt_floattype=rt_floattype,
             rt_floatset=rt_floatset,
         )
+        if optiondict["focaldebug"]:
+            print(
+                f"after cleanregressor: {len(referencetc)=}, {len(cleaned_referencetc)=}, {osvalidsimcalcstart=}, {osvalidsimcalcend=}, {lagmininpts=}, {lagmaxinpts=}"
+            )
 
         # Step 0 - estimate significance
         if optiondict["numestreps"] > 0:
@@ -1737,6 +1715,10 @@ def rapidtide_main(argparsingfunc):
                     f"{outputname}_options_pregetnull_pass" + str(thepass) + ".json",
                 )
             theCorrelator.setlimits(lagmininpts, lagmaxinpts)
+            if optiondict["focaldebug"]:
+                print(
+                    f"calling setreftc prior to significance estimation with length {len(cleaned_resampref_y)}"
+                )
             theCorrelator.setreftc(cleaned_resampref_y)
             theMutualInformationator.setlimits(lagmininpts, lagmaxinpts)
             theMutualInformationator.setreftc(cleaned_resampref_y)
@@ -1904,6 +1886,7 @@ def rapidtide_main(argparsingfunc):
                 chunksize=optiondict["mp_chunksize"],
                 rt_floatset=rt_floatset,
                 rt_floattype=rt_floattype,
+                debug=optiondict["focaldebug"],
             )
         else:
             (
@@ -1928,6 +1911,7 @@ def rapidtide_main(argparsingfunc):
                 chunksize=optiondict["mp_chunksize"],
                 rt_floatset=rt_floatset,
                 rt_floattype=rt_floattype,
+                debug=optiondict["focaldebug"],
             )
         tide_util.enablemkl(optiondict["mklthreads"], debug=threaddebug)
 
@@ -1950,7 +1934,7 @@ def rapidtide_main(argparsingfunc):
         if optiondict["checkpoint"]:
             outcorrarray[:, :] = 0.0
             outcorrarray[validvoxels, :] = corrout[:, :]
-            if optiondict["textio"]:
+            if theinputdata.filetype == "text":
                 tide_io.writenpvecs(
                     outcorrarray.reshape(nativecorrshape),
                     f"{outputname}_corrout_prefit_pass" + str(thepass) + ".txt",
@@ -2142,8 +2126,8 @@ def rapidtide_main(argparsingfunc):
                     internaldespeckleincludemask[validvoxels] == 0.0, 0, 1
                 )
                 if thepass == optiondict["passes"]:
-                    if not optiondict["textio"]:
-                        if fileiscifti:
+                    if theinputdata.filetype != "text":
+                        if theinputdata.filetype == "cifti":
                             timeindex = theheader["dim"][0] - 1
                             spaceindex = theheader["dim"][0]
                             theheader["dim"][timeindex] = 1
@@ -2168,10 +2152,9 @@ def rapidtide_main(argparsingfunc):
                         nativespaceshape,
                         theheader,
                         bidsbasedict,
-                        textio=optiondict["textio"],
-                        fileiscifti=fileiscifti,
+                        filetype=theinputdata.filetype,
                         rt_floattype=rt_floattype,
-                        cifti_hdr=cifti_hdr,
+                        cifti_hdr=theinputdata.cifti_hdr,
                     )
             LGR.info(
                 f"\n\n{voxelsprocessed_fc_ds} voxels despeckled in "
@@ -2206,18 +2189,17 @@ def rapidtide_main(argparsingfunc):
                 nativespaceshape,
                 theheader,
                 bidsbasedict,
-                textio=optiondict["textio"],
-                fileiscifti=fileiscifti,
+                filetype=theinputdata.filetype,
                 rt_floattype=rt_floattype,
-                cifti_hdr=cifti_hdr,
+                cifti_hdr=theinputdata.cifti_hdr,
             )
 
             # create list of anomalous 3D regions that don't match surroundings
-            if nim_affine is not None:
+            if theinputdata.nim_affine is not None:
                 # make an atlas of anomalous patches - each patch shares the same integer value
                 step1 = tide_patch.calc_DoG(
                     outmaparray.reshape(nativespaceshape).copy(),
-                    nim_affine,
+                    theinputdata.nim_affine,
                     thesizes,
                     fwhm=optiondict["patchfwhm"],
                     ratioopt=False,
@@ -2239,10 +2221,9 @@ def rapidtide_main(argparsingfunc):
                     nativespaceshape,
                     theheader,
                     bidsbasedict,
-                    textio=optiondict["textio"],
-                    fileiscifti=fileiscifti,
+                    filetype=theinputdata.filetype,
                     rt_floattype=rt_floattype,
-                    cifti_hdr=cifti_hdr,
+                    cifti_hdr=theinputdata.cifti_hdr,
                 )
                 step2 = tide_patch.invertedflood3D(
                     step1,
@@ -2264,10 +2245,9 @@ def rapidtide_main(argparsingfunc):
                     nativespaceshape,
                     theheader,
                     bidsbasedict,
-                    textio=optiondict["textio"],
-                    fileiscifti=fileiscifti,
+                    filetype=theinputdata.filetype,
                     rt_floattype=rt_floattype,
-                    cifti_hdr=cifti_hdr,
+                    cifti_hdr=theinputdata.cifti_hdr,
                 )
 
                 patchmap = tide_patch.separateclusters(
@@ -2277,7 +2257,7 @@ def rapidtide_main(argparsingfunc):
                 )
                 # patchmap = tide_patch.getclusters(
                 #   outmaparray.reshape(nativespaceshape),
-                #    nim_affine,
+                #    theinputdata.nim_affine,
                 #    thesizes,
                 #    fwhm=optiondict["patchfwhm"],
                 #    ratioopt=True,
@@ -2300,10 +2280,9 @@ def rapidtide_main(argparsingfunc):
                     nativespaceshape,
                     theheader,
                     bidsbasedict,
-                    textio=optiondict["textio"],
-                    fileiscifti=fileiscifti,
+                    filetype=theinputdata.filetype,
                     rt_floattype=rt_floattype,
-                    cifti_hdr=cifti_hdr,
+                    cifti_hdr=theinputdata.cifti_hdr,
                 )
 
             # now shift the patches to align with the majority of the image
@@ -2318,17 +2297,7 @@ def rapidtide_main(argparsingfunc):
         )
 
         if optiondict["saveintermediatemaps"]:
-            if not optiondict["textio"]:
-                theheader = copy.deepcopy(nim_hdr)
-                if fileiscifti:
-                    timeindex = theheader["dim"][0] - 1
-                    spaceindex = theheader["dim"][0]
-                    theheader["dim"][timeindex] = 1
-                    theheader["dim"][spaceindex] = numspatiallocs
-                else:
-                    theheader["dim"][0] = 3
-                    theheader["dim"][4] = 1
-                    theheader["pixdim"][4] = 1.0
+            theheader = theinputdata.copyheader(numtimepoints=1)
             bidspasssuffix = f"_intermediatedata-pass{thepass}"
             maplist = [
                 (lagtimes, "maxtime", "map", "second", "Lag time in seconds"),
@@ -2349,10 +2318,9 @@ def rapidtide_main(argparsingfunc):
                 nativespaceshape,
                 theheader,
                 bidsbasedict,
-                textio=optiondict["textio"],
-                fileiscifti=fileiscifti,
+                filetype=theinputdata.filetype,
                 rt_floattype=rt_floattype,
-                cifti_hdr=cifti_hdr,
+                cifti_hdr=theinputdata.cifti_hdr,
             )
 
         # Step 3 - regressor refinement for next pass
@@ -2362,7 +2330,7 @@ def rapidtide_main(argparsingfunc):
         if (
             thepass < optiondict["passes"]
             or optiondict["convergencethresh"] is not None
-            or optiondict["globalpreselect"]
+            or optiondict["initregressorpreselect"]
             or optiondict["dofinalrefine"]
         ):
             LGR.info(f"\n\nRegressor refinement, pass {thepass}")
@@ -2378,7 +2346,7 @@ def rapidtide_main(argparsingfunc):
                     LGR.warning(
                         "NB: cannot exclude voxels from offset calculation mask - including for this pass"
                     )
-                    offsetmask = fitmask
+                    offsetmask = fitmask + 0
 
                 peaklag, dummy, dummy = tide_stats.gethistprops(
                     lagtimes[np.where(offsetmask > 0)],
@@ -2479,7 +2447,34 @@ def rapidtide_main(argparsingfunc):
             )
             for key, value in outputdict.items():
                 optiondict[key] = value
-        # We are done with refinement.
+
+            # Save shifted timecourses for César
+            if optiondict["saveintermediatemaps"] and optiondict["savelagregressors"]:
+                theheader = theinputdata.copyheader()
+                bidspasssuffix = f"_intermediatedata-pass{thepass}"
+                maplist = [
+                    (
+                        (theRegressorRefiner.getpaddedshiftedtcs())[:, numpadtrs:-numpadtrs],
+                        "shiftedtcs",
+                        "bold",
+                        None,
+                        "The filtered input fMRI data, in voxels used for refinement, time shifted by the negated delay in every voxel so that the moving blood component is aligned.",
+                    ),
+                ]
+                tide_io.savemaplist(
+                    f"{outputname}{bidspasssuffix}",
+                    maplist,
+                    validvoxels,
+                    nativefmrishape,
+                    theheader,
+                    bidsbasedict,
+                    filetype=theinputdata.filetype,
+                    rt_floattype=rt_floattype,
+                    cifti_hdr=theinputdata.cifti_hdr,
+                    debug=True,
+                )
+            # We are done with refinement.
+        # End of main pass loop
 
     if optiondict["convergencethresh"] is None:
         optiondict["actual_passes"] = optiondict["passes"]
@@ -2530,10 +2525,10 @@ def rapidtide_main(argparsingfunc):
             coherencefreqstep,
             coherencefreqaxissize,
         ) = theCoherer.getaxisinfo()
-        if optiondict["textio"]:
+        if theinputdata.filetype == "text":
             nativecoherenceshape = (xsize, coherencefreqaxissize)
         else:
-            if fileiscifti:
+            if theinputdata.filetype == "cifti":
                 nativecoherenceshape = (1, 1, 1, coherencefreqaxissize, numspatiallocs)
             else:
                 nativecoherenceshape = (xsize, ysize, numslices, coherencefreqaxissize)
@@ -2583,19 +2578,11 @@ def rapidtide_main(argparsingfunc):
         tide_util.enablemkl(optiondict["mklthreads"], debug=threaddebug)
 
         # save the results of the calculations
-        if not optiondict["textio"]:
-            theheader = copy.deepcopy(nim_hdr)
-            theheader["toffset"] = coherencefreqstart
-            theheader["pixdim"][4] = coherencefreqstep
-            if fileiscifti:
-                timeindex = theheader["dim"][0] - 1
-                spaceindex = theheader["dim"][0]
-                theheader["dim"][timeindex] = coherencefreqaxissize
-                theheader["dim"][spaceindex] = numspatiallocs
-            else:
-                theheader["dim"][0] = 3
-                theheader["dim"][4] = coherencefreqaxissize
-                theheader["pixdim"][4] = 1.0
+        theheader = theinputdata.copyheader(
+            numtimepoints=coherencefreqaxissize,
+            tr=coherencefreqstep,
+            toffset=coherencefreqstart,
+        )
         maplist = [(coherencefunc, "coherence", "info", None, "Coherence function")]
         tide_io.savemaplist(
             outputname,
@@ -2604,10 +2591,9 @@ def rapidtide_main(argparsingfunc):
             nativecoherenceshape,
             theheader,
             bidsbasedict,
-            textio=optiondict["textio"],
-            fileiscifti=fileiscifti,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
-            cifti_hdr=cifti_hdr,
+            cifti_hdr=theinputdata.cifti_hdr,
         )
 
         TimingLGR.info(
@@ -2703,7 +2689,7 @@ def rapidtide_main(argparsingfunc):
                 theinputdata.setvalidtimes(validstart, validend)
                 theinputdata.setvalidvoxels(validvoxels)
 
-            fmri_data_valid = theinputdata.getvalidvoxels() + 0.0
+            fmri_data_valid = theinputdata.validdata() + 0.0
 
             if optiondict["docvrmap"]:
                 # percent normalize the fmri data
@@ -2806,20 +2792,13 @@ def rapidtide_main(argparsingfunc):
 
         if optiondict["debug"]:
             # dump the fmri input file going to sLFO filter
-            if not optiondict["textio"]:
+            if theinputdata.filetype != "text":
                 outfmriarray = np.zeros(internalfmrishape, dtype=rt_floattype)
-                theheader = copy.deepcopy(nim_hdr)
-                if fileiscifti:
-                    timeindex = theheader["dim"][0] - 1
-                    spaceindex = theheader["dim"][0]
-                    theheader["dim"][timeindex] = np.shape(outfmriarray)[1]
-                    theheader["dim"][spaceindex] = numspatiallocs
-                else:
-                    theheader["dim"][4] = np.shape(outfmriarray)[1]
-                    theheader["pixdim"][4] = fmritr
+                theheader = theinputdata.copyheader(
+                    numtimepoints=np.shape(outfmriarray)[1], tr=fmritr
+                )
             else:
                 theheader = None
-                cifti_hdr = None
                 outfmriarray = None
 
             maplist = [
@@ -2838,10 +2817,9 @@ def rapidtide_main(argparsingfunc):
                 nativefmrishape,
                 theheader,
                 bidsbasedict,
-                textio=optiondict["textio"],
-                fileiscifti=fileiscifti,
+                filetype=theinputdata.filetype,
                 rt_floattype=rt_floattype,
-                cifti_hdr=cifti_hdr,
+                cifti_hdr=theinputdata.cifti_hdr,
             )
         else:
             outfmriarray = None
@@ -2850,7 +2828,7 @@ def rapidtide_main(argparsingfunc):
         if optiondict["refinedelay"]:
             TimingLGR.info("Delay refinement start")
             LGR.info("\n\nDelay refinement")
-            if optiondict["delayoffsetgausssigma"] < 0.0 and not optiondict["textio"]:
+            if optiondict["delayoffsetgausssigma"] < 0.0 and theinputdata.filetype != "text":
                 # set gausssigma automatically
                 optiondict["delayoffsetgausssigma"] = np.mean([xdim, ydim, slicethickness]) / 2.0
 
@@ -2888,8 +2866,7 @@ def rapidtide_main(argparsingfunc):
                         (xdim, ydim, slicethickness),
                         gausssigma=optiondict["delayoffsetgausssigma"],
                         patchthresh=optiondict["delaypatchthresh"],
-                        fileiscifti=fileiscifti,
-                        textio=optiondict["textio"],
+                        filetype=theinputdata.filetype,
                         rt_floattype="float64",
                         debug=optiondict["debug"],
                     )
@@ -2934,8 +2911,7 @@ def rapidtide_main(argparsingfunc):
                         (xdim, ydim, slicethickness),
                         gausssigma=optiondict["delayoffsetgausssigma"],
                         patchthresh=optiondict["delaypatchthresh"],
-                        fileiscifti=False,
-                        textio=False,
+                        filetype=theinputdata.filetype,
                         rt_floattype=rt_floattype,
                         debug=optiondict["debug"],
                     )
@@ -3052,6 +3028,79 @@ def rapidtide_main(argparsingfunc):
                     "message3": "voxels",
                 },
             )
+            if internalinitregressorincludemask is not None:
+                thisincludemask = internalinitregressorincludemask[validvoxels]
+            else:
+                thisincludemask = None
+            if internalinitregressorexcludemask is not None:
+                thisexcludemask = internalinitregressorexcludemask[validvoxels]
+            else:
+                thisexcludemask = None
+
+            meanvec, meanmask = tide_mask.saveregionaltimeseries(
+                "initial regressor",
+                "startregressormask",
+                filtereddata,
+                thisincludemask,
+                meanfreq,
+                outputname,
+                initfile=True,
+                excludemask=thisexcludemask,
+                filedesc="regionalpostfilter",
+                suffix="",
+                debug=optiondict["debug"],
+            )
+            if brainmask is not None:
+                brainvec, dummy = tide_mask.saveregionaltimeseries(
+                    "whole brain",
+                    "brain",
+                    filtereddata,
+                    internalbrainmask[validvoxels],
+                    meanfreq,
+                    outputname,
+                    filedesc="regionalpostfilter",
+                    suffix="",
+                    debug=optiondict["debug"],
+                )
+            if graymask is not None:
+                grayvec, dummy = tide_mask.saveregionaltimeseries(
+                    "gray matter",
+                    "GM",
+                    filtereddata,
+                    internalgraymask[validvoxels],
+                    meanfreq,
+                    outputname,
+                    excludemask=internalinvbrainmask[validvoxels],
+                    filedesc="regionalpostfilter",
+                    suffix="",
+                    debug=optiondict["debug"],
+                )
+            if whitemask is not None:
+                whitevec, dummy = tide_mask.saveregionaltimeseries(
+                    "white matter",
+                    "WM",
+                    filtereddata,
+                    internalwhitemask[validvoxels],
+                    meanfreq,
+                    outputname,
+                    excludemask=internalinvbrainmask[validvoxels],
+                    filedesc="regionalpostfilter",
+                    suffix="",
+                    debug=optiondict["debug"],
+                )
+            if csfmask is not None:
+                grayvec, dummy = tide_mask.saveregionaltimeseries(
+                    "CSF",
+                    "CSF",
+                    filtereddata,
+                    internalcsfmask[validvoxels],
+                    meanfreq,
+                    outputname,
+                    excludemask=internalinvbrainmask[validvoxels],
+                    filedesc="regionalpostfilter",
+                    suffix="",
+                    debug=optiondict["debug"],
+                )
             tide_util.logmem("after sLFO filter")
             LGR.info("")
     else:
@@ -3145,21 +3194,7 @@ def rapidtide_main(argparsingfunc):
 
     # write the 3D maps that need to be remapped
     TimingLGR.info("Start saving maps")
-    if not optiondict["textio"]:
-        theheader = copy.deepcopy(nim_hdr)
-        if fileiscifti:
-            timeindex = theheader["dim"][0] - 1
-            spaceindex = theheader["dim"][0]
-            theheader["dim"][timeindex] = 1
-            theheader["dim"][spaceindex] = numspatiallocs
-        else:
-            theheader["dim"][0] = 3
-            theheader["dim"][4] = 1
-            theheader["pixdim"][4] = 1.0
-    else:
-        theheader = None
-        cifti_hdr = None
-
+    theheader = theinputdata.copyheader(numtimepoints=1)
     savelist = [
         (lagtimes, "maxtime", "map", "second", "Lag time in seconds"),
         (
@@ -3264,10 +3299,9 @@ def rapidtide_main(argparsingfunc):
         nativespaceshape,
         theheader,
         bidsbasedict,
-        textio=optiondict["textio"],
-        fileiscifti=fileiscifti,
+        filetype=theinputdata.filetype,
         rt_floattype=rt_floattype,
-        cifti_hdr=cifti_hdr,
+        cifti_hdr=theinputdata.cifti_hdr,
     )
     namesuffix = "_desc-MTT_hist"
     tide_stats.makeandsavehistogram(
@@ -3424,10 +3458,9 @@ def rapidtide_main(argparsingfunc):
             nativespaceshape,
             theheader,
             bidsbasedict,
-            textio=optiondict["textio"],
-            fileiscifti=fileiscifti,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
-            cifti_hdr=cifti_hdr,
+            cifti_hdr=theinputdata.cifti_hdr,
         )
 
         if optiondict["refinedelay"] and False:
@@ -3481,10 +3514,9 @@ def rapidtide_main(argparsingfunc):
                 nativespaceshape,
                 theheader,
                 bidsbasedict,
-                textio=optiondict["textio"],
-                fileiscifti=fileiscifti,
+                filetype=theinputdata.filetype,
                 rt_floattype=rt_floattype,
-                cifti_hdr=cifti_hdr,
+                cifti_hdr=theinputdata.cifti_hdr,
             )
 
         del fmri_data_valid
@@ -3518,6 +3550,8 @@ def rapidtide_main(argparsingfunc):
         maplist.append((graymask, "GM", "mask", None, "Gray matter mask"))
     if whitemask is not None:
         maplist.append((whitemask, "WM", "mask", None, "White matter mask"))
+    if csfmask is not None:
+        maplist.append((csfmask, "CSF", "mask", None, "CSF mask"))
     tide_io.savemaplist(
         outputname,
         maplist,
@@ -3525,10 +3559,9 @@ def rapidtide_main(argparsingfunc):
         nativespaceshape,
         theheader,
         bidsbasedict,
-        textio=optiondict["textio"],
-        fileiscifti=fileiscifti,
+        filetype=theinputdata.filetype,
         rt_floattype=rt_floattype,
-        cifti_hdr=cifti_hdr,
+        cifti_hdr=theinputdata.cifti_hdr,
     )
     del meanvalue
 
@@ -3564,22 +3597,21 @@ def rapidtide_main(argparsingfunc):
             nativespaceshape,
             theheader,
             bidsbasedict,
-            textio=optiondict["textio"],
-            fileiscifti=fileiscifti,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
-            cifti_hdr=cifti_hdr,
+            cifti_hdr=theinputdata.cifti_hdr,
         )
         del masklist
 
-    if (optiondict["passes"] > 1 or optiondict["globalpreselect"]) and optiondict[
+    if (optiondict["passes"] > 1 or optiondict["initregressorpreselect"]) and optiondict[
         "refinestopreason"
     ] != "emptymask":
         refinemask = theRegressorRefiner.getrefinemask()
-        if optiondict["globalpreselect"]:
+        if optiondict["initregressorpreselect"]:
             masklist = [
                 (
                     refinemask,
-                    "globalmeanpreselect",
+                    "initregressorpreselect",
                     "mask",
                     None,
                     "I really don't know what this file is for",
@@ -3594,10 +3626,9 @@ def rapidtide_main(argparsingfunc):
             nativespaceshape,
             theheader,
             bidsbasedict,
-            textio=optiondict["textio"],
-            fileiscifti=fileiscifti,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
-            cifti_hdr=cifti_hdr,
+            cifti_hdr=theinputdata.cifti_hdr,
         )
         del refinemask
 
@@ -3609,21 +3640,11 @@ def rapidtide_main(argparsingfunc):
     del fitmask
 
     # now do the 4D maps of the similarity function and friends
-    if not optiondict["textio"]:
-        theheader = copy.deepcopy(nim_hdr)
-        theheader["toffset"] = corrscale[corrorigin - lagmininpts]
-        if fileiscifti:
-            timeindex = theheader["dim"][0] - 1
-            spaceindex = theheader["dim"][0]
-            theheader["dim"][timeindex] = np.shape(outcorrarray)[1]
-            theheader["dim"][spaceindex] = numspatiallocs
-        else:
-            theheader["dim"][4] = np.shape(outcorrarray)[1]
-            theheader["pixdim"][4] = corrtr
-    else:
-        theheader = None
-        cifti_hdr = None
-
+    theheader = theinputdata.copyheader(
+        numtimepoints=np.shape(outcorrarray)[1],
+        tr=corrtr,
+        toffset=(corrscale[corrorigin - lagmininpts]),
+    )
     if (
         optiondict["savecorrout"]
         or (optiondict["outputlevel"] != "min")
@@ -3650,10 +3671,9 @@ def rapidtide_main(argparsingfunc):
             nativecorrshape,
             theheader,
             bidsbasedict,
-            textio=optiondict["textio"],
-            fileiscifti=fileiscifti,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
-            cifti_hdr=cifti_hdr,
+            cifti_hdr=theinputdata.cifti_hdr,
         )
     del windowout
     del gaussout
@@ -3668,20 +3688,7 @@ def rapidtide_main(argparsingfunc):
     # now save all the files that are of the same length as the input data file and masked
     if outfmriarray is None:
         outfmriarray = np.zeros(internalfmrishape, dtype=rt_floattype)
-    if not optiondict["textio"]:
-        theheader = copy.deepcopy(nim_hdr)
-        if fileiscifti:
-            timeindex = theheader["dim"][0] - 1
-            spaceindex = theheader["dim"][0]
-            theheader["dim"][timeindex] = np.shape(outfmriarray)[1]
-            theheader["dim"][spaceindex] = numspatiallocs
-        else:
-            theheader["dim"][4] = np.shape(outfmriarray)[1]
-            theheader["pixdim"][4] = fmritr
-    else:
-        theheader = None
-        cifti_hdr = None
-
+    theheader = theinputdata.copyheader(numtimepoints=np.shape(outfmriarray)[1], tr=fmritr)
     maplist = []
     if optiondict["saveallsLFOfiltfiles"] and (
         optiondict["dolinfitfilt"] or optiondict["docvrmap"]
@@ -3775,10 +3782,9 @@ def rapidtide_main(argparsingfunc):
             nativefmrishape,
             theheader,
             bidsbasedict,
-            textio=optiondict["textio"],
-            fileiscifti=fileiscifti,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
-            cifti_hdr=cifti_hdr,
+            cifti_hdr=theinputdata.cifti_hdr,
         )
 
     # clean up