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

rapidtide/workflows/retroregress.py

@@ -28,12 +28,14 @@ import numpy as np
 
 import rapidtide.filter as tide_filt
 import rapidtide.io as tide_io
+import rapidtide.maskutil as tide_mask
 import rapidtide.miscmath as tide_math
 import rapidtide.multiproc as tide_multiproc
 import rapidtide.refinedelay as tide_refinedelay
 import rapidtide.resample as tide_resample
 import rapidtide.stats as tide_stats
 import rapidtide.util as tide_util
+import rapidtide.voxelData as tide_voxelData
 import rapidtide.workflows.parser_funcs as pf
 import rapidtide.workflows.regressfrommaps as tide_regressfrommaps
 
@@ -127,13 +129,14 @@ def _get_parser():
         dest="outputlevel",
         action="store",
         type=str,
-        choices=["min", "less", "normal", "more", "max"],
+        choices=["min", "less", "normal", "more", "max", "onlyregressors"],
         help=(
             "The level of file output produced.  'min' produces only absolutely essential files, 'less' adds in "
             "the sLFO filtered data (rather than just filter efficacy metrics), 'normal' saves what you "
             "would typically want around for interactive data exploration, "
             "'more' adds files that are sometimes useful, and 'max' outputs anything you might possibly want. "
-            "Selecting 'max' will produce ~3x your input datafile size as output.  "
+            "Selecting 'max' will produce ~3x your input datafile size as output.  'onlyregressors' will ONLY generate the "
+            "voxelwise timecourses to filter and save them without actually running the filter. "
             f'Default is "normal".'
         ),
         default="normal",
@@ -271,28 +274,39 @@ def retroregress(args):
         args.savenormalsLFOfiltfiles = False
         args.savemovingsignal = False
         args.saveallsLFOfiltfiles = False
+        args.saveEVsandquit = False
     elif args.outputlevel == "less":
         args.saveminimumsLFOfiltfiles = True
         args.savenormalsLFOfiltfiles = False
         args.savemovingsignal = False
         args.saveallsLFOfiltfiles = False
+        args.saveEVsandquit = False
     elif args.outputlevel == "normal":
         args.saveminimumsLFOfiltfiles = True
         args.savenormalsLFOfiltfiles = True
         args.savemovingsignal = False
         args.saveallsLFOfiltfiles = False
+        args.saveEVsandquit = False
     elif args.outputlevel == "more":
         args.saveminimumsLFOfiltfiles = True
         args.savenormalsLFOfiltfiles = True
         args.savemovingsignal = True
         args.saveallsLFOfiltfiles = False
+        args.saveEVsandquit = False
     elif args.outputlevel == "max":
         args.saveminimumsLFOfiltfiles = True
         args.savenormalsLFOfiltfiles = True
         args.savemovingsignal = True
         args.saveallsLFOfiltfiles = True
+        args.saveEVsandquit = False
+    elif args.outputlevel == "onlyregressors":
+        args.saveminimumsLFOfiltfiles = False
+        args.savenormalsLFOfiltfiles = False
+        args.savemovingsignal = False
+        args.saveallsLFOfiltfiles = False
+        args.saveEVsandquit = True
     else:
-        print(f"illegal output level {args['outputlevel']}")
+        print(f"illegal output level {args.outputlevel}")
         sys.exit()
 
     # save the raw and formatted command lines
@@ -370,19 +384,19 @@ def retroregress(args):
 
     # read the fmri input files
     print("reading fmrifile")
-    fmri_input, fmri_data, fmri_header, fmri_dims, fmri_sizes = tide_io.readfromnifti(
-        args.fmrifile
-    )
+    theinputdata = tide_voxelData.VoxelData(args.fmrifile)
+    xsize, ysize, numslices, timepoints = theinputdata.getdims()
+    xdim, ydim, slicethickness, fmritr = theinputdata.getsizes()
+    fmri_header = theinputdata.copyheader()
+    fmri_data = theinputdata.byvol()
+    numspatiallocs = theinputdata.numspatiallocs
 
     # create the canary file
     Path(f"{outputname}_RETROISRUNNING.txt").touch()
 
     if args.debug:
         print(f"{fmri_data.shape=}")
-    xdim, ydim, slicedim, fmritr = tide_io.parseniftisizes(fmri_sizes)
-    xsize, ysize, numslices, timepoints = tide_io.parseniftidims(fmri_dims)
-    numspatiallocs = int(xsize) * int(ysize) * int(numslices)
-    fmri_data_spacebytime = fmri_data.reshape((numspatiallocs, timepoints))
+    fmri_data_spacebytime = theinputdata.byvoxel()
     if args.debug:
         print(f"{fmri_data_spacebytime.shape=}")
 
@@ -584,9 +598,7 @@ def retroregress(args):
 
     if args.debug:
         # dump the fmri input file going to glm
-        theheader = copy.deepcopy(fmri_header)
-        theheader["dim"][4] = validtimepoints
-        theheader["pixdim"][4] = fmritr
+        theheader = theinputdata.copyheader(numtimepoints=validtimepoints, tr=fmritr)
 
         maplist = [
             (
@@ -604,8 +616,7 @@ def retroregress(args):
             (xsize, ysize, numslices, validtimepoints),
             theheader,
             bidsbasedict,
-            textio=therunoptions["textio"],
-            fileiscifti=False,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
             cifti_hdr=None,
         )
@@ -618,7 +629,7 @@ def retroregress(args):
 
         if args.delayoffsetgausssigma < 0.0:
             # set gausssigma automatically
-            args.delayoffsetgausssigma = np.mean([xdim, ydim, slicedim]) / 2.0
+            args.delayoffsetgausssigma = np.mean([xdim, ydim, slicethickness]) / 2.0
 
         TimingLGR.info("Refinement calibration start")
         regressderivratios, regressrvalues = tide_refinedelay.getderivratios(
@@ -652,11 +663,9 @@ def retroregress(args):
                     regressderivratios,
                     (xsize, ysize, numslices),
                     validvoxels,
-                    (xdim, ydim, slicedim),
+                    (xdim, ydim, slicethickness),
                     gausssigma=args.delayoffsetgausssigma,
                     patchthresh=args.delaypatchthresh,
-                    fileiscifti=False,
-                    textio=False,
                     rt_floattype=rt_floattype,
                     debug=args.debug,
                 )
@@ -704,11 +713,9 @@ def retroregress(args):
                     regressderivratios[i, :],
                     (xsize, ysize, numslices),
                     validvoxels,
-                    (xdim, ydim, slicedim),
+                    (xdim, ydim, slicethickness),
                     gausssigma=args.delayoffsetgausssigma,
                     patchthresh=args.delaypatchthresh,
-                    fileiscifti=False,
-                    textio=False,
                     rt_floattype=rt_floattype,
                     debug=args.debug,
                 )
@@ -725,16 +732,17 @@ def retroregress(args):
                 )
             refinedvoxelstoreport = filteredregressderivratios.shape[1]
 
-        namesuffix = "_desc-delayoffset_hist"
-        tide_stats.makeandsavehistogram(
-            delayoffset,
-            therunoptions["histlen"],
-            1,
-            outputname + namesuffix,
-            displaytitle="Histogram of delay offsets calculated from GLM",
-            dictvarname="delayoffsethist",
-            thedict=None,
-        )
+        if not args.saveEVsandquit:
+            namesuffix = "_desc-delayoffset_hist"
+            tide_stats.makeandsavehistogram(
+                delayoffset,
+                therunoptions["histlen"],
+                1,
+                outputname + namesuffix,
+                displaytitle="Histogram of delay offsets calculated from GLM",
+                dictvarname="delayoffsethist",
+                thedict=None,
+            )
         lagtimesrefined_valid = lagtimes_valid + delayoffset
 
         TimingLGR.info(
@@ -782,248 +790,546 @@ def retroregress(args):
         nprocs_regressionfilt=args.nprocs,
         regressderivs=args.regressderivs,
         showprogressbar=args.showprogressbar,
+        saveEVsandquit=args.saveEVsandquit,
         debug=args.debug,
     )
-    print(f"filtered {voxelsprocessed_regressionfilt} voxels")
-    TimingLGR.info(
-        "sLFO filtering done",
-        {
-            "message2": voxelsprocessed_regressionfilt,
-            "message3": "voxels",
-        },
-    )
-    # finalrawvariance = tide_math.imagevariance(filtereddata, None, 1.0 / fmritr)
-    finalvariance = tide_math.imagevariance(filtereddata, theprefilter, 1.0 / fmritr)
 
-    divlocs = np.where(finalvariance > 0.0)
-    varchange = initialvariance * 0.0
-    varchange[divlocs] = 100.0 * (finalvariance[divlocs] / initialvariance[divlocs] - 1.0)
+    if not args.saveEVsandquit:
+        print(f"filtered {voxelsprocessed_regressionfilt} voxels")
+        TimingLGR.info(
+            "sLFO filtering done",
+            {
+                "message2": voxelsprocessed_regressionfilt,
+                "message3": "voxels",
+            },
+        )
+        finalvariance = tide_math.imagevariance(filtereddata, theprefilter, 1.0 / fmritr)
+
+        divlocs = np.where(finalvariance > 0.0)
+        varchange = initialvariance * 0.0
+        varchange[divlocs] = 100.0 * (finalvariance[divlocs] / initialvariance[divlocs] - 1.0)
+
+        # save regional timecourses if masks are defined
+        # read in the anatomic masks
+        anatomiclist = [
+            ["brainmaskincludename", "brainmaskincludevals", "brainmask"],
+            ["graymatterincludename", "graymatterincludevals", "graymattermask"],
+            ["whitematterincludename", "whitematterincludevals", "whitemattermask"],
+            ["csfincludename", "csfincludevals", "csfmask"],
+        ]
+        anatomicmasks = []
+        for thisanatomic in anatomiclist:
+            if therunoptions[thisanatomic[0]] is not None:
+                anatomicmasks.append(
+                    tide_mask.readamask(
+                        therunoptions[thisanatomic[0]],
+                        theinputdata.nim_hdr,
+                        xsize,
+                        istext=(theinputdata.filetype == "text"),
+                        valslist=therunoptions[thisanatomic[1]],
+                        maskname=thisanatomic[2],
+                        tolerance=therunoptions["spatialtolerance"],
+                        debug=args.focaldebug,
+                    )
+                )
+                anatomicmasks[-1] = np.uint16(np.where(anatomicmasks[-1] > 0.1, 1, 0))
+            else:
+                anatomicmasks.append(None)
+        brainmask = anatomicmasks[0]
+        graymask = anatomicmasks[1]
+        whitemask = anatomicmasks[2]
+        csfmask = anatomicmasks[3]
+
+        """if internalinitregressorincludemask is not None:
+            thisincludemask = internalinitregressorincludemask[validvoxels]
+        else:
+            thisincludemask = None
+        if internalinitregressorexcludemask is not None:
+            thisexcludemask = internalinitregressorexcludemask[validvoxels]
+        else:
+            thisexcludemask = None
 
-    """divlocs = np.where(finalrawvariance > 0.0)
-    rawvarchange = initialrawvariance * 0.0
-    rawvarchange[divlocs] = 100.0 * (finalrawvariance[divlocs] / initialrawvariance[divlocs] - 1.0)"""
+        meanvec, meanmask = tide_mask.saveregionaltimeseries(
+            "initial regressor",
+            "startregressormask",
+            filtereddata,
+            thisincludemask,
+            1.0 / fmritr,
+            outputname,
+            initfile=True,
+            excludemask=thisexcludemask,
+            filedesc="regionalpostfilter",
+            suffix="",
+            debug=args.debug,
+        )"""
+        # reformat the anatomic masks, if they exist
+        if brainmask is None:
+            invbrainmask = None
 
-    # save outputs
-    TimingLGR.info("Starting output save")
-    theheader = copy.deepcopy(lagtimes_header)
-    if mode == "glm":
-        maplist = [
-            (
-                initialvariance,
-                "lfofilterInbandVarianceBefore",
-                "map",
-                None,
-                "Inband variance prior to filtering",
-            ),
-            (
-                finalvariance,
-                "lfofilterInbandVarianceAfter",
-                "map",
-                None,
-                "Inband variance after filtering",
-            ),
-            (
-                varchange,
-                "lfofilterInbandVarianceChange",
-                "map",
-                "percent",
-                "Change in inband variance after filtering, in percent",
-            ),
-            # (
-            #   initialrawvariance,
-            #    "lfofilterTotalVarianceBefore",
-            #    "map",
-            #    None,
-            #    "Total variance prior to filtering",
-            # ),
-            # (
-            #    finalrawvariance,
-            #    "lfofilterTotalVarianceAfter",
-            #    "map",
-            #    None,
-            #    "Total variance after filtering",
-            # ),
-            # (
-            #    rawvarchange,
-            #    "lfofilterTotalVarianceChange",
-            #    "map",
-            #    "percent",
-            #    "Change in total variance after filtering, in percent",
-            # ),
-        ]
-        if args.saveminimumsLFOfiltfiles:
-            maplist += [
+            internalbrainmask = None
+            internalinvbrainmask = None
+        else:
+            invbrainmask = 1 - brainmask
+            internalbrainmask = brainmask.reshape((numspatiallocs))
+            internalinvbrainmask = invbrainmask.reshape((numspatiallocs))
+        if graymask is None:
+            internalgraymask = None
+        else:
+            internalgraymask = graymask.reshape((numspatiallocs))
+        if whitemask is None:
+            internalwhitemask = None
+        else:
+            internalwhitemask = whitemask.reshape((numspatiallocs))
+        if csfmask is None:
+            internalcsfmask = None
+        else:
+            internalcsfmask = csfmask.reshape((numspatiallocs))
+        if brainmask is not None:
+            brainvec, dummy = tide_mask.saveregionaltimeseries(
+                "whole brain",
+                "brain",
+                filtereddata,
+                internalbrainmask[validvoxels],
+                1.0 / fmritr,
+                outputname,
+                filedesc="regionalpostfilter",
+                suffix="",
+                debug=args.debug,
+            )
+        if graymask is not None:
+            grayvec, dummy = tide_mask.saveregionaltimeseries(
+                "gray matter",
+                "GM",
+                filtereddata,
+                internalgraymask[validvoxels],
+                1.0 / fmritr,
+                outputname,
+                excludemask=internalinvbrainmask[validvoxels],
+                filedesc="regionalpostfilter",
+                suffix="",
+                debug=args.debug,
+            )
+        if whitemask is not None:
+            whitevec, dummy = tide_mask.saveregionaltimeseries(
+                "white matter",
+                "WM",
+                filtereddata,
+                internalwhitemask[validvoxels],
+                1.0 / fmritr,
+                outputname,
+                excludemask=internalinvbrainmask[validvoxels],
+                filedesc="regionalpostfilter",
+                suffix="",
+                debug=args.debug,
+            )
+        if csfmask is not None:
+            grayvec, dummy = tide_mask.saveregionaltimeseries(
+                "CSF",
+                "CSF",
+                filtereddata,
+                internalcsfmask[validvoxels],
+                1.0 / fmritr,
+                outputname,
+                excludemask=internalinvbrainmask[validvoxels],
+                filedesc="regionalpostfilter",
+                suffix="",
+                debug=args.debug,
+            )
+
+        # save outputs
+        TimingLGR.info("Starting output save")
+        theheader = copy.deepcopy(lagtimes_header)
+        if mode == "glm":
+            maplist = [
                 (
-                    r2value,
-                    "lfofilterR2",
+                    initialvariance,
+                    "lfofilterInbandVarianceBefore",
                     "map",
                     None,
-                    "Squared R value of the GLM fit (proportion of variance explained)",
+                    "Inband variance prior to filtering",
                 ),
+                (
+                    finalvariance,
+                    "lfofilterInbandVarianceAfter",
+                    "map",
+                    None,
+                    "Inband variance after filtering",
+                ),
+                (
+                    varchange,
+                    "lfofilterInbandVarianceChange",
+                    "map",
+                    "percent",
+                    "Change in inband variance after filtering, in percent",
+                ),
+                # (
+                #   initialrawvariance,
+                #    "lfofilterTotalVarianceBefore",
+                #    "map",
+                #    None,
+                #    "Total variance prior to filtering",
+                # ),
+                # (
+                #    finalrawvariance,
+                #    "lfofilterTotalVarianceAfter",
+                #    "map",
+                #    None,
+                #    "Total variance after filtering",
+                # ),
+                # (
+                #    rawvarchange,
+                #    "lfofilterTotalVarianceChange",
+                #    "map",
+                #    "percent",
+                #    "Change in total variance after filtering, in percent",
+                # ),
             ]
-        if args.savenormalsLFOfiltfiles:
-            maplist += [
-                (rvalue, "lfofilterR", "map", None, "R value of the GLM fit"),
-                (sLFOfitmean, "lfofilterMean", "map", None, "Intercept from GLM fit"),
-            ]
-    else:
-        maplist = [
-            (initialvariance, "lfofilterInbandVarianceBefore", "map", None),
-            (finalvariance, "lfofilterInbandVarianceAfter", "map", None),
-            (varchange, "CVRVariance", "map", None),
-        ]
-        if args.savenormalsLFOfiltfiles:
-            maplist += [
-                (rvalue, "CVRR", "map", None),
-                (r2value, "CVRR2", "map", None),
-                (fitcoeff, "CVR", "map", "percent"),
-            ]
-    bidsdict = bidsbasedict.copy()
-
-    if args.debug or args.focaldebug:
-        maplist += [
-            (
-                lagtimes_valid,
-                "maxtimeREAD",
-                "map",
-                "second",
-                "Lag time in seconds used for calculation",
-            ),
-            (corrmask_valid, "corrfitREAD", "mask", None, "Correlation mask used for calculation"),
-            (procmask_valid, "processedREAD", "mask", None, "Processed mask used for calculation"),
-        ]
-    if args.savenormalsLFOfiltfiles:
-        if args.regressderivs > 0 or args.refinedelay:
-            maplist += [
-                (fitcoeff[:, 0], "lfofilterCoeff", "map", None, "Fit coefficient"),
-                (fitNorm[:, 0], "lfofilterNorm", "map", None, "Normalized fit coefficient"),
-            ]
-            for thederiv in range(1, args.regressderivs + 1):
+            if args.saveminimumsLFOfiltfiles:
                 maplist += [
                     (
-                        fitcoeff[:, thederiv],
-                        f"lfofilterCoeffDeriv{thederiv}",
+                        r2value,
+                        "lfofilterR2",
                         "map",
                         None,
-                        f"Fit coefficient for temporal derivative {thederiv}",
-                    ),
-                    (
-                        fitNorm[:, thederiv],
-                        f"lfofilterNormDeriv{thederiv}",
-                        "map",
-                        None,
-                        f"Normalized fit coefficient for temporal derivative {thederiv}",
+                        "Squared R value of the GLM fit (proportion of variance explained)",
                     ),
                 ]
+            if args.savenormalsLFOfiltfiles:
+                maplist += [
+                    (rvalue, "lfofilterR", "map", None, "R value of the GLM fit"),
+                    (sLFOfitmean, "lfofilterMean", "map", None, "Intercept from GLM fit"),
+                ]
         else:
+            maplist = [
+                (initialvariance, "lfofilterInbandVarianceBefore", "map", None),
+                (finalvariance, "lfofilterInbandVarianceAfter", "map", None),
+                (varchange, "CVRVariance", "map", None),
+            ]
+            if args.savenormalsLFOfiltfiles:
+                maplist += [
+                    (rvalue, "CVRR", "map", None),
+                    (r2value, "CVRR2", "map", None),
+                    (fitcoeff, "CVR", "map", "percent"),
+                ]
+        bidsdict = bidsbasedict.copy()
+
+        if args.debug or args.focaldebug:
             maplist += [
-                (fitcoeff, "lfofilterCoeff", "map", None, "Fit coefficient"),
-                (fitNorm, "lfofilterNorm", "map", None, "Normalized fit coefficient"),
+                (
+                    lagtimes_valid,
+                    "maxtimeREAD",
+                    "map",
+                    "second",
+                    "Lag time in seconds used for calculation",
+                ),
+                (
+                    corrmask_valid,
+                    "corrfitREAD",
+                    "mask",
+                    None,
+                    "Correlation mask used for calculation",
+                ),
+                (
+                    procmask_valid,
+                    "processedREAD",
+                    "mask",
+                    None,
+                    "Processed mask used for calculation",
+                ),
             ]
+        if args.savenormalsLFOfiltfiles:
+            if args.regressderivs > 0 or args.refinedelay:
+                maplist += [
+                    (fitcoeff[:, 0], "lfofilterCoeff", "map", None, "Fit coefficient"),
+                    (fitNorm[:, 0], "lfofilterNorm", "map", None, "Normalized fit coefficient"),
+                ]
+                for thederiv in range(1, args.regressderivs + 1):
+                    maplist += [
+                        (
+                            fitcoeff[:, thederiv],
+                            f"lfofilterCoeffDeriv{thederiv}",
+                            "map",
+                            None,
+                            f"Fit coefficient for temporal derivative {thederiv}",
+                        ),
+                        (
+                            fitNorm[:, thederiv],
+                            f"lfofilterNormDeriv{thederiv}",
+                            "map",
+                            None,
+                            f"Normalized fit coefficient for temporal derivative {thederiv}",
+                        ),
+                    ]
+            else:
+                maplist += [
+                    (fitcoeff, "lfofilterCoeff", "map", None, "Fit coefficient"),
+                    (fitNorm, "lfofilterNorm", "map", None, "Normalized fit coefficient"),
+                ]
 
-    if args.refinedelay:
-        if args.refineregressderivs > 1:
-            for i in range(args.refineregressderivs):
+        if args.refinedelay:
+            if args.refineregressderivs > 1:
+                for i in range(args.refineregressderivs):
+                    maplist += [
+                        (
+                            regressderivratios[i, :],
+                            f"regressderivratios_{i}",
+                            "map",
+                            None,
+                            f"Ratio of derivative {i+1} of delayed sLFO to the delayed sLFO",
+                        ),
+                        (
+                            medfiltregressderivratios[i, :],
+                            f"medfiltregressderivratios_{i}",
+                            "map",
+                            None,
+                            f"Median filtered version of the regressderivratios_{i} map",
+                        ),
+                        (
+                            filteredregressderivratios[i, :],
+                            f"filteredregressderivratios_{i}",
+                            "map",
+                            None,
+                            f"regressderivratios_{i}, with outliers patched using median filtered data",
+                        ),
+                    ]
+            else:
                 maplist += [
                     (
-                        regressderivratios[i, :],
-                        f"regressderivratios_{i}",
+                        regressderivratios,
+                        "regressderivratios",
                         "map",
                         None,
-                        f"Ratio of derivative {i+1} of delayed sLFO to the delayed sLFO",
+                        "Ratio of the first derivative of delayed sLFO to the delayed sLFO",
                     ),
                     (
-                        medfiltregressderivratios[i, :],
-                        f"medfiltregressderivratios_{i}",
+                        medfiltregressderivratios,
+                        "medfiltregressderivratios",
                         "map",
                         None,
-                        f"Median filtered version of the regressderivratios_{i} map",
+                        "Median filtered version of the regressderivratios map",
                     ),
                     (
-                        filteredregressderivratios[i, :],
-                        f"filteredregressderivratios_{i}",
+                        filteredregressderivratios,
+                        "filteredregressderivratios",
                         "map",
                         None,
-                        f"regressderivratios_{i}, with outliers patched using median filtered data",
+                        "regressderivratios, with outliers patched using median filtered data",
                     ),
                 ]
-        else:
             maplist += [
                 (
-                    regressderivratios,
-                    "regressderivratios",
+                    delayoffset,
+                    "delayoffset",
                     "map",
-                    None,
-                    "Ratio of the first derivative of delayed sLFO to the delayed sLFO",
+                    "second",
+                    "Delay offset correction from delay refinement",
                 ),
                 (
-                    medfiltregressderivratios,
-                    "medfiltregressderivratios",
+                    lagtimesrefined_valid,
+                    "maxtimerefined",
                     "map",
-                    None,
-                    "Median filtered version of the regressderivratios map",
+                    "second",
+                    "Lag time in seconds, refined",
                 ),
+            ]
+
+        # write the 3D maps
+        tide_io.savemaplist(
+            outputname,
+            maplist,
+            validvoxels,
+            (xsize, ysize, numslices),
+            theheader,
+            bidsdict,
+            debug=args.debug,
+        )
+
+        # write the 4D maps
+        theheader = theinputdata.copyheader()
+        maplist = []
+        if args.saveminimumsLFOfiltfiles:
+            maplist = [
                 (
-                    filteredregressderivratios,
-                    "filteredregressderivratios",
-                    "map",
+                    filtereddata,
+                    "lfofilterCleaned",
+                    "bold",
                     None,
-                    "regressderivratios, with outliers patched using median filtered data",
+                    "fMRI data with sLFO signal filtered out",
                 ),
             ]
-        maplist += [
-            (
-                delayoffset,
-                "delayoffset",
-                "map",
-                "second",
-                "Delay offset correction from delay refinement",
-            ),
+        if args.savemovingsignal:
+            maplist += [
+                (
+                    movingsignal,
+                    "lfofilterRemoved",
+                    "bold",
+                    None,
+                    "sLFO signal filtered out of this voxel",
+                )
+            ]
+
+        if args.saveallsLFOfiltfiles:
+            if args.regressderivs > 0:
+                if args.debug:
+                    print("going down the multiple EV path")
+                    print(f"{regressorset[:, :, 0].shape=}")
+                maplist += [
+                    (
+                        regressorset[:, :, 0],
+                        "lfofilterEV",
+                        "bold",
+                        None,
+                        "Shifted sLFO regressor to filter",
+                    ),
+                ]
+                for thederiv in range(1, args.regressderivs + 1):
+                    if args.debug:
+                        print(f"{regressorset[:, :, thederiv].shape=}")
+                    maplist += [
+                        (
+                            regressorset[:, :, thederiv],
+                            f"lfofilterEVDeriv{thederiv}",
+                            "bold",
+                            None,
+                            f"Time derivative {thederiv} of shifted sLFO regressor",
+                        ),
+                    ]
+            else:
+                if args.debug:
+                    print("going down the single EV path")
+                maplist += [
+                    (
+                        regressorset,
+                        "lfofilterEV",
+                        "bold",
+                        None,
+                        "Shifted sLFO regressor to filter",
+                    ),
+                ]
+        if args.makepseudofile:
+            print("reading mean image")
+            meanfile = f"{args.datafileroot}_desc-mean_map.nii.gz"
             (
-                lagtimesrefined_valid,
-                "maxtimerefined",
-                "map",
-                "second",
-                "Lag time in seconds, refined",
-            ),
-        ]
+                mean_input,
+                mean,
+                mean_header,
+                mean_dims,
+                mean_sizes,
+            ) = tide_io.readfromnifti(meanfile)
+            if not tide_io.checkspacematch(fmri_header, mean_header):
+                raise ValueError("mean dimensions do not match fmri dimensions")
+            if args.debug:
+                print(f"{mean.shape=}")
+            mean_spacebytime = mean.reshape((numspatiallocs))
+            if args.debug:
+                print(f"{mean_spacebytime.shape=}")
+            pseudofile = mean_spacebytime[validvoxels, None] + movingsignal[:, :]
+            maplist.append((pseudofile, "pseudofile", "bold", None, None))
+        tide_io.savemaplist(
+            outputname,
+            maplist,
+            validvoxels,
+            (xsize, ysize, numslices, validtimepoints),
+            theheader,
+            bidsdict,
+            debug=args.debug,
+        )
+        TimingLGR.info("Finishing output save")
 
-    # write the 3D maps
-    tide_io.savemaplist(
-        outputname,
-        maplist,
-        validvoxels,
-        (xsize, ysize, numslices),
-        theheader,
-        bidsdict,
-        debug=args.debug,
-    )
+        if args.refinecorr:
+            TimingLGR.info("Filtering for maxcorralt calculation start")
+            for thevoxel in range(fmri_data_valid.shape[0]):
+                fmri_data_valid[thevoxel, :] = theprefilter.apply(
+                    1.0 / fmritr, fmri_data_valid[thevoxel, :]
+                )
+            TimingLGR.info("Filtering for maxcorralt calculation complete")
+            TimingLGR.info("GLM for maxcorralt calculation start")
+            voxelsprocessed_regressionfilt, regressorset, evset = (
+                tide_regressfrommaps.regressfrommaps(
+                    fmri_data_valid,
+                    validvoxels,
+                    initial_fmri_x,
+                    lagstouse_valid,
+                    corrmask_valid,
+                    genlagtc,
+                    mode,
+                    outputname,
+                    oversamptr,
+                    sLFOfitmean,
+                    rvalue,
+                    r2value,
+                    fitNorm[:, : args.regressderivs + 1],
+                    fitcoeff[:, : args.regressderivs + 1],
+                    movingsignal,
+                    lagtc,
+                    filtereddata,
+                    LGR,
+                    TimingLGR,
+                    threshval,
+                    args.saveminimumsLFOfiltfiles,
+                    nprocs_makelaggedtcs=args.nprocs,
+                    nprocs_regressionfilt=args.nprocs,
+                    regressderivs=args.regressderivs,
+                    showprogressbar=args.showprogressbar,
+                    debug=args.debug,
+                )
+            )
+            TimingLGR.info(
+                "GLM for maxcorralt calculation done",
+                {
+                    "message2": voxelsprocessed_regressionfilt,
+                    "message3": "voxels",
+                },
+            )
 
-    # write the 4D maps
-    theheader = copy.deepcopy(fmri_header)
-    maplist = []
-    if args.saveminimumsLFOfiltfiles:
-        maplist = [
-            (
-                filtereddata,
-                "lfofilterCleaned",
-                "bold",
-                None,
-                "fMRI data with sLFO signal filtered out",
-            ),
-        ]
-    if args.savemovingsignal:
-        maplist += [
-            (
-                movingsignal,
-                "lfofilterRemoved",
-                "bold",
-                None,
-                "sLFO signal filtered out of this voxel",
+            maplist = [
+                (
+                    rvalue,
+                    "maxcorralt",
+                    "map",
+                    None,
+                    "R value for the lfo component of the delayed regressor, with sign",
+                ),
+            ]
+            theheader = copy.deepcopy(lagtimes_header)
+            tide_io.savemaplist(
+                outputname,
+                maplist,
+                validvoxels,
+                (xsize, ysize, numslices),
+                theheader,
+                bidsdict,
+                debug=args.debug,
             )
-        ]
+            if args.debug:
+                # dump the fmri input file going to glm
+                theheader = theinputdata.copyheader(numtimepoints=validtimepoints, tr=fmritr)
 
-    if args.saveallsLFOfiltfiles:
+                maplist = [
+                    (
+                        fmri_data_valid,
+                        "prefilteredinputdata",
+                        "bold",
+                        None,
+                        "fMRI data after temporal filtering",
+                    ),
+                ]
+                tide_io.savemaplist(
+                    outputname,
+                    maplist,
+                    validvoxels,
+                    (xsize, ysize, numslices, validtimepoints),
+                    theheader,
+                    bidsbasedict,
+                    filetype=theinputdata.filetype,
+                    rt_floattype=rt_floattype,
+                    cifti_hdr=None,
+                )
+    else:
+        # We are terminating early because we only want the regressors
+        # write the EVs
+        theheader = theinputdata.copyheader()
+        maplist = []
         if args.regressderivs > 0:
             if args.debug:
                 print("going down the multiple EV path")
@@ -1061,128 +1367,18 @@ def retroregress(args):
                     "Shifted sLFO regressor to filter",
                 ),
             ]
-    if args.makepseudofile:
-        print("reading mean image")
-        meanfile = f"{args.datafileroot}_desc-mean_map.nii.gz"
-        (
-            mean_input,
-            mean,
-            mean_header,
-            mean_dims,
-            mean_sizes,
-        ) = tide_io.readfromnifti(meanfile)
-        if not tide_io.checkspacematch(fmri_header, mean_header):
-            raise ValueError("mean dimensions do not match fmri dimensions")
-        if args.debug:
-            print(f"{mean.shape=}")
-        mean_spacebytime = mean.reshape((numspatiallocs))
-        if args.debug:
-            print(f"{mean_spacebytime.shape=}")
-        pseudofile = mean_spacebytime[validvoxels, None] + movingsignal[:, :]
-        maplist.append((pseudofile, "pseudofile", "bold", None, None))
-    tide_io.savemaplist(
-        outputname,
-        maplist,
-        validvoxels,
-        (xsize, ysize, numslices, validtimepoints),
-        theheader,
-        bidsdict,
-        debug=args.debug,
-    )
-    TimingLGR.info("Finishing output save")
-
-    if args.refinecorr:
-        TimingLGR.info("Filtering for maxcorralt calculation start")
-        for thevoxel in range(fmri_data_valid.shape[0]):
-            fmri_data_valid[thevoxel, :] = theprefilter.apply(
-                1.0 / fmritr, fmri_data_valid[thevoxel, :]
-            )
-        TimingLGR.info("Filtering for maxcorralt calculation complete")
-        TimingLGR.info("GLM for maxcorralt calculation start")
-        voxelsprocessed_regressionfilt, regressorset, evset = tide_regressfrommaps.regressfrommaps(
-            fmri_data_valid,
-            validvoxels,
-            initial_fmri_x,
-            lagstouse_valid,
-            corrmask_valid,
-            genlagtc,
-            mode,
-            outputname,
-            oversamptr,
-            sLFOfitmean,
-            rvalue,
-            r2value,
-            fitNorm[:, : args.regressderivs + 1],
-            fitcoeff[:, : args.regressderivs + 1],
-            movingsignal,
-            lagtc,
-            filtereddata,
-            LGR,
-            TimingLGR,
-            threshval,
-            args.saveminimumsLFOfiltfiles,
-            nprocs_makelaggedtcs=args.nprocs,
-            nprocs_regressionfilt=args.nprocs,
-            regressderivs=args.regressderivs,
-            showprogressbar=args.showprogressbar,
-            debug=args.debug,
-        )
-        TimingLGR.info(
-            "GLM for maxcorralt calculation done",
-            {
-                "message2": voxelsprocessed_regressionfilt,
-                "message3": "voxels",
-            },
-        )
-
-        maplist = [
-            (
-                rvalue,
-                "maxcorralt",
-                "map",
-                None,
-                "R value for the lfo component of the delayed regressor, with sign",
-            ),
-        ]
-        theheader = copy.deepcopy(lagtimes_header)
+        bidsdict = bidsbasedict.copy()
         tide_io.savemaplist(
             outputname,
             maplist,
             validvoxels,
-            (xsize, ysize, numslices),
+            (xsize, ysize, numslices, validtimepoints),
             theheader,
             bidsdict,
             debug=args.debug,
         )
-        if args.debug:
-            # dump the fmri input file going to glm
-            theheader = copy.deepcopy(fmri_header)
-            theheader["dim"][4] = validtimepoints
-            theheader["pixdim"][4] = fmritr
-
-            maplist = [
-                (
-                    fmri_data_valid,
-                    "prefilteredinputdata",
-                    "bold",
-                    None,
-                    "fMRI data after temporal filtering",
-                ),
-            ]
-            tide_io.savemaplist(
-                outputname,
-                maplist,
-                validvoxels,
-                (xsize, ysize, numslices, validtimepoints),
-                theheader,
-                bidsbasedict,
-                textio=therunoptions["textio"],
-                fileiscifti=False,
-                rt_floattype=rt_floattype,
-                cifti_hdr=None,
-            )
 
-    # read the runoptions file
+    # write the runoptions file
     print("writing runoptions")
     if args.refinedelay:
         therunoptions["retroregress_delayoffsetMAD"] = delayoffsetMAD