rapidtide 2.9.6__py3-none-any.whl → 3.1.3__py3-none-any.whl

rapidtide/workflows/rapidtide_parser.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #
-#   Copyright 2016-2024 Blaise Frederick
+#   Copyright 2016-2025 Blaise Frederick
 #
 #   Licensed under the Apache License, Version 2.0 (the "License");
 #   you may not use this file except in compliance with the License.
@@ -21,21 +21,16 @@ import logging
 import os
 import sys
 from argparse import Namespace
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 import nibabel as nib
 import numpy as np
+from numpy.typing import NDArray
 
 import rapidtide.io as tide_io
 import rapidtide.util as tide_util
 import rapidtide.workflows.parser_funcs as pf
 
-try:
-    from memory_profiler import profile
-
-    memprofilerexists = True
-except ImportError:
-    memprofilerexists = False
-
 
 # Create a sentinel.
 # from https://stackoverflow.com/questions/58594956/find-out-which-arguments-were-passed-explicitly-in-argparse
@@ -51,7 +46,7 @@ LGR = logging.getLogger(__name__)
 DEFAULT_SPATIALFILT = -1
 DEFAULT_HISTLEN = 101
 DEFAULT_DETREND_ORDER = 3
-DEFAULT_GLOBAL_PCACOMPONENTS = 0.8
+DEFAULT_INITREGRESSOR_PCACOMPONENTS = 0.8
 DEFAULT_CORRMASK_THRESHPCT = 1.0
 DEFAULT_MUTUALINFO_SMOOTHINGTIME = 3.0
 DEFAULT_LAGMIN = -30.0
@@ -61,8 +56,8 @@ DEFAULT_SIGMAMIN = 0.0
 DEFAULT_DESPECKLE_PASSES = 4
 DEFAULT_DESPECKLE_THRESH = 5.0
 DEFAULT_PASSES = 3
-DEFAULT_LAGMIN_THRESH = 0.5
-DEFAULT_LAGMAX_THRESH = 5.0
+DEFAULT_LAGMIN_THRESH = 0.25
+DEFAULT_LAGMAX_THRESH = 3.0
 DEFAULT_AMPTHRESH = 0.3
 DEFAULT_PICKLEFT_THRESH = 0.33
 DEFAULT_SIGMATHRESH = 100.0
@@ -70,16 +65,15 @@ DEFAULT_MAXPASSES = 15
 DEFAULT_REFINE_TYPE = "pca"
 DEFAULT_INTERPTYPE = "univariate"
 DEFAULT_WINDOW_TYPE = "hamming"
-DEFAULT_GLOBALMASK_METHOD = "mean"
-DEFAULT_GLOBALSIGNAL_METHOD = "sum"
-DEFAULT_CORRWEIGHTING = "regressor"
+DEFAULT_INITREGRESSOR_METHOD = "sum"
+DEFAULT_CORRWEIGHTING = "phat"
 DEFAULT_CORRTYPE = "linear"
 DEFAULT_SIMILARITYMETRIC = "correlation"
 DEFAULT_PEAKFIT_TYPE = "gauss"
 DEFAULT_REFINE_PRENORM = "var"
 DEFAULT_REFINE_WEIGHTING = "None"
 DEFAULT_REFINE_PCACOMPONENTS = 0.8
-DEFAULT_GLMDERIVS = 0
+DEFAULT_REGRESSIONFILTDERIVS = 0
 
 DEFAULT_DENOISING_LAGMIN = -10.0
 DEFAULT_DENOISING_LAGMAX = 10.0
@@ -92,6 +86,7 @@ DEFAULT_DELAYMAPPING_LAGMIN = -10.0
 DEFAULT_DELAYMAPPING_LAGMAX = 30.0
 DEFAULT_DELAYMAPPING_PASSES = 3
 DEFAULT_DELAYMAPPING_DESPECKLE_PASSES = 4
+DEFAULT_DELAYMAPPING_SPATIALFILT = 2.5
 
 DEFAULT_CVRMAPPING_LAGMIN = -5.0
 DEFAULT_CVRMAPPING_LAGMAX = 20.0
@@ -103,10 +98,49 @@ DEFAULT_OUTPUTLEVEL = "normal"
 
 DEFAULT_SLFONOISEAMP_WINDOWSIZE = 40.0
 
+DEFAULT_COARSEDELAY_TYPE = "simfunc"
+DEFAULT_RIPTIDESTEP = 2.0
+
+DEFAULT_PATCHTHRESH = 3.0
+DEFAULT_REFINEDELAYMINDELAY = -5.0
+DEFAULT_REFINEDELAYMAXDELAY = 5.0
+DEFAULT_REFINEDELAYNUMPOINTS = 501
+DEFAULT_DELAYOFFSETSPATIALFILT = -1
+
+DEFAULT_PATCHMINSIZE = 10
+DEFAULT_PATCHFWHM = 5
+
+DEFAULT_PREWHITEN_LAGS = -1
+
 
-def _get_parser():
+def _get_parser() -> Any:
     """
-    Argument parser for rapidtide
+    Set up the argument parser for rapidtide command-line interface.
+
+    This function configures all available command-line arguments for the rapidtide
+    tool, organizing them into logical groups for easy reference and use.
+
+    Returns
+    -------
+    argparse.ArgumentParser
+        Configured argument parser with all rapidtide options added
+
+    Notes
+    -----
+    The parser includes several groups of options:
+    - Input/Output options
+    - Processing options
+    - Performance options
+    - Miscellaneous options
+    - Experimental options (not fully tested)
+    - Deprecated options (will be removed in future versions)
+    - Debugging options (for development and troubleshooting)
+
+    Examples
+    --------
+    >>> parser = setup_parser()
+    >>> args = parser.parse_args()
+    >>> print(args.version)
     """
     parser = argparse.ArgumentParser(
         prog="rapidtide",
@@ -149,7 +183,7 @@ def _get_parser():
             f"sets searchrange=({DEFAULT_DENOISING_LAGMIN}, {DEFAULT_DENOISING_LAGMAX}), "
             f"passes={DEFAULT_DENOISING_PASSES}, despeckle_passes={DEFAULT_DENOISING_DESPECKLE_PASSES}, "
             f"refineoffset=True, peakfittype={DEFAULT_DENOISING_PEAKFITTYPE}, "
-            f"gausssigma={DEFAULT_DENOISING_SPATIALFILT}, nofitfilt=True, doglmfilt=True. "
+            f"gausssigma={DEFAULT_DENOISING_SPATIALFILT}, nofitfilt=True, dolinfitfilt=True. "
             "Any of these options can be overridden with the appropriate "
             "additional arguments."
         ),
@@ -163,8 +197,9 @@ def _get_parser():
             "Preset for delay mapping analysis - this is a macro that "
             f"sets searchrange=({DEFAULT_DELAYMAPPING_LAGMIN}, {DEFAULT_DELAYMAPPING_LAGMAX}), "
             f"passes={DEFAULT_DELAYMAPPING_PASSES}, despeckle_passes={DEFAULT_DELAYMAPPING_DESPECKLE_PASSES}, "
-            "refineoffset=True, outputlevel='normal', "
-            "doglmfilt=False. "
+            f"gausssigma={DEFAULT_DELAYMAPPING_SPATIALFILT}, "
+            "refineoffset=True, refinedelay=True, outputlevel='normal', "
+            "dolinfitfilt=False. "
             "Any of these options can be overridden with the appropriate "
             "additional arguments."
         ),
@@ -181,7 +216,7 @@ def _get_parser():
             f"passes=1, despeckle_passes={DEFAULT_CVRMAPPING_DESPECKLE_PASSES}, "
             f"searchrange=({DEFAULT_CVRMAPPING_LAGMIN}, {DEFAULT_CVRMAPPING_LAGMAX}), "
             f"filterfreqs=({DEFAULT_CVRMAPPING_FILTER_LOWERPASS}, {DEFAULT_CVRMAPPING_FILTER_UPPERPASS}), "
-            "and calculates a voxelwise GLM using the optimally delayed "
+            "and calculates a voxelwise regression fit using the optimally delayed "
             "input regressor and the percent normalized, demeaned BOLD data as inputs. This map is output as "
             "(XXX_desc-CVR_map.nii.gz).  If no input regressor is supplied, this will generate an error.  "
             "These options can be overridden with the appropriate additional arguments."
@@ -190,12 +225,12 @@ def _get_parser():
     )
     analysis_type.add_argument(
         "--globalpreselect",
-        dest="globalpreselect",
+        dest="initregressorpreselect",
         action="store_true",
         help=(
             "Treat this run as an initial pass to locate good candidate voxels for global mean "
             "regressor generation.  This sets: passes=1, despecklepasses=0, "
-            "refinedespeckle=False, outputlevel='normal', doglmfilt=False, saveintermediatemaps=False."
+            "refinedespeckle=False, outputlevel='normal', dolinfitfilt=False, saveintermediatemaps=False."
         ),
         default=False,
     )
@@ -228,7 +263,7 @@ def _get_parser():
         action="store_true",
         help=(
             "This is a NIRS analysis - this is a macro that "
-            "sets nothresh, refineprenorm=var, ampthresh=0.7, and "
+            "sets nothresh, dataiszeromean=True, refineprenorm=var, ampthresh=0.7, and "
             "lagminthresh=0.1. "
         ),
         default=False,
@@ -256,7 +291,7 @@ def _get_parser():
             "2) decide which voxels in which to calculate delays, "
             "3) refine the regressor at the end of each pass, 4) determine the zero time offset value, and 5) process "
             "to remove sLFO signal. "
-            "Setting --globalmeaninclude, --refineinclude, --corrmaskinclude or --offsetinclude explicitly will "
+            "Setting --initregressorinclude, --corrmaskinclude, --refineinclude or --offsetinclude explicitly will "
             "override this for the given include mask."
         ),
         default=None,
@@ -269,9 +304,8 @@ def _get_parser():
             "This specifies a gray matter mask registered to the input functional data.  "
             "If VALSPEC is given, only voxels in the mask with integral values listed in VALSPEC are used, otherwise "
             "voxels with value > 0.1 are used.  If this option is set, "
-            "rapidtide will use voxels in the gray matter mask to 1) calculate the initial global mean regressor, "
-            "and 2) for determining the zero time offset value. "
-            "Setting --globalmeaninclude or --offsetinclude explicitly will override this for "
+            "rapidtide will use voxels in the gray matter mask to calculate the initial global mean regressor. "
+            "Setting --initregressorinclude  explicitly will override this for "
             "the given include mask."
         ),
         default=None,
@@ -284,8 +318,21 @@ def _get_parser():
             "This specifies a white matter mask registered to the input functional data.  "
             "If VALSPEC is given, only voxels in the mask with integral values listed in VALSPEC are used, otherwise "
             "voxels with value > 0.1 are used.  "
-            "This currently isn't used for anything, but rapidtide will keep track of it and might use if for something "
-            "in a later version."
+            "This will be used to calculate the white matter timecourse before running rapidtide, and after sLFO "
+            "filtering (if enabled)."
+        ),
+        default=None,
+    )
+    anatomy.add_argument(
+        "--csfmask",
+        dest="csfincludespec",
+        metavar="MASK[:VALSPEC]",
+        help=(
+            "This specifies a CSF mask registered to the input functional data.  "
+            "If VALSPEC is given, only voxels in the mask with integral values listed in VALSPEC are used, otherwise "
+            "voxels with value > 0.1 are used.  "
+            "This will be used to calculate the CSF timecourse before running rapidtide, and after sLFO "
+            "filtering (if enabled)."
         ),
         default=None,
     )
@@ -298,7 +345,7 @@ def _get_parser():
         dest="realtr",
         action="store",
         metavar="TSTEP",
-        type=lambda x: pf.is_float(parser, x),
+        type=lambda x: pf.is_float(parser, x, minval=0.0),
         help=(
             "Set the timestep of the data file to TSTEP. "
             "This will override the TR in an "
@@ -370,6 +417,17 @@ def _get_parser():
         ),
         default=False,
     )
+    preproc.add_argument(
+        "--dataiszeromean",
+        dest="dataiszeromean",
+        action="store_true",
+        help=(
+            "Assume that the fMRI data is zero mean (this will be the case if you used AFNI for preprocessing).  "
+            "This affects how masks are generated.  Rapidtide will attempt to detect this, but set explicitly "
+            "if you know this is the case."
+        ),
+        default=False,
+    )
 
     # Add filter options
     pf.addfilteropts(parser, filtertarget="data and regressors", details=True)
@@ -384,7 +442,7 @@ def _get_parser():
         "--detrendorder",
         dest="detrendorder",
         action="store",
-        type=int,
+        type=lambda x: pf.is_int(parser, x, minval=0),
         metavar="ORDER",
         help=(f"Set order of trend removal (0 to disable). Default is {DEFAULT_DETREND_ORDER}."),
         default=DEFAULT_DETREND_ORDER,
@@ -399,40 +457,45 @@ def _get_parser():
             "Spatially filter fMRI data prior to analysis "
             "using GAUSSSIGMA in mm.  Set GAUSSSIGMA negative "
             "to have rapidtide set it to half the mean voxel "
-            "dimension (a rule of thumb for a good value)."
+            "dimension (a rule of thumb for a good value). Set to 0 to disable."
         ),
         default=DEFAULT_SPATIALFILT,
     )
     preproc.add_argument(
-        "--globalmean",
-        dest="useglobalref",
+        "--premask",
+        dest="premask",
         action="store_true",
         help=(
-            "Generate a global mean regressor and use that as the reference "
-            "regressor.  If no external regressor is specified, this "
-            "is enabled by default."
+            "Apply masking prior to spatial filtering to limit extracerebral sources (requires --brainmask)"
         ),
         default=False,
     )
     preproc.add_argument(
-        "--globalmaskmethod",
-        dest="globalmaskmethod",
-        action="store",
-        type=str,
-        choices=["mean", "variance"],
+        "--premasktissueonly",
+        dest="premasktissueonly",
+        action="store_true",
         help=(
-            "Select whether to use timecourse mean or variance to "
-            "mask voxels prior to generating global mean. "
-            f'Default is "{DEFAULT_GLOBALMASK_METHOD}".'
+            "Apply more stringent masking prior to spatial filtering, removing CSF voxels (requires --graymattermask and --whitemattermask)."
         ),
-        default=DEFAULT_GLOBALMASK_METHOD,
+        default=False,
+    )
+    preproc.add_argument(
+        "--globalmean",
+        dest="useinitregressorref",
+        action="store_true",
+        help=(
+            "Generate a global mean regressor and use that as the reference "
+            "regressor.  If no external regressor is specified, this "
+            "is enabled by default."
+        ),
+        default=False,
     )
     preproc.add_argument(
         "--globalmeaninclude",
-        dest="globalmeanincludespec",
+        dest="initregressorincludespec",
         metavar="MASK[:VALSPEC]",
         help=(
-            "Only use voxels in mask file NAME for global regressor "
+            "Only use voxels in mask file NAME for the initial regressor "
             "generation (if VALSPEC is given, only voxels "
             "with integral values listed in VALSPEC are used)."
         ),
@@ -440,10 +503,10 @@ def _get_parser():
     )
     preproc.add_argument(
         "--globalmeanexclude",
-        dest="globalmeanexcludespec",
+        dest="initregressorexcludespec",
         metavar="MASK[:VALSPEC]",
         help=(
-            "Do not use voxels in mask file NAME for global regressor "
+            "Do not use voxels in mask file NAME for the initial regressor "
             "generation (if VALSPEC is given, only voxels "
             "with integral values listed in VALSPEC are excluded)."
         ),
@@ -461,10 +524,22 @@ def _get_parser():
         default=None,
     )
     preproc.add_argument(
-        "--motderiv",
+        "--motpowers",
+        dest="mot_power",
+        metavar="N",
+        type=lambda x: pf.is_int(parser, x, minval=1),
+        help=(
+            "Include powers of each motion regressor up to order N. Default is 1 (no expansion). "
+        ),
+        default=1,
+    )
+    preproc.add_argument(
+        "--nomotderiv",
         dest="mot_deriv",
         action="store_false",
-        help=("Toggle whether derivatives will be used in motion regression.  Default is True."),
+        help=(
+            "Do not use derivatives in motion regression.  Default is to use temporal derivatives."
+        ),
         default=True,
     )
     preproc.add_argument(
@@ -483,18 +558,18 @@ def _get_parser():
         "--confoundpowers",
         dest="confound_power",
         metavar="N",
-        type=int,
+        type=lambda x: pf.is_int(parser, x, minval=1),
         help=(
             "Include powers of each confound regressor up to order N. Default is 1 (no expansion). "
         ),
         default=1,
     )
     preproc.add_argument(
-        "--confoundderiv",
+        "--noconfoundderiv",
         dest="confound_deriv",
         action="store_false",
         help=(
-            "Toggle whether derivatives will be used in confound regression.  Default is True. "
+            "Do not use derivatives in confound regression.  Default is to use temporal derivatives."
         ),
         default=True,
     )
@@ -509,32 +584,32 @@ def _get_parser():
     )
     preproc.add_argument(
         "--globalsignalmethod",
-        dest="globalsignalmethod",
+        dest="initregressorsignalmethod",
         action="store",
         type=str,
         choices=["sum", "meanscale", "pca", "random"],
         help=(
-            "The method for constructing the initial global signal regressor - straight summation, "
-            "mean scaling each voxel prior to summation, MLE PCA of the voxels in the global signal mask, "
+            "The method for constructing the initial signal regressor - straight summation, "
+            "mean scaling each voxel prior to summation, MLE PCA of the voxels in the initial regressor mask, "
             "or initializing using random noise."
-            f'Default is "{DEFAULT_GLOBALSIGNAL_METHOD}."'
+            f'Default is "{DEFAULT_INITREGRESSOR_METHOD}."'
         ),
-        default=DEFAULT_GLOBALSIGNAL_METHOD,
+        default=DEFAULT_INITREGRESSOR_METHOD,
     )
     preproc.add_argument(
         "--globalpcacomponents",
-        dest="globalpcacomponents",
+        dest="initregressorpcacomponents",
         action="store",
         type=float,
         metavar="VALUE",
         help=(
-            "Number of PCA components used for estimating the global signal.  If VALUE >= 1, will retain this"
+            "Number of PCA components used for estimating the initial regressor.  If VALUE >= 1, will retain this"
             "many components.  If "
             "0.0 < VALUE < 1.0, enough components will be retained to explain the fraction VALUE of the "
             "total variance. If VALUE is negative, the number of components will be to retain will be selected "
-            f"automatically using the MLE method.  Default is {DEFAULT_GLOBAL_PCACOMPONENTS}."
+            f"automatically using the MLE method.  Default is {DEFAULT_INITREGRESSOR_PCACOMPONENTS}."
         ),
-        default=DEFAULT_GLOBAL_PCACOMPONENTS,
+        default=DEFAULT_INITREGRESSOR_PCACOMPONENTS,
     )
     preproc.add_argument(
         "--slicetimes",
@@ -549,7 +624,7 @@ def _get_parser():
         "--numskip",
         dest="preprocskip",
         action="store",
-        type=int,
+        type=lambda x: pf.is_int(parser, x, minval=0),
         metavar="SKIP",
         help=(
             "SKIP TRs were previously deleted during "
@@ -558,19 +633,6 @@ def _get_parser():
         ),
         default=0,
     )
-    preproc.add_argument(
-        "--numtozero",
-        dest="numtozero",
-        action="store",
-        type=int,
-        metavar="NUMPOINTS",
-        help=(
-            "When calculating the moving regressor, set this number of points to zero at the beginning of the "
-            "voxel timecourses. This prevents initial points which may not be in equilibrium from contaminating the "
-            "calculated sLFO signal.  This may improve similarity fitting and GLM noise removal.  Default is 0."
-        ),
-        default=0,
-    )
     preproc.add_argument(
         "--timerange",
         dest="timerange",
@@ -586,6 +648,34 @@ def _get_parser():
         ),
         default=(-1, -1),
     )
+    preproc.add_argument(
+        "--tincludemask",
+        dest="tincludemaskname",
+        action="store",
+        type=lambda x: pf.is_valid_file(parser, x),
+        metavar="FILE",
+        help=(
+            "Only correlate during epochs specified "
+            "in MASKFILE (NB: each line of FILE "
+            "contains the time and duration of an "
+            "epoch to include."
+        ),
+        default=None,
+    )
+    preproc.add_argument(
+        "--texcludemask",
+        dest="texcludemaskname",
+        action="store",
+        type=lambda x: pf.is_valid_file(parser, x),
+        metavar="FILE",
+        help=(
+            "Do not correlate during epochs specified "
+            "in MASKFILE (NB: each line of FILE "
+            "contains the time and duration of an "
+            "epoch to exclude."
+        ),
+        default=None,
+    )
     preproc.add_argument(
         "--nothresh",
         dest="nothresh",
@@ -626,7 +716,7 @@ def _get_parser():
         "--regressorfreq",
         dest="inputfreq",
         action="store",
-        type=lambda x: pf.is_float(parser, x),
+        type=lambda x: pf.is_float(parser, x, minval=0.0),
         metavar="FREQ",
         help=(
             "Probe regressor in file has sample "
@@ -721,10 +811,10 @@ def _get_parser():
         dest="similaritymetric",
         action="store",
         type=str,
-        choices=["correlation", "mutualinfo", "hybrid"],
+        choices=["correlation", "mutualinfo", "hybrid", "riptide"],
         help=(
             "Similarity metric for finding delay values.  "
-            'Choices are "correlation", "mutualinfo", and "hybrid". '
+            'Choices are "correlation", "mutualinfo", "hybrid", and "riptide". '
             f"Default is {DEFAULT_SIMILARITYMETRIC}."
         ),
         default=DEFAULT_SIMILARITYMETRIC,
@@ -764,16 +854,19 @@ def _get_parser():
     # Correlation fitting options
     corr_fit = parser.add_argument_group("Correlation fitting options")
 
-    fixdelay = corr_fit.add_mutually_exclusive_group()
-    fixdelay.add_argument(
-        "--fixdelay",
-        dest="fixeddelayvalue",
-        action="store",
-        type=float,
-        metavar="DELAYTIME",
-        help=("Don't fit the delay time - set it to DELAYTIME seconds for all " "voxels."),
-        default=None,
+    corr_fit.add_argument(
+        "--initialdelay",
+        dest="initialdelayvalue",
+        type=lambda x: pf.is_valid_file_or_float(parser, x),
+        metavar="DELAY",
+        help=(
+            "Start the analysis with predefined delays.  If DELAY is a filename, use it as an initial delay map; "
+            "if DELAY is a float, initialize all voxels to a  delay of DELAY seconds."
+        ),
+        default=0.0,
     )
+
+    fixdelay = corr_fit.add_mutually_exclusive_group()
     fixdelay.add_argument(
         "--searchrange",
         dest="lag_extrema",
@@ -787,6 +880,13 @@ def _get_parser():
         ),
         default=(DEFAULT_LAGMIN, DEFAULT_LAGMAX),
     )
+    fixdelay.add_argument(
+        "--nodelayfit",
+        dest="fixdelay",
+        action="store_true",
+        help=("Fix the delay in every voxel to its initial value.  Do not perform any fitting."),
+        default=False,
+    )
     corr_fit.add_argument(
         "--sigmalimit",
         dest="widthmax",
@@ -832,7 +932,7 @@ def _get_parser():
         "--despecklepasses",
         dest="despeckle_passes",
         action=pf.IndicateSpecifiedAction,
-        type=int,
+        type=lambda x: pf.is_int(parser, x, minval=0),
         metavar="PASSES",
         help=(
             "Detect and refit suspect correlations to "
@@ -886,8 +986,8 @@ def _get_parser():
     reg_ref.add_argument(
         "--passes",
         dest="passes",
-        action="store",
-        type=int,
+        action=pf.IndicateSpecifiedAction,
+        type=lambda x: pf.is_int(parser, x, minval=1),
         metavar="PASSES",
         help=("Set the number of processing passes to PASSES.  " f"Default is {DEFAULT_PASSES}."),
         default=DEFAULT_PASSES,
@@ -1008,15 +1108,6 @@ def _get_parser():
         help=("Disables selecting the leftmost delay peak when setting the refine offset."),
         default=True,
     )
-    reg_ref.add_argument(
-        "--pickleft",
-        dest="dummy",
-        action="store_true",
-        help=(
-            "DEPRECATED. pickleft is now on by default. Use 'nopickleft' to disable it instead."
-        ),
-        default=True,
-    )
     reg_ref.add_argument(
         "--pickleftthresh",
         dest="pickleftthresh",
@@ -1024,7 +1115,7 @@ def _get_parser():
         metavar="THRESH",
         type=float,
         help=(
-            "Threshhold value (fraction of maximum) in a histogram "
+            "Threshold value (fraction of maximum) in a histogram "
             f"to be considered the start of a peak.  Default is {DEFAULT_PICKLEFT_THRESH}."
         ),
         default=DEFAULT_PICKLEFT_THRESH,
@@ -1101,31 +1192,31 @@ def _get_parser():
         "--maxpasses",
         dest="maxpasses",
         action="store",
-        type=int,
+        type=lambda x: pf.is_int(parser, x, minval=1),
         metavar="MAXPASSES",
         help=(
-            "Terminate refinement after MAXPASSES passes, whether or not convergence has occured. "
+            "Terminate refinement after MAXPASSES passes, whether or not convergence has occurred. "
             f"Default is {DEFAULT_MAXPASSES}."
         ),
         default=DEFAULT_MAXPASSES,
     )
 
-    # GLM noise removal options
-    glm = parser.add_argument_group("GLM noise removal options")
-    glm.add_argument(
-        "--noglm",
-        dest="doglmfilt",
+    # sLFO noise removal options
+    slfofilt = parser.add_argument_group("sLFO noise removal options")
+    slfofilt.add_argument(
+        "--nodenoise",
+        dest="dolinfitfilt",
         action="store_false",
         help=(
-            "Turn off GLM filtering to remove delayed "
+            "Turn off regression filtering to remove delayed "
             "regressor from each voxel (disables output of "
             "fitNorm)."
         ),
         default=True,
     )
-    glm.add_argument(
-        "--glmsourcefile",
-        dest="glmsourcefile",
+    slfofilt.add_argument(
+        "--denoisesourcefile",
+        dest="denoisesourcefile",
         action="store",
         type=lambda x: pf.is_valid_file(parser, x),
         metavar="FILE",
@@ -1136,23 +1227,63 @@ def _get_parser():
         ),
         default=None,
     )
-    glm.add_argument(
+    slfofilt.add_argument(
         "--preservefiltering",
         dest="preservefiltering",
         action="store_true",
-        help="Don't reread data prior to performing GLM.",
+        help="Don't reread data prior to performing sLFO filtering.",
         default=False,
     )
-    glm.add_argument(
-        "--glmderivs",
-        dest="glmderivs",
+    slfofilt.add_argument(
+        "--regressderivs",
+        dest="regressderivs",
         action="store",
-        type=int,
+        type=lambda x: pf.is_int(parser, x, minval=0),
         metavar="NDERIVS",
         help=(
-            f"When doing final GLM, include derivatives up to NDERIVS order. Default is {DEFAULT_GLMDERIVS}"
+            f"When doing final sLFO filtering, include derivatives up to NDERIVS order. Default is {DEFAULT_REGRESSIONFILTDERIVS}"
         ),
-        default=DEFAULT_GLMDERIVS,
+        default=DEFAULT_REGRESSIONFILTDERIVS,
+    )
+    slfofilt.add_argument(
+        "--norefinedelay",
+        dest="refinedelay",
+        action="store_false",
+        help=("Do not calculate a refined delay map using sLFO regression information."),
+        default=True,
+    )
+    slfofilt.add_argument(
+        "--nofilterwithrefineddelay",
+        dest="filterwithrefineddelay",
+        action="store_false",
+        help=("Do not use the refined delay in sLFO filter."),
+        default=True,
+    )
+    slfofilt.add_argument(
+        "--delaypatchthresh",
+        dest="delaypatchthresh",
+        action="store",
+        type=float,
+        metavar="NUMMADs",
+        help=(
+            "Maximum number of robust standard deviations to permit in the offset delay refine map. "
+            f"Default is {DEFAULT_PATCHTHRESH}"
+        ),
+        default=DEFAULT_PATCHTHRESH,
+    )
+    slfofilt.add_argument(
+        "--delayoffsetspatialfilt",
+        dest="delayoffsetgausssigma",
+        action="store",
+        type=float,
+        metavar="GAUSSSIGMA",
+        help=(
+            "Spatially filter fMRI data prior to calculating delay offsets "
+            "using GAUSSSIGMA in mm.  Set GAUSSSIGMA negative "
+            "to have rapidtide set it to half the mean voxel "
+            "dimension (a rule of thumb for a good value).  Set to 0 to disable."
+        ),
+        default=DEFAULT_DELAYOFFSETSPATIALFILT,
     )
 
     # Output options
@@ -1165,7 +1296,7 @@ def _get_parser():
         choices=["min", "less", "normal", "more", "max"],
         help=(
             "The level of file output produced.  'min' produces only absolutely essential files, 'less' adds in "
-            "the GLM filtered data (rather than just filter efficacy metrics), 'normal' saves what you "
+            "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.  "
@@ -1173,16 +1304,6 @@ def _get_parser():
         ),
         default=DEFAULT_OUTPUTLEVEL,
     )
-    output.add_argument(
-        "--nolimitoutput",
-        dest="limitoutput",
-        action="store_false",
-        help=(
-            "Save some of the large and rarely used files.  "
-            "NB: THIS IS NOW DEPRECATED: Use '--outputlevel max' instead."
-        ),
-        default=True,
-    )
     output.add_argument(
         "--savelags",
         dest="savecorrtimes",
@@ -1194,7 +1315,7 @@ def _get_parser():
         "--histlen",  # was -h
         dest="histlen",
         action="store",
-        type=int,
+        type=lambda x: pf.is_int(parser, x, minval=5),
         metavar="HISTLEN",
         help=(f"Change the histogram length to HISTLEN.  Default is {DEFAULT_HISTLEN}."),
         default=DEFAULT_HISTLEN,
@@ -1203,7 +1324,7 @@ def _get_parser():
         "--saveintermediatemaps",
         dest="saveintermediatemaps",
         action="store_true",
-        help="Save lag times, strengths, widths, and mask for each pass.",
+        help="Save lag times, strengths, widths, mask (and shiftedtcs, if they'd normally be saved) for each pass.",
         default=False,
     )
     output.add_argument(
@@ -1246,7 +1367,7 @@ def _get_parser():
         "--mklthreads",
         dest="mklthreads",
         action="store",
-        type=int,
+        type=lambda x: pf.is_int(parser, x, minval=1),
         metavar="MKLTHREADS",
         help=(
             "If mkl library is installed, use no more than MKLTHREADS worker "
@@ -1274,6 +1395,13 @@ def _get_parser():
         help=("Will disable showing progress bars (helpful if stdout is going to a file)."),
         default=True,
     )
+    misc.add_argument(
+        "--makepseudofile",
+        dest="makepseudofile",
+        action="store_true",
+        help=("Make a simulated input file from the mean and the movingsignal."),
+        default=False,
+    )
     misc.add_argument(
         "--checkpoint",
         dest="checkpoint",
@@ -1300,6 +1428,18 @@ def _get_parser():
         help=("Use double precision for output files."),
         default="single",
     )
+    misc.add_argument(
+        "--spatialtolerance",
+        dest="spatialtolerance",
+        action="store",
+        type=float,
+        metavar="EPSILON",
+        help=(
+            "When checking to see if the spatial dimensions of two NIFTI files match, allow a relative difference "
+            "of EPSILON in any dimension.  By default, this is set to 0.0, requiring an exact match. "
+        ),
+        default=0.0,
+    )
     misc.add_argument(
         "--cifti",
         dest="isgrayordinate",
@@ -1328,19 +1468,44 @@ def _get_parser():
         help=("Disable use of shared memory for large array storage."),
         default=True,
     )
-    misc.add_argument(
-        "--memprofile",
-        dest="memprofile",
-        action="store_true",
-        help=("Enable memory profiling - " "warning: this slows things down a lot."),
-        default=False,
-    )
     pf.addtagopts(misc)
 
     # Experimental options (not fully tested, may not work)
     experimental = parser.add_argument_group(
         "Experimental options (not fully tested, or not tested at all, may not work).  Beware!"
     )
+    experimental.add_argument(
+        "--riptidestep",  # was -h
+        dest="riptidestep",
+        action="store",
+        type=lambda x: pf.is_float(parser, x, maxval=5.0),
+        metavar="STEP",
+        help=(
+            f"Timestep between RIPTiDe regressors, in seconds.  Default is {DEFAULT_RIPTIDESTEP}."
+        ),
+        default=DEFAULT_RIPTIDESTEP,
+    )
+    experimental.add_argument(
+        "--refinedelayeachpass",
+        dest="refinedelayeachpass",
+        action="store_true",
+        help=("Do delay refinement in each pass."),
+        default=False,
+    )
+    experimental.add_argument(
+        "--dofinalrefine",
+        dest="dofinalrefine",
+        action="store_true",
+        help=("Do regressor refinement on the final pass."),
+        default=False,
+    )
+    experimental.add_argument(
+        "--sLFOfiltmask",
+        dest="sLFOfiltmask",
+        action="store_true",
+        help=("Limit sLFO filter to fit voxels."),
+        default=False,
+    )
     experimental.add_argument(
         "--territorymap",
         dest="territorymap",
@@ -1355,13 +1520,6 @@ def _get_parser():
         ),
         default=None,
     )
-    experimental.add_argument(
-        "--psdfilter",
-        dest="psdfilter",
-        action="store_true",
-        help=("Apply a PSD weighted Wiener filter to shifted timecourses prior to refinement."),
-        default=False,
-    )
     experimental.add_argument(
         "--wiener",
         dest="dodeconv",
@@ -1369,38 +1527,6 @@ def _get_parser():
         help=("Do Wiener deconvolution to find voxel transfer function."),
         default=False,
     )
-    experimental.add_argument(
-        "--corrbaselinespatialsigma",
-        dest="corrbaselinespatialsigma",
-        action="store",
-        type=float,
-        metavar="SIGMA",
-        help=("Spatial lowpass kernel, in mm, for filtering the correlation function baseline. "),
-        default=0.0,
-    )
-    experimental.add_argument(
-        "--corrbaselinetemphpfcutoff",
-        dest="corrbaselinetemphpfcutoff",
-        action="store",
-        type=float,
-        metavar="FREQ",
-        help=(
-            "Temporal highpass cutoff, in Hz, for filtering the correlation function baseline. "
-        ),
-        default=0.0,
-    )
-    experimental.add_argument(
-        "--spatialtolerance",
-        dest="spatialtolerance",
-        action="store",
-        type=float,
-        metavar="EPSILON",
-        help=(
-            "When checking to see if the spatial dimensions of two NIFTI files match, allow a relative difference "
-            "of EPSILON in any dimension.  By default, this is set to 0.0, requiring an exact match. "
-        ),
-        default=0.0,
-    )
     experimental.add_argument(
         "--echocancel",
         dest="echocancel",
@@ -1415,68 +1541,6 @@ def _get_parser():
         help=("Attempt to detect and remove respiratory signal that strays into " "the LFO band."),
         default=False,
     )
-
-    experimental.add_argument(
-        "--noisetimecourse",
-        dest="noisetimecoursespec",
-        metavar="FILENAME[:VALSPEC]",
-        help=(
-            "Find and remove any instance of the timecourse supplied from any regressors used for analysis. "
-            "(if VALSPEC is given, and there are multiple timecourses in the file, use the indicated timecourse."
-            "This can be the name of the regressor if it's in the file, or the column number). "
-        ),
-        default=None,
-    )
-    noise_group = experimental.add_mutually_exclusive_group()
-    noise_group.add_argument(
-        "--noisefreq",
-        dest="noisefreq",
-        action="store",
-        type=lambda x: pf.is_float(parser, x),
-        metavar="FREQ",
-        help=(
-            "Noise timecourse in file has sample "
-            "frequency FREQ (default is 1/tr) "
-            "NB: --noisefreq and --noisetstep) "
-            "are two ways to specify the same thing."
-        ),
-        default="auto",
-    )
-    noise_group.add_argument(
-        "--noisetstep",
-        dest="noisefreq",
-        action="store",
-        type=lambda x: pf.invert_float(parser, x),
-        metavar="TSTEP",
-        help=(
-            "Noise timecourse in file has sample "
-            "frequency FREQ (default is 1/tr) "
-            "NB: --noisefreq and --noisetstep) "
-            "are two ways to specify the same thing."
-        ),
-        default="auto",
-    )
-    experimental.add_argument(
-        "--noisestart",
-        dest="noisestarttime",
-        action="store",
-        type=float,
-        metavar="START",
-        help=(
-            "The time delay in seconds into the noise timecourse "
-            "file, corresponding in the first TR of the fMRI "
-            "file (default is 0.0)."
-        ),
-        default=0.0,
-    )
-    experimental.add_argument(
-        "--noiseinvert",
-        dest="noiseinvert",
-        action="store_true",
-        help=("Invert noise regressor prior to alignment."),
-        default=False,
-    )
-
     experimental.add_argument(
         "--acfix",
         dest="fix_autocorrelation",
@@ -1514,6 +1578,15 @@ def _get_parser():
         ),
         default=False,
     )
+    experimental.add_argument(
+        "--donotfilterinputdata",
+        dest="filterinputdata",
+        action="store_false",
+        help=(
+            "Do not filter input data prior to similarity calculation.  May make processing faster."
+        ),
+        default=True,
+    )
     experimental.add_argument(
         "--dispersioncalc",
         dest="dodispersioncalc",
@@ -1522,33 +1595,76 @@ def _get_parser():
         default=False,
     )
     experimental.add_argument(
-        "--tincludemask",
-        dest="tincludemaskname",
+        "--patchshift",
+        dest="patchshift",
+        action="store_true",
+        help=("Perform patch shift correction."),
+        default=False,
+    )
+    experimental.add_argument(
+        "--prewhitenregressor",
+        dest="prewhitenregressor",
+        action="store_true",
+        help=("Prewhiten probe regressor prior to calculating correlations."),
+        default=False,
+    )
+    experimental.add_argument(
+        "--prewhitenlags",
+        dest="prewhitenlags",
         action="store",
-        type=lambda x: pf.is_valid_file(parser, x),
-        metavar="FILE",
+        type=lambda x: pf.is_int(parser, x, minval=0),
+        metavar="LAGS",
         help=(
-            "Only correlate during epochs specified "
-            "in MASKFILE (NB: each line of FILE "
-            "contains the time and duration of an "
-            "epoch to include."
+            f"Set number of TRs to use in prewhitening.  Set to -1 to calculate automatically. Default is {DEFAULT_PREWHITEN_LAGS}."
         ),
-        default=None,
+        default=DEFAULT_PREWHITEN_LAGS,
     )
-    experimental.add_argument(
-        "--texcludemask",
-        dest="texcludemaskname",
-        action="store",
-        type=lambda x: pf.is_valid_file(parser, x),
-        metavar="FILE",
+
+    # Deprecated options
+    deprecated = parser.add_argument_group(
+        "Deprecated options.  These options will go away in the indeterminate future.  Don't use them."
+    )
+    deprecated.add_argument(
+        "--refinedelay",
+        dest="dummy",
+        action="store_true",
         help=(
-            "Do not correlate during epochs specified "
-            "in MASKFILE (NB: each line of FILE "
-            "contains the time and duration of an "
-            "epoch to exclude."
+            "Calculate a refined delay map using regression coefficient information. ***DEPRECATED***: refinedelay is now on by default."
         ),
-        default=None,
+        default=True,
+    )
+    deprecated.add_argument(
+        "--nolimitoutput",
+        dest="limitoutput",
+        action="store_false",
+        help=(
+            "Save some of the large and rarely used files.  "
+            "***DEPRECATED***: Use '--outputlevel max' instead."
+        ),
+        default=True,
     )
+    deprecated.add_argument(
+        "--pickleft",
+        dest="dummy",
+        action="store_true",
+        help=(
+            "***DEPRECATED***: pickleft is now on by default. Use 'nopickleft' to disable it instead."
+        ),
+        default=True,
+    )
+    deprecated.add_argument(
+        "--noglm",
+        dest="dolinfitfilt",
+        action="store_false",
+        help=(
+            "Turn off regression filtering to remove delayed "
+            "regressor from each voxel (disables output of "
+            "fitNorm)."
+            "***DEPRECATED***: Use '--nodenoise' instead."
+        ),
+        default=True,
+    )
+
     # Debugging options
     debugging = parser.add_argument_group(
         "Debugging options.  You probably don't want to use any of these unless I ask you to to help diagnose a problem"
@@ -1564,7 +1680,7 @@ def _get_parser():
         "--focaldebug",
         dest="focaldebug",
         action="store_true",
-        help=("Enable targetted additional debugging output (used during development)."),
+        help=("Enable targeted additional debugging output (used during development)."),
         default=False,
     )
     debugging.add_argument(
@@ -1575,10 +1691,10 @@ def _get_parser():
         default=False,
     )
     debugging.add_argument(
-        "--disabledockermemfix",
-        dest="dockermemfix",
+        "--disablecontainermemfix",
+        dest="containermemfix",
         action="store_false",
-        help=("Disable docker memory limit setting."),
+        help=("Disable container memory limit setting."),
         default=True,
     )
     debugging.add_argument(
@@ -1638,10 +1754,10 @@ def _get_parser():
         default=False,
     )
     debugging.add_argument(
-        "--singleproc_glm",
-        dest="singleproc_glm",
+        "--singleproc_regressionfilt",
+        dest="singleproc_regressionfilt",
         action="store_true",
-        help=("Force single proc path for glm."),
+        help=("Force single proc path for regression filtering."),
         default=False,
     )
     debugging.add_argument(
@@ -1662,9 +1778,51 @@ def _get_parser():
     return parser
 
 
-def process_args(inputargs=None):
+def process_args(inputargs: Optional[Any] = None) -> Tuple[Any, object]:
     """
     Compile arguments for rapidtide workflow.
+
+    This function processes command-line arguments and sets up the configuration
+    for the rapidtide workflow. It handles argument parsing, logging setup,
+    command-line saving, and various parameter defaults and overrides based on
+    analysis modes and macros.
+
+    Parameters
+    ----------
+    inputargs : optional
+        Input arguments to be processed. If None, arguments are parsed from
+        sys.argv. Default is None.
+
+    Returns
+    -------
+    tuple
+        A tuple containing:
+        - args : dict
+            Dictionary of processed arguments.
+        - theprefilter : object
+            Preprocessing filter object.
+
+    Notes
+    -----
+    The function performs the following key operations:
+    1. Parses command-line arguments using `_get_parser`
+    2. Sets up logging based on debug flag
+    3. Saves raw and formatted command lines to files
+    4. Applies default values and overrides for various parameters
+    5. Handles analysis modes (delaymapping, denoising, cvrmap, etc.)
+    6. Processes macros (venousrefine, nirs)
+    7. Configures output options based on `outputlevel`
+    8. Sets up pass options and dispersion calculation parameters
+    9. Handles mask specifications and file processing
+    10. Initializes filter options
+
+    Examples
+    --------
+    >>> args, prefilter = process_args()
+    >>> print(args['passes'])
+    1
+    >>> print(args['outputlevel'])
+    'normal'
     """
     inargs, argstowrite = pf.setargs(_get_parser, inputargs=inputargs)
     args = vars(inargs)
@@ -1678,7 +1836,7 @@ def process_args(inputargs=None):
     # save the raw and formatted command lines
     args["commandlineargs"] = argstowrite[1:]
     thecommandline = " ".join(argstowrite)
-    tide_io.writevec([thecommandline], args["outputname"] + "_commandline.txt")
+    tide_io.writevec(np.array([thecommandline]), args["outputname"] + "_commandline.txt")
     formattedcommandline = []
     for thetoken in argstowrite[0:3]:
         formattedcommandline.append(thetoken)
@@ -1697,7 +1855,9 @@ def process_args(inputargs=None):
         else:
             suffix = ""
         formattedcommandline[i] = prefix + formattedcommandline[i] + suffix
-    tide_io.writevec(formattedcommandline, args["outputname"] + "_formattedcommandline.txt")
+    tide_io.writevec(
+        np.array(formattedcommandline), args["outputname"] + "_formattedcommandline.txt"
+    )
 
     LGR.debug("\nbefore postprocessing:\n{}".format(args))
 
@@ -1706,7 +1866,7 @@ def process_args(inputargs=None):
     # what fraction of the correlation window to avoid on either end when
     # fitting
     args["edgebufferfrac"] = 0.0
-    # only do fits in voxels that exceed threshhold
+    # only do fits in voxels that exceed threshold
     args["enforcethresh"] = True
     # if set to the location of the first autocorrelation sidelobe,
     # this will fold back sidelobes
@@ -1719,8 +1879,6 @@ def process_args(inputargs=None):
     args["absmaxsigma"] = 10000.0
     # width of the reference autocorrelation function
     args["absminsigma"] = 0.05
-    # search window width for noise regressor mutual information function
-    args["noisesearchwindow"] = 30.0
     # number of MADs away from the median to consider an outlier
     args["sigdistoutlierfac"] = 10.0
 
@@ -1731,11 +1889,12 @@ def process_args(inputargs=None):
     args["hardlimit"] = True
     # The fraction of the main peak over which points are included in the peak
     args["searchfrac"] = 0.5
-    args["mp_chunksize"] = 50000
+    args["mp_chunksize"] = 500
+    args["patchminsize"] = DEFAULT_PATCHMINSIZE
+    args["patchfwhm"] = DEFAULT_PATCHFWHM
 
     # significance estimation
     args["sighistlen"] = 1000
-    args["dosighistfit"] = True
     if args["corrtype"] == "linear":
         args["corrpadding"] = -1
         # pf.setifnotset(args, "windowfunc", "None")
@@ -1750,6 +1909,10 @@ def process_args(inputargs=None):
     args["check_autocorrelation"] = True
     args["acwidth"] = 0.0  # width of the reference autocorrelation function
 
+    # delay refinement
+    args["mindelay"] = DEFAULT_REFINEDELAYMINDELAY
+    args["maxdelay"] = DEFAULT_REFINEDELAYMAXDELAY
+    args["numpoints"] = DEFAULT_REFINEDELAYNUMPOINTS
     # diagnostic information about version
     (
         args["release_version"],
@@ -1764,6 +1927,8 @@ def process_args(inputargs=None):
     args = vars(theobj)
 
     # Additional argument parsing not handled by argparse
+    args["passes"] = np.max([args["passes"], 1])
+
     args["despeckle_passes"] = np.max([args["despeckle_passes"], 0])
 
     if "lag_extrema_nondefault" in args.keys():
@@ -1773,6 +1938,9 @@ def process_args(inputargs=None):
     args["lagmin"] = args["lag_extrema"][0]
     args["lagmax"] = args["lag_extrema"][1]
 
+    if args["prewhitenlags"] == -1:
+        args["prewhitenlags"] = int(np.max([np.fabs(args["lagmin"]), np.fabs(args["lagmax"])]))
+
     # set startpoint and endpoint
     args["startpoint"], args["endpoint"] = pf.parserange(args["timerange"], descriptor="timerange")
 
@@ -1815,18 +1983,22 @@ def process_args(inputargs=None):
     else:
         args["nohistzero"] = True
 
-    if args["fixeddelayvalue"] is not None:
-        args["fixdelay"] = True
+    # sort out initial delay options
+    if args["fixdelay"]:
+        try:
+            tempinitialdelayvalue = float(args["initialdelayvalue"])
+        except ValueError:
+            tempinitialdelayvalue = 0.0
         args["lag_extrema"] = (
-            args["fixeddelayvalue"] - 10.0,
-            args["fixeddelayvalue"] + 10.0,
+            tempinitialdelayvalue - 10.0,
+            tempinitialdelayvalue + 10.0,
         )
     else:
-        args["fixdelay"] = False
+        args["initialdelayvalue"] = None
 
     if args["in_file"].endswith("txt") and args["realtr"] == "auto":
         raise ValueError(
-            "Either --datatstep or --datafreq must be provided " "if data file is a text file."
+            "Either --datatstep or --datafreq must be provided if data file is a text file."
         )
 
     if args["realtr"] != "auto":
@@ -1835,7 +2007,7 @@ def process_args(inputargs=None):
         if tide_io.checkifcifti(args["in_file"]):
             fmri_tr, dummy = tide_io.getciftitr(nib.load(args["in_file"]).header)
         else:
-            fmri_tr = nib.load(args["in_file"]).header.get_zooms()[3]
+            fmri_tr, dummy = tide_io.fmritimeinfo(args["in_file"])
     args["realtr"] = fmri_tr
 
     if args["inputfreq"] == "auto":
@@ -1844,32 +2016,27 @@ def process_args(inputargs=None):
     else:
         args["inputfreq_nondefault"] = True
 
-    if args["noisetimecoursespec"] is not None:
-        (
-            args["noisetimecoursename"],
-            args["noisetimecoursevals"],
-        ) = tide_io.parsefilespec(args["noisetimecoursespec"])
-    else:
-        args["noisetimecoursename"] = None
-        args["noisetimecoursevals"] = None
-
-    if args["noisefreq"] == "auto":
-        args["noisefreq"] = 1.0 / fmri_tr
-
-    # mask processing
-    if args["corrmaskincludespec"] is not None:
-        (
-            args["corrmaskincludename"],
-            args["corrmaskincludevals"],
-        ) = tide_io.processnamespec(
-            args["corrmaskincludespec"],
-            "Including voxels where ",
-            "in correlation calculations.",
-        )
-    else:
-        args["corrmaskincludename"] = None
-
-    # if brainmaskincludespec is set, set corrmaskinclude to it.
+    # initial mask values from anatomical images (before any overrides)
+    for key in [
+        "corrmaskincludename",
+        "corrmaskincludevals",
+        "initregressorincludename",
+        "initregressorincludevals",
+        "initregressorexcludename",
+        "initregressorexcludevals",
+        "refineincludename",
+        "refineincludevals",
+        "refineexcludename",
+        "refineexcludevals",
+        "offsetincludename",
+        "offsetincludevals",
+        "offsetexcludename",
+        "offsetexcludevals",
+    ]:
+        args[key] = None
+
+    # if brainmaskincludespec is set, set initregressorinclude, corrmaskinclude, refineinclude, and offsetinclude to it.
+    brainmasks = ["initregressor", "corrmask", "refine", "offset"]
     if args["brainmaskincludespec"] is not None:
         (
             args["brainmaskincludename"],
@@ -1879,11 +2046,22 @@ def process_args(inputargs=None):
         )
         if not os.path.isfile(args["brainmaskincludename"]):
             raise FileNotFoundError(f"file {args['brainmaskincludename']} does not exist.")
+        for masktype in brainmasks:
+            (
+                args[f"{masktype}includename"],
+                args[f"{masktype}includevals"],
+            ) = (
+                args["brainmaskincludename"],
+                args["brainmaskincludevals"],
+            )
+            print(f"setting {masktype}include mask to gray matter mask")
     else:
         args["brainmaskincludename"] = None
         args["brainmaskincludevals"] = None
 
-    # if graymatterincludespec is set, set globalmeaninclude and offsetinclude to it.
+    # if graymatterincludespec is set, set initregressorinclude, offsetinclude to it.
+    # graymasks = ["initregressor", "offset"]
+    graymasks = ["initregressor"]
     if args["graymatterincludespec"] is not None:
         (
             args["graymatterincludename"],
@@ -1893,27 +2071,18 @@ def process_args(inputargs=None):
         )
         if not os.path.isfile(args["graymatterincludename"]):
             raise FileNotFoundError(f"file {args['graymatterincludename']} does not exist.")
-        (
-            args["globalmeanincludename"],
-            args["globalmeanincludevals"],
-        ) = (
-            args["graymatterincludename"],
-            args["graymatterincludevals"],
-        )
-        (
-            args["offsetincludename"],
-            args["offsetincludevals"],
-        ) = (
-            args["graymatterincludename"],
-            args["graymatterincludevals"],
-        )
+        for masktype in graymasks:
+            (
+                args[f"{masktype}includename"],
+                args[f"{masktype}includevals"],
+            ) = (
+                args["graymatterincludename"],
+                args["graymatterincludevals"],
+            )
+            print(f"setting {masktype}include mask to gray matter mask")
     else:
         args["graymatterincludename"] = None
         args["graymatterincludevals"] = None
-        args["globalmeanincludename"] = None
-        args["globalmeanincludevals"] = None
-        args["offsetincludename"] = None
-        args["offsetincludevals"] = None
 
     if args["whitematterincludespec"] is not None:
         (
@@ -1926,26 +2095,47 @@ def process_args(inputargs=None):
         args["whitematterincludename"] = None
         args["whitematterincludevals"] = None
 
-    if args["globalmeanincludespec"] is not None:
+    if args["csfincludespec"] is not None:
+        (
+            args["csfincludename"],
+            args["csfincludevals"],
+        ) = tide_io.processnamespec(
+            args["csfincludespec"], "Including voxels where ", "in CSF mask."
+        )
+    else:
+        args["csfincludename"] = None
+        args["csfincludevals"] = None
+
+    # individual mask processing (including overrides)
+    if args["corrmaskincludespec"] is not None:
+        (
+            args["corrmaskincludename"],
+            args["corrmaskincludevals"],
+        ) = tide_io.processnamespec(
+            args["corrmaskincludespec"],
+            "Including voxels where ",
+            "in correlation calculations.",
+        )
+
+    if args["initregressorincludespec"] is not None:
         (
-            args["globalmeanincludename"],
-            args["globalmeanincludevals"],
+            args["initregressorincludename"],
+            args["initregressorincludevals"],
         ) = tide_io.processnamespec(
-            args["globalmeanincludespec"], "Including voxels where ", "in global mean."
+            args["initregressorincludespec"],
+            "Including voxels where ",
+            "in initial regressor calculation.",
         )
 
-    if args["globalmeanexcludespec"] is not None:
+    if args["initregressorexcludespec"] is not None:
         (
-            args["globalmeanexcludename"],
-            args["globalmeanexcludevals"],
+            args["initregressorexcludename"],
+            args["initregressorexcludevals"],
         ) = tide_io.processnamespec(
-            args["globalmeanexcludespec"],
+            args["initregressorexcludespec"],
             "Excluding voxels where ",
-            "from global mean.",
+            "from initial regressor calculation.",
         )
-    else:
-        args["globalmeanexcludename"] = None
-        args["globalmeanexcludevals"] = None
 
     if args["refineincludespec"] is not None:
         (
@@ -1954,9 +2144,6 @@ def process_args(inputargs=None):
         ) = tide_io.processnamespec(
             args["refineincludespec"], "Including voxels where ", "in refinement."
         )
-    else:
-        args["refineincludename"] = None
-        args["refineincludevals"] = None
 
     if args["refineexcludespec"] is not None:
         (
@@ -1965,9 +2152,6 @@ def process_args(inputargs=None):
         ) = tide_io.processnamespec(
             args["refineexcludespec"], "Excluding voxels where ", "from refinement."
         )
-    else:
-        args["refineexcludename"] = None
-        args["refineexcludevals"] = None
 
     if args["offsetincludespec"] is not None:
         (
@@ -1984,9 +2168,6 @@ def process_args(inputargs=None):
         ) = tide_io.processnamespec(
             args["offsetexcludespec"], "Excluding voxels where ", "from offset calculation."
         )
-    else:
-        args["offsetexcludename"] = None
-        args["offsetexcludevals"] = None
 
     # motion processing
     if args["motionfilespec"] is not None:
@@ -1999,25 +2180,35 @@ def process_args(inputargs=None):
     # process analysis modes
     if args["delaymapping"]:
         LGR.warning('Using "delaymapping" analysis mode. Overriding any affected arguments.')
-        pf.setifnotset(args, "passes", DEFAULT_DELAYMAPPING_PASSES)
-        pf.setifnotset(args, "despeckle_passes", DEFAULT_DELAYMAPPING_DESPECKLE_PASSES)
+        if args["passes"] == DEFAULT_PASSES:
+            args["passes"] = DEFAULT_DELAYMAPPING_PASSES
+        if args["despeckle_passes"] == DEFAULT_DESPECKLE_PASSES:
+            args["despeckle_passes"] = DEFAULT_DELAYMAPPING_DESPECKLE_PASSES
+        if args["gausssigma"] == DEFAULT_SPATIALFILT:
+            args["gausssigma"] = DEFAULT_DELAYMAPPING_SPATIALFILT
         pf.setifnotset(args, "lagmin", DEFAULT_DELAYMAPPING_LAGMIN)
         pf.setifnotset(args, "lagmax", DEFAULT_DELAYMAPPING_LAGMAX)
         args["refineoffset"] = True
+        args["refinedelay"] = True
         args["outputlevel"] = "normal"
-        pf.setifnotset(args, "doglmfilt", False)
+        pf.setifnotset(args, "dolinfitfilt", True)
 
     if args["denoising"]:
         LGR.warning('Using "denoising" analysis mode. Overriding any affected arguments.')
-        pf.setifnotset(args, "passes", DEFAULT_DENOISING_PASSES)
-        pf.setifnotset(args, "despeckle_passes", DEFAULT_DENOISING_DESPECKLE_PASSES)
+        if args["passes"] == DEFAULT_PASSES:
+            args["passes"] = DEFAULT_DENOISING_PASSES
+        if args["despeckle_passes"] == DEFAULT_DESPECKLE_PASSES:
+            args["despeckle_passes"] = DEFAULT_DENOISING_DESPECKLE_PASSES
+        if args["gausssigma"] == DEFAULT_SPATIALFILT:
+            args["gausssigma"] = DEFAULT_DENOISING_SPATIALFILT
+        if args["peakfittype"] == DEFAULT_PEAKFIT_TYPE:
+            args["peakfittype"] = DEFAULT_DENOISING_PEAKFITTYPE
         pf.setifnotset(args, "lagmin", DEFAULT_DENOISING_LAGMIN)
         pf.setifnotset(args, "lagmax", DEFAULT_DENOISING_LAGMAX)
-        pf.setifnotset(args, "peakfittype", DEFAULT_DENOISING_PEAKFITTYPE)
-        pf.setifnotset(args, "gausssigma", DEFAULT_DENOISING_SPATIALFILT)
         args["refineoffset"] = True
+        args["refinedelay"] = True
         args["zerooutbadfit"] = False
-        pf.setifnotset(args, "doglmfilt", True)
+        args["dolinfitfilt"] = True
 
     if args["docvrmap"]:
         LGR.warning('Using "CVR" analysis mode. Overriding any affected arguments.')
@@ -2029,22 +2220,24 @@ def process_args(inputargs=None):
             DEFAULT_CVRMAPPING_FILTER_LOWERPASS,
             DEFAULT_CVRMAPPING_FILTER_UPPERPASS,
         )
-        pf.setifnotset(args, "filterband", "arb")
-        pf.setifnotset(args, "despeckle_passes", DEFAULT_CVRMAPPING_DESPECKLE_PASSES)
+        if args["despeckle_passes"] == DEFAULT_DESPECKLE_PASSES:
+            args["despeckle_passes"] = DEFAULT_CVRMAPPING_DESPECKLE_PASSES
+        if args["filterband"] == pf.DEFAULT_FILTERBAND:
+            args["filterband"] = "None"
         pf.setifnotset(args, "lagmin", DEFAULT_CVRMAPPING_LAGMIN)
         pf.setifnotset(args, "lagmax", DEFAULT_CVRMAPPING_LAGMAX)
         args["preservefiltering"] = True
         args["passes"] = 1
         args["outputlevel"] = "min"
-        args["doglmfilt"] = False
+        args["dolinfitfilt"] = False
 
-    if args["globalpreselect"]:
+    if args["initregressorpreselect"]:
         LGR.warning('Using "globalpreselect" analysis mode. Overriding any affected arguments.')
         args["passes"] = 1
         args["despeckle_passes"] = 0
         args["refinedespeckle"] = False
         args["outputlevel"] = "normal"
-        pf.setifnotset(args, "doglmfilt", False)
+        pf.setifnotset(args, "dolinfitfilt", False)
         args["saveintermediatemaps"] = False
 
     # configure the filter
@@ -2064,6 +2257,7 @@ def process_args(inputargs=None):
         LGR.warning('Using "nirs" macro. Overriding any affected arguments.')
         args["nothresh"] = True
         pf.setifnotset(args, "preservefiltering", False)
+        args["dataiszeromean"] = True
         args["refineprenorm"] = "var"
         args["ampthresh"] = 0.7
         args["ampthreshfromsig"] = False
@@ -2081,59 +2275,66 @@ def process_args(inputargs=None):
         args["savecorrtimes"] = False
         args["savelagregressors"] = False
         args["savedespecklemasks"] = False
-        args["saveminimumglmfiles"] = False
-        args["savenormalglmfiles"] = False
+        args["saveminimumsLFOfiltfiles"] = False
+        args["savenormalsLFOfiltfiles"] = False
         args["savemovingsignal"] = False
-        args["saveallglmfiles"] = False
+        args["saveallsLFOfiltfiles"] = False
     elif args["outputlevel"] == "less":
         args["saveconfoundfiltered"] = False
         args["savegaussout"] = False
         args["savecorrtimes"] = False
         args["savelagregressors"] = False
         args["savedespecklemasks"] = False
-        args["saveminimumglmfiles"] = True
-        args["savenormalglmfiles"] = False
+        args["saveminimumsLFOfiltfiles"] = True
+        args["savenormalsLFOfiltfiles"] = False
         args["savemovingsignal"] = False
-        args["saveallglmfiles"] = False
+        args["saveallsLFOfiltfiles"] = False
     elif args["outputlevel"] == "normal":
         args["saveconfoundfiltered"] = False
         args["savegaussout"] = False
         args["savecorrtimes"] = False
         args["savelagregressors"] = False
         args["savedespecklemasks"] = False
-        args["saveminimumglmfiles"] = True
-        args["savenormalglmfiles"] = True
+        args["saveminimumsLFOfiltfiles"] = True
+        args["savenormalsLFOfiltfiles"] = True
         args["savemovingsignal"] = False
-        args["saveallglmfiles"] = False
+        args["saveallsLFOfiltfiles"] = False
     elif args["outputlevel"] == "more":
         args["saveconfoundfiltered"] = False
         args["savegaussout"] = False
         args["savecorrtimes"] = False
         args["savelagregressors"] = True
         args["savedespecklemasks"] = False
-        args["saveminimumglmfiles"] = True
-        args["savenormalglmfiles"] = True
+        args["saveminimumsLFOfiltfiles"] = True
+        args["savenormalsLFOfiltfiles"] = True
         args["savemovingsignal"] = True
-        args["saveallglmfiles"] = False
+        args["saveallsLFOfiltfiles"] = False
     elif args["outputlevel"] == "max":
         args["saveconfoundfiltered"] = True
         args["savegaussout"] = True
         args["savecorrtimes"] = True
         args["savelagregressors"] = True
         args["savedespecklemasks"] = True
-        args["saveminimumglmfiles"] = True
-        args["savenormalglmfiles"] = True
+        args["saveminimumsLFOfiltfiles"] = True
+        args["savenormalsLFOfiltfiles"] = True
         args["savemovingsignal"] = True
-        args["saveallglmfiles"] = True
+        args["saveallsLFOfiltfiles"] = True
     else:
         print(f"illegal output level {args['outputlevel']}")
         sys.exit()
 
-    # disable memory profiling if necessary
-    if not memprofilerexists:
-        if args["memprofile"]:
-            LGR.info("memprofiler is not installed - disabling memory profiling")
-            args["memprofile"] = False
+    # make the pass options dictionary
+    args["passoptions"] = [
+        {
+            "similaritymetric": "riptide",
+        },
+        {
+            "similaritymetric": "correlation",
+        },
+        {
+            "similaritymetric": "correlation",
+        },
+    ]
 
     # dispersion calculation
     args["dispersioncalc_lower"] = args["lagmin"]
@@ -2150,14 +2351,14 @@ def process_args(inputargs=None):
             args["territorymapname"],
             args["territorymapincludevals"],
         ) = tide_io.processnamespec(
-            args["territorymap"], "Including voxels where ", "in global mean."
+            args["territorymap"], "Including voxels where ", "in initial regressor calculation."
         )
     else:
         args["territorymapname"] = None
         args["territorymapincludevals"] = None
 
-    # this is new enough to do retrospective GLM
-    args["retroglmcompatible"] = True
+    # this is new enough to do retrospective regression filtering
+    args["retroregresscompatible"] = True
 
     LGR.debug("\nafter postprocessing\n{}".format(args))