Suggested Choices for Basis Functions

Here are some recommended basis functions to apply to 3dDeconvolve using
'-stim_times' under various circumstances.   Feel free to use other basis
functions, but preferably when you are pretty sure of what you are doing.

Note that when the option '-basis_normall MAX' is applied, all subsequent
basis functions will have a maximum height of MAX.  Otherwise, the default
height is 1, except for the BLOCK() function.  In these common examples,
there is no need to use '-basis_normall' at all.

deconvolution (variable-shape regression): TENT(b,c,n)
    TENT(b,c,n)
                                                                                
        b : The start time (after stimulus), usually 0.
        c : The end time, should be the maximum expected response duration
            (perhaps 'rounded' to the next highest TR time).
        n : The number of TENT functions to apply.  Note that since the first
            and last TENTs are half-TENTs, n TENTs covers n-1 intervals, where
            each interval is shared by 2 TENTs (crossing in an X-pattern).
            One TENT will last for 2 intervals (rise for 1, fall for 1).

            Note that 'n' can be anything greater than 1.  Often users wish to
            have the TENTs TR-locked, meaning each TENT is centered at a TR
            time.  That way the TENTs can be viewed as a TR-locked hemodynamic
            response time series (having n values, and lasting n-1 TRs).

            For instance, if the TR is 3 seconds, and the expected HRF is 15
            seconds, one might use TENT(0,15,6).  Note tsat 15/(6-1) is 3.
 
regression (fixed-shape regression): GAM, BLOCK(d,p) or BLOCK(d)
    GAM

        If the stimuli are brief (0-2 seconds, say), and are of the same
        length (or have the same average length, across stimulus classes),
        then GAM might make sense.  The GAM curve lasts about 12 seconds.

        In this case, the beta weights represent the peak height of the
        resulting GAM curves found in the data.

    BLOCK(d,p)
                                                                               
        d : The duration of a single stimulus event (maybe 1-30 seconds).
        p : The peak amplitude of the curve, usually 1.

        BLOCK() is created by convolving an incomplete gamma function (very
        similar to a GAM function) with a boxcar function (equal to 1 over
        the stimulus duration, and 0 elsewhere), where each has a height of 1.

        It will convolve to a maximum height of about 5.114, once the block
        length reaches about 15 seconds.  Above 15 seconds, the curve will
        plateau at 5.114 before returning to 0.  The BLOCK curve lasts about
        15.8 seconds longer than the stimulus duration.  So if each stimulus
        lasts 20 seconds, then the basis function for a single such stimulus
        would last (be non-zero) for 35.8 seconds.

        If the stimuli are longer (than 1 or 2 seconds, say), and the stimuli
        of each stimulus class last the same duration, then the 2-parameter
        BLOCK() function might be used, usually with p=1, where p is the
        height of the curve.
                                                                               
        Note that the stimulus timing file would have only 1 stimulus per
        BLOCK.  If each stimulus lasts 20 seconds, then the basis function
        for a single such stimulus would last for about 35.8 seconds, namely
        BLOCK(20,1).

        In this case, each beta weight represents the peak height of the
        corresponding BLOCK curve for that class (assuming p=1), i.e. the
        beta weight is the magnitude of the response to the entire stimulus
        block.

    BLOCK(d)

        d : The duration of a single stimulus event (maybe 1-30 seconds).

        It is recommended not to use '-basis_normall 1' with BLOCK(d), unless
        you are pretty sure of yourself.

        As opposed to the 2-parameter block function, this function would
        be used when the stimulus lengths differ between classes, i.e. if
        stimulus class 1 has 7-second stimuli, and stimulus class 2 has
        11-second stimuli.

        A longer stimulus is expected to result in a bigger response, perhaps
        up to a limit of a 15-second stimulus.  So if any stimulus class has
        a duration less than 15 seconds, and that duration differs from that
        of any other stimulus class, this 1-parameter BLOCK() function may be
        good to use.  The bigger response will be accounted for by the basis
        functions, allowing a valid comparison between the beta weights.

        As an example, imagine that class 1 is for a 3-second stimulus of some
        type.  If class 2 is for a 7-second stimulus which is exactly the same
        as the class 1 stimulus, just longer, we would hope to be able to say
        that these have the same response (in some way), because they are the
        same type of stimulus.  But clearly, the 7-second stimuli ought to
        generate a bigger response than the 3-second stimuli.

        Assuming the brain works as we hope, then using BLOCK(3) and BLOCK(7)
        for the basis functions of these 2 classes would result in exactly
        the same beta weights output by 3dDeconvolve, while the columns of
        the X-matrix would differ by a scalar.

        ---

        Recall that a BLOCK() curve is created by convolving a function
        similar to GAM with a boxcar function.  In the case of a 1-parameter
        BLOCK() function, each beta weight represents not the peak height of
        the corresponding BLOCK curve (as they did with the 2-parameter
        BLOCK() function), but the height of the underlying incomplete gamma
        variate function that was convolved with the boxcar function.

        So the beta weight would represent not the magnitude of the response
        to a single, long stimulus, but the magnitude of the response as if
        the stimulus were instantaneous.  This is meant to remove the
        differences due to different stimulus durations.