.. AUTO-GENERATED FILE -- DO NOT EDIT!

interfaces.fsl.model
====================


.. _nipype.interfaces.fsl.model.Cluster:


.. index:: Cluster

Cluster
-------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/model.py#L1950>`__

Wraps the executable command ``cluster``.

Uses FSL cluster to perform clustering on statistical output

Examples
~~~~~~~~

>>> cl = Cluster()
>>> cl.inputs.threshold = 2.3
>>> cl.inputs.in_file = 'zstat1.nii.gz'
>>> cl.inputs.out_localmax_txt_file = 'stats.txt'
>>> cl.inputs.use_mm = True
>>> cl.cmdline
'cluster --in=zstat1.nii.gz --olmax=stats.txt --thresh=2.3000000000 --mm'

Inputs::

        [Mandatory]
        threshold: (a float)
                threshold for input volume
                argument: ``--thresh=%.10f``
        in_file: (an existing file name)
                input volume
                argument: ``--in=%s``

        [Optional]
        dlh: (a float)
                smoothness estimate = sqrt(det(Lambda))
                argument: ``--dlh=%.10f``
        num_maxima: (an integer (int or long))
                no of local maxima to report
                argument: ``--num=%d``
        cope_file: (a file name)
                cope volume
                argument: ``--cope=%s``
        pthreshold: (a float)
                p-threshold for clusters
                argument: ``--pthresh=%.10f``
                requires: dlh, volume
        out_index_file: (a boolean or a file name)
                output of cluster index (in size order)
                argument: ``--oindex=%s``
        out_mean_file: (a boolean or a file name)
                filename for output of mean image
                argument: ``--omean=%s``
        find_min: (a boolean, nipype default value: False)
                find minima instead of maxima
                argument: ``--min``
        std_space_file: (a file name)
                filename for standard-space volume
                argument: ``--stdvol=%s``
        out_localmax_txt_file: (a boolean or a file name)
                local maxima text file
                argument: ``--olmax=%s``
        out_localmax_vol_file: (a boolean or a file name)
                output of local maxima volume
                argument: ``--olmaxim=%s``
        fractional: (a boolean, nipype default value: False)
                interprets the threshold as a fraction of the robust range
                argument: ``--fractional``
        out_max_file: (a boolean or a file name)
                filename for output of max image
                argument: ``--omax=%s``
        out_pval_file: (a boolean or a file name)
                filename for image output of log pvals
                argument: ``--opvals=%s``
        use_mm: (a boolean, nipype default value: False)
                use mm, not voxel, coordinates
                argument: ``--mm``
        minclustersize: (a boolean, nipype default value: False)
                prints out minimum significant cluster size
                argument: ``--minclustersize``
        no_table: (a boolean, nipype default value: False)
                suppresses printing of the table info
                argument: ``--no_table``
        warpfield_file: (a file name)
                file contining warpfield
                argument: ``--warpvol=%s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        volume: (an integer (int or long))
                number of voxels in the mask
                argument: ``--volume=%d``
        connectivity: (an integer (int or long))
                the connectivity of voxels (default 26)
                argument: ``--connectivity=%d``
        out_size_file: (a boolean or a file name)
                filename for output of size image
                argument: ``--osize=%s``
        xfm_file: (a file name)
                filename for Linear: input->standard-space transform. Non-linear:
                input->highres transform
                argument: ``--xfm=%s``
        peak_distance: (a float)
                minimum distance between local maxima/minima, in mm (default 0)
                argument: ``--peakdist=%.10f``
        out_threshold_file: (a boolean or a file name)
                thresholded image
                argument: ``--othresh=%s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

Outputs::

        threshold_file: (a file name)
                thresholded image
        localmax_vol_file: (a file name)
                output of local maxima volume
        size_file: (a file name)
                filename for output of size image
        mean_file: (a file name)
                filename for output of mean image
        max_file: (a file name)
                filename for output of max image
        pval_file: (a file name)
                filename for image output of log pvals
        localmax_txt_file: (a file name)
                local maxima text file
        index_file: (a file name)
                output of cluster index (in size order)

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.model.ContrastMgr:


.. index:: ContrastMgr

ContrastMgr
-----------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/model.py#L1205>`__

Wraps the executable command ``contrast_mgr``.

Use FSL contrast_mgr command to evaluate contrasts

In interface mode this file assumes that all the required inputs are in the
same location. This has deprecated for FSL versions 5.0.7+ as the necessary
corrections file is no longer generated by FILMGLS.

Inputs::

        [Mandatory]
        dof_file: (an existing file name)
                degrees of freedom
        corrections: (an existing file name)
                statistical corrections used within FILM modelling
        param_estimates: (a list of items which are an existing file name)
                Parameter estimates for each column of the design matrix
        sigmasquareds: (an existing file name)
                summary of residuals, See Woolrich, et. al., 2001
        tcon_file: (an existing file name)
                contrast file containing T-contrasts
                argument: ``%s``, position: -1

        [Optional]
        suffix: (a unicode string)
                suffix to put on the end of the cope filename before the contrast
                number, default is nothing
                argument: ``-suffix %s``
        fcon_file: (an existing file name)
                contrast file containing F-contrasts
                argument: ``-f %s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        contrast_num: (an integer >= 1)
                contrast number to start labeling copes from
                argument: ``-cope``

Outputs::

        neffs: (a list of items which are an existing file name)
                neff file ?? for each contrast
        varcopes: (a list of items which are an existing file name)
                Variance estimates for each contrast
        tstats: (a list of items which are an existing file name)
                t-stat file for each contrast
        zstats: (a list of items which are an existing file name)
                z-stat file for each contrast
        fstats: (a list of items which are an existing file name)
                f-stat file for each contrast
        zfstats: (a list of items which are an existing file name)
                z-stat file for each F contrast
        copes: (a list of items which are an existing file name)
                Contrast estimates for each contrast

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.model.DualRegression:


.. index:: DualRegression

DualRegression
--------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/model.py#L2068>`__

Wraps the executable command ``dual_regression``.

Wrapper Script for Dual Regression Workflow

Examples
~~~~~~~~

>>> dual_regression = DualRegression()
>>> dual_regression.inputs.in_files = ["functional.nii", "functional2.nii", "functional3.nii"]
>>> dual_regression.inputs.group_IC_maps_4D = "allFA.nii"
>>> dual_regression.inputs.des_norm = False
>>> dual_regression.inputs.one_sample_group_mean = True
>>> dual_regression.inputs.n_perm = 10
>>> dual_regression.inputs.out_dir = "my_output_directory"
>>> dual_regression.cmdline
'dual_regression allFA.nii 0 -1 10 my_output_directory functional.nii functional2.nii functional3.nii'
>>> dual_regression.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        n_perm: (an integer (int or long))
                Number of permutations for randomise; set to 1 for just raw tstat
                output, set to 0 to not run randomise at all.
                argument: ``%i``, position: 5
        in_files: (a list of items which are an existing file name)
                List all subjects' preprocessed, standard-space 4D datasets
                argument: ``%s``, position: -1
        group_IC_maps_4D: (an existing file name)
                4D image containing spatial IC maps (melodic_IC) from the whole-
                group ICA analysis
                argument: ``%s``, position: 1

        [Optional]
        con_file: (an existing file name)
                Design contrasts for final cross-subject modelling with randomise
                argument: ``%s``, position: 4
        out_dir: (a directory name, nipype default value: output)
                This directory will be created to hold all output and logfiles
                argument: ``%s``, position: 6
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        design_file: (an existing file name)
                Design matrix for final cross-subject modelling with randomise
                argument: ``%s``, position: 3
        one_sample_group_mean: (a boolean)
                perform 1-sample group-mean test instead of generic permutation test
                argument: ``-1``, position: 3
        des_norm: (a boolean, nipype default value: True)
                Whether to variance-normalise the timecourses used as the stage-2
                regressors; True is default and recommended
                argument: ``%i``, position: 2
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

Outputs::

        out_dir: (an existing directory name)

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.model.FEAT:


.. index:: FEAT

FEAT
----

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/model.py#L408>`__

Wraps the executable command ``feat``.

Uses FSL feat to calculate first level stats

Inputs::

        [Mandatory]
        fsf_file: (an existing file name)
                File specifying the feat design spec file
                argument: ``%s``, position: 0

        [Optional]
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables

Outputs::

        feat_dir: (an existing directory name)

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.model.FEATModel:


.. index:: FEATModel

FEATModel
---------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/model.py#L472>`__

Wraps the executable command ``feat_model``.

Uses FSL feat_model to generate design.mat files

Inputs::

        [Mandatory]
        ev_files: (a list of items which are an existing file name)
                Event spec files generated by level1design
                argument: ``%s``, position: 1
        fsf_file: (an existing file name)
                File specifying the feat design spec file
                argument: ``%s``, position: 0

        [Optional]
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

Outputs::

        design_cov: (an existing file name)
                Graphical representation of design covariance
        design_file: (an existing file name)
                Mat file containing ascii matrix for design
        design_image: (an existing file name)
                Graphical representation of design matrix
        con_file: (an existing file name)
                Contrast file containing contrast vectors
        fcon_file: (a file name)
                Contrast file containing contrast vectors

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.model.FEATRegister:


.. index:: FEATRegister

FEATRegister
------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/model.py#L877>`__

Register feat directories to a specific standard

Inputs::

        [Mandatory]
        reg_image: (an existing file name)
                image to register to (will be treated as standard)
        feat_dirs: (a list of items which are an existing directory name)
                Lower level feat dirs

        [Optional]
        reg_dof: (an integer (int or long), nipype default value: 12)
                registration degrees of freedom

Outputs::

        fsf_file: (an existing file name)
                FSL feat specification file

.. _nipype.interfaces.fsl.model.FILMGLS:


.. index:: FILMGLS

FILMGLS
-------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/model.py#L725>`__

Wraps the executable command ``film_gls``.

Use FSL film_gls command to fit a design matrix to voxel timeseries

Examples
~~~~~~~~

Initialize with no options, assigning them when calling run:

>>> from nipype.interfaces import fsl
>>> fgls = fsl.FILMGLS()
>>> res = fgls.run('in_file', 'design_file', 'thresh', rn='stats') #doctest: +SKIP

Assign options through the ``inputs`` attribute:

>>> fgls = fsl.FILMGLS()
>>> fgls.inputs.in_file = 'functional.nii'
>>> fgls.inputs.design_file = 'design.mat'
>>> fgls.inputs.threshold = 10
>>> fgls.inputs.results_dir = 'stats'
>>> res = fgls.run() #doctest: +SKIP

Specify options when creating an instance:

>>> fgls = fsl.FILMGLS(in_file='functional.nii', design_file='design.mat', threshold=10, results_dir='stats')
>>> res = fgls.run() #doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input data file
                argument: ``%s``, position: -3

        [Optional]
        output_pwdata: (a boolean)
                output prewhitened data and average design matrix
                argument: ``-output_pwdata``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        smooth_autocorr: (a boolean)
                Smooth auto corr estimates
                argument: ``-sa``
        results_dir: (a directory name, nipype default value: results)
                directory to store results in
                argument: ``-rn %s``
        fit_armodel: (a boolean)
                fits autoregressive model - default is to use tukey with
                M=sqrt(numvols)
                argument: ``-ar``
                mutually_exclusive: autocorr_estimate_only, fit_armodel,
                  tukey_window, multitaper_product, use_pava, autocorr_noestimate
        design_file: (an existing file name)
                design matrix file
                argument: ``%s``, position: -2
        brightness_threshold: (an integer >= 0)
                susan brightness threshold, otherwise it is estimated
                argument: ``-epith %d``
        mask_size: (an integer (int or long))
                susan mask size
                argument: ``-ms %d``
        tukey_window: (an integer (int or long))
                tukey window size to estimate autocorr
                argument: ``-tukey %d``
                mutually_exclusive: autocorr_estimate_only, fit_armodel,
                  tukey_window, multitaper_product, use_pava, autocorr_noestimate
        full_data: (a boolean)
                output full data
                argument: ``-v``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        multitaper_product: (an integer (int or long))
                multitapering with slepian tapers and num is the time-bandwidth
                product
                argument: ``-mt %d``
                mutually_exclusive: autocorr_estimate_only, fit_armodel,
                  tukey_window, multitaper_product, use_pava, autocorr_noestimate
        autocorr_estimate_only: (a boolean)
                perform autocorrelation estimatation only
                argument: ``-ac``
                mutually_exclusive: autocorr_estimate_only, fit_armodel,
                  tukey_window, multitaper_product, use_pava, autocorr_noestimate
        threshold: (a floating point number >= 0.0, nipype default value:
                  1000.0)
                threshold
                argument: ``%f``, position: -1
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        use_pava: (a boolean)
                estimates autocorr using PAVA
                argument: ``-pava``
        autocorr_noestimate: (a boolean)
                do not estimate autocorrs
                argument: ``-noest``
                mutually_exclusive: autocorr_estimate_only, fit_armodel,
                  tukey_window, multitaper_product, use_pava, autocorr_noestimate

Outputs::

        corrections: (an existing file name)
                statistical corrections used within FILM modeling
        results_dir: (an existing directory name)
                directory storing model estimation output
        param_estimates: (a list of items which are an existing file name)
                Parameter estimates for each column of the design matrix
        sigmasquareds: (an existing file name)
                summary of residuals, See Woolrich, et. al., 2001
        dof_file: (an existing file name)
                degrees of freedom
        logfile: (an existing file name)
                FILM run logfile
        thresholdac: (an existing file name)
                The FILM autocorrelation parameters
        residual4d: (an existing file name)
                Model fit residual mean-squared error for each time point

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.model.FLAMEO:


.. index:: FLAMEO

FLAMEO
------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/model.py#L1012>`__

Wraps the executable command ``flameo``.

Use FSL flameo command to perform higher level model fits

Examples
~~~~~~~~

Initialize FLAMEO with no options, assigning them when calling run:

>>> from nipype.interfaces import fsl
>>> flameo = fsl.FLAMEO()
>>> flameo.inputs.cope_file = 'cope.nii.gz'
>>> flameo.inputs.var_cope_file = 'varcope.nii.gz'
>>> flameo.inputs.cov_split_file = 'cov_split.mat'
>>> flameo.inputs.design_file = 'design.mat'
>>> flameo.inputs.t_con_file = 'design.con'
>>> flameo.inputs.mask_file = 'mask.nii'
>>> flameo.inputs.run_mode = 'fe'
>>> flameo.cmdline
'flameo --copefile=cope.nii.gz --covsplitfile=cov_split.mat --designfile=design.mat --ld=stats --maskfile=mask.nii --runmode=fe --tcontrastsfile=design.con --varcopefile=varcope.nii.gz'

Inputs::

        [Mandatory]
        cope_file: (an existing file name)
                cope regressor data file
                argument: ``--copefile=%s``
        design_file: (an existing file name)
                design matrix file
                argument: ``--designfile=%s``
        cov_split_file: (an existing file name)
                ascii matrix specifying the groups the covariance is split into
                argument: ``--covsplitfile=%s``
        t_con_file: (an existing file name)
                ascii matrix specifying t-contrasts
                argument: ``--tcontrastsfile=%s``
        mask_file: (an existing file name)
                mask file
                argument: ``--maskfile=%s``
        run_mode: (u'fe' or u'ols' or u'flame1' or u'flame12')
                inference to perform
                argument: ``--runmode=%s``

        [Optional]
        sigma_dofs: (an integer (int or long))
                sigma (in mm) to use for Gaussian smoothing the DOFs in FLAME 2.
                Default is 1mm, -1 indicates no smoothing
                argument: ``--sigma_dofs=%d``
        f_con_file: (an existing file name)
                ascii matrix specifying f-contrasts
                argument: ``--fcontrastsfile=%s``
        burnin: (an integer (int or long))
                number of jumps at start of mcmc to be discarded
                argument: ``--burnin=%d``
        outlier_iter: (an integer (int or long))
                Number of max iterations to use when inferring outliers. Default is
                12.
                argument: ``--ioni=%d``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        sample_every: (an integer (int or long))
                number of jumps for each sample
                argument: ``--sampleevery=%d``
        n_jumps: (an integer (int or long))
                number of jumps made by mcmc
                argument: ``--njumps=%d``
        dof_var_cope_file: (an existing file name)
                dof data file for varcope data
                argument: ``--dofvarcopefile=%s``
        no_pe_outputs: (a boolean)
                do not output pe files
                argument: ``--nopeoutput``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        log_dir: (a directory name, nipype default value: stats)
                argument: ``--ld=%s``
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        infer_outliers: (a boolean)
                infer outliers - not for fe
                argument: ``--inferoutliers``
        var_cope_file: (an existing file name)
                varcope weightings data file
                argument: ``--varcopefile=%s``
        fix_mean: (a boolean)
                fix mean for tfit
                argument: ``--fixmean``

Outputs::

        mrefvars: (a list of items which are an existing file name)
                mean random effect variances for each contrast
        tstats: (a list of items which are an existing file name)
                t-stat file for each contrast
        pes: (a list of items which are an existing file name)
                Parameter estimates for each column of the design matrix for each
                voxel
        stats_dir: (a directory name)
                directory storing model estimation output
        zstats: (a list of items which are an existing file name)
                z-stat file for each contrast
        weights: (a list of items which are an existing file name)
                weights file for each contrast
        tdof: (a list of items which are an existing file name)
                temporal dof file for each contrast
        var_copes: (a list of items which are an existing file name)
                Variance estimates for each contrast
        copes: (a list of items which are an existing file name)
                Contrast estimates for each contrast
        fstats: (a list of items which are an existing file name)
                f-stat file for each contrast
        zfstats: (a list of items which are an existing file name)
                z stat file for each f contrast
        res4d: (a list of items which are an existing file name)
                Model fit residual mean-squared error for each time point

References:
~~~~~~~~~~~
None
None

.. _nipype.interfaces.fsl.model.GLM:


.. index:: GLM

GLM
---

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/model.py#L2356>`__

Wraps the executable command ``fsl_glm``.

FSL GLM:

Example
~~~~~~~
>>> import nipype.interfaces.fsl as fsl
>>> glm = fsl.GLM(in_file='functional.nii', design='maps.nii', output_type='NIFTI')
>>> glm.cmdline
'fsl_glm -i functional.nii -d maps.nii -o functional_glm.nii'

Inputs::

        [Mandatory]
        design: (an existing file name)
                file name of the GLM design matrix (text time courses for temporal
                regression or an image file for spatial regression)
                argument: ``-d %s``, position: 2
        in_file: (an existing file name)
                input file name (text matrix or 3D/4D image file)
                argument: ``-i %s``, position: 1

        [Optional]
        out_sigsq_name: (a file name)
                output file name for residual noise variance sigma-square
                argument: ``--out_sigsq=%s``
        dof: (an integer (int or long))
                set degrees of freedom explicitly
                argument: ``--dof=%d``
        out_pf_name: (a file name)
                output file name for p-value for full model fit
                argument: ``--out_pf=%s``
        out_t_name: (a file name)
                output file name for t-stats (either as txt or image
                argument: ``--out_t=%s``
        out_cope: (a file name)
                output file name for COPE (either as txt or image
                argument: ``--out_cope=%s``
        mask: (an existing file name)
                mask image file name if input is image
                argument: ``-m %s``
        out_res_name: (a file name)
                output file name for residuals
                argument: ``--out_res=%s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        out_vnscales_name: (a file name)
                output file name for scaling factors for variance normalisation
                argument: ``--out_vnscales=%s``
        out_varcb_name: (a file name)
                output file name for variance of COPEs
                argument: ``--out_varcb=%s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        out_z_name: (a file name)
                output file name for Z-stats (either as txt or image
                argument: ``--out_z=%s``
        var_norm: (a boolean)
                perform MELODIC variance-normalisation on data
                argument: ``--vn``
        out_f_name: (a file name)
                output file name for F-value of full model fit
                argument: ``--out_f=%s``
        out_data_name: (a file name)
                output file name for pre-processed data
                argument: ``--out_data=%s``
        contrasts: (an existing file name)
                matrix of t-statics contrasts
                argument: ``-c %s``
        out_file: (a file name)
                filename for GLM parameter estimates (GLM betas)
                argument: ``-o %s``, position: 3
        dat_norm: (a boolean)
                switch on normalization of the data time series to unit std
                deviation
                argument: ``--dat_norm``
        demean: (a boolean)
                switch on demeaining of design and data
                argument: ``--demean``
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        des_norm: (a boolean)
                switch on normalization of the design matrix columns to unit std
                deviation
                argument: ``--des_norm``
        out_p_name: (a file name)
                output file name for p-values of Z-stats (either as text file or
                image)
                argument: ``--out_p=%s``

Outputs::

        out_res: (a list of items which are an existing file name)
                output file name for residuals
        out_varcb: (a list of items which are an existing file name)
                output file name for variance of COPEs
        out_f: (a list of items which are an existing file name)
                output file name for F-value of full model fit
        out_file: (an existing file name)
                file name of GLM parameters (if generated)
        out_vnscales: (a list of items which are an existing file name)
                output file name for scaling factors for variance normalisation
        out_cope: (a list of items which are an existing file name)
                output file name for COPEs (either as text file or image)
        out_sigsq: (a list of items which are an existing file name)
                output file name for residual noise variance sigma-square
        out_t: (a list of items which are an existing file name)
                output file name for t-stats (either as text file or image)
        out_pf: (a list of items which are an existing file name)
                output file name for p-value for full model fit
        out_p: (a list of items which are an existing file name)
                output file name for p-values of Z-stats (either as text file or
                image)
        out_data: (a list of items which are an existing file name)
                output file for preprocessed data
        out_z: (a list of items which are an existing file name)
                output file name for COPEs (either as text file or image)

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.model.L2Model:


.. index:: L2Model

L2Model
-------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/model.py#L1315>`__

Generate subject specific second level model

Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import L2Model
>>> model = L2Model(num_copes=3) # 3 sessions

Inputs::

        [Mandatory]
        num_copes: (an integer >= 1)
                number of copes to be combined

Outputs::

        design_grp: (an existing file name)
                design group file
        design_con: (an existing file name)
                design contrast file
        design_mat: (an existing file name)
                design matrix file

.. _nipype.interfaces.fsl.model.Level1Design:


.. index:: Level1Design

Level1Design
------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/model.py#L96>`__

Generate FEAT specific files

Examples
~~~~~~~~

>>> level1design = Level1Design()
>>> level1design.inputs.interscan_interval = 2.5
>>> level1design.inputs.bases = {'dgamma':{'derivs': False}}
>>> level1design.inputs.session_info = 'session_info.npz'
>>> level1design.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        interscan_interval: (a float)
                Interscan interval (in secs)
        model_serial_correlations: (a boolean)
                Option to model serial correlations using an autoregressive
                estimator (order 1). Setting this option is only useful in the
                context of the fsf file. If you set this to False, you need to
                repeat this option for FILMGLS by setting autocorr_noestimate to
                True
        bases: (a dictionary with keys which are u'dgamma' and with values
                  which are a dictionary with keys which are u'derivs' and with
                  values which are a boolean or a dictionary with keys which are
                  u'gamma' and with values which are a dictionary with keys which
                  are u'derivs' or u'gammasigma' or u'gammadelay' and with values
                  which are any value or a dictionary with keys which are u'custom'
                  and with values which are a dictionary with keys which are
                  u'bfcustompath' and with values which are a unicode string or a
                  dictionary with keys which are u'none' and with values which are a
                  dictionary with keys which are any value and with values which are
                  any value or a dictionary with keys which are u'none' and with
                  values which are None)
                name of basis function and options e.g., {'dgamma': {'derivs':
                True}}
        session_info: (any value)
                Session specific information generated by ``modelgen.SpecifyModel``

        [Optional]
        orthogonalization: (a dictionary with keys which are an integer (int
                  or long) and with values which are a dictionary with keys which
                  are an integer (int or long) and with values which are a boolean
                  or an integer (int or long), nipype default value: {})
                which regressors to make orthogonal e.g., {1: {0:0,1:0,2:0}, 2:
                {0:1,1:1,2:0}} to make the second regressor in a 2-regressor model
                orthogonal to the first.
        contrasts: (a list of items which are a tuple of the form: (a unicode
                  string, u'T', a list of items which are a unicode string, a list
                  of items which are a float) or a tuple of the form: (a unicode
                  string, u'T', a list of items which are a unicode string, a list
                  of items which are a float, a list of items which are a float) or
                  a tuple of the form: (a unicode string, u'F', a list of items
                  which are a tuple of the form: (a unicode string, u'T', a list of
                  items which are a unicode string, a list of items which are a
                  float) or a tuple of the form: (a unicode string, u'T', a list of
                  items which are a unicode string, a list of items which are a
                  float, a list of items which are a float)))
                List of contrasts with each contrast being a list of the form -
                [('name', 'stat', [condition list], [weight list], [session list])].
                if session list is None or not provided, all sessions are used. For
                F contrasts, the condition list should contain previously defined
                T-contrasts.

Outputs::

        ev_files: (a list of items which are a list of items which are an
                  existing file name)
                condition information files
        fsf_files: (a list of items which are an existing file name)
                FSL feat specification files

.. _nipype.interfaces.fsl.model.MELODIC:


.. index:: MELODIC

MELODIC
-------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/model.py#L1734>`__

Wraps the executable command ``melodic``.

Multivariate Exploratory Linear Optimised Decomposition into Independent
Components

Examples
~~~~~~~~

>>> melodic_setup = MELODIC()
>>> melodic_setup.inputs.approach = 'tica'
>>> melodic_setup.inputs.in_files = ['functional.nii', 'functional2.nii', 'functional3.nii']
>>> melodic_setup.inputs.no_bet = True
>>> melodic_setup.inputs.bg_threshold = 10
>>> melodic_setup.inputs.tr_sec = 1.5
>>> melodic_setup.inputs.mm_thresh = 0.5
>>> melodic_setup.inputs.out_stats = True
>>> melodic_setup.inputs.t_des = 'timeDesign.mat'
>>> melodic_setup.inputs.t_con = 'timeDesign.con'
>>> melodic_setup.inputs.s_des = 'subjectDesign.mat'
>>> melodic_setup.inputs.s_con = 'subjectDesign.con'
>>> melodic_setup.inputs.out_dir = 'groupICA.out'
>>> melodic_setup.cmdline
'melodic -i functional.nii,functional2.nii,functional3.nii -a tica --bgthreshold=10.000000 --mmthresh=0.500000 --nobet -o groupICA.out --Ostats --Scon=subjectDesign.con --Sdes=subjectDesign.mat --Tcon=timeDesign.con --Tdes=timeDesign.mat --tr=1.500000'
>>> melodic_setup.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_files: (a list of items which are an existing file name)
                input file names (either single file name or a list)
                argument: ``-i %s``, position: 0

        [Optional]
        dim_est: (a unicode string)
                use specific dim. estimation technique: lap, bic, mdl, aic, mean
                (default: lap)
                argument: ``--dimest=%s``
        out_dir: (a directory name)
                output directory name
                argument: ``-o %s``
        pbsc: (a boolean)
                switch off conversion to percent BOLD signal change
                argument: ``--pbsc``
        smode: (an existing file name)
                matrix of session modes for report generation
                argument: ``--smode=%s``
        out_orig: (a boolean)
                output the original ICs
                argument: ``--Oorig``
        sep_whiten: (a boolean)
                switch on separate whitening
                argument: ``--sep_whiten``
        t_des: (an existing file name)
                design matrix across time-domain
                argument: ``--Tdes=%s``
        maxit: (an integer (int or long))
                maximum number of iterations before restart
                argument: ``--maxit=%d``
        report_maps: (a unicode string)
                control string for spatial map images (see slicer)
                argument: ``--report_maps=%s``
        t_con: (an existing file name)
                t-contrast matrix across time-domain
                argument: ``--Tcon=%s``
        num_ICs: (an integer (int or long))
                number of IC's to extract (for deflation approach)
                argument: ``-n %d``
        no_mm: (a boolean)
                switch off mixture modelling on IC maps
                argument: ``--no_mm``
        log_power: (a boolean)
                calculate log of power for frequency spectrum
                argument: ``--logPower``
        var_norm: (a boolean)
                switch off variance normalization
                argument: ``--vn``
        cov_weight: (a float)
                voxel-wise weights for the covariance matrix (e.g. segmentation
                information)
                argument: ``--covarweight=%f``
        tr_sec: (a float)
                TR in seconds
                argument: ``--tr=%f``
        mix: (an existing file name)
                mixing matrix for mixture modelling / filtering
                argument: ``--mix=%s``
        migpN: (an integer (int or long))
                number of internal Eigenmaps
                argument: ``--migpN %d``
        out_all: (a boolean)
                output everything
                argument: ``--Oall``
        epsilonS: (a float)
                minimum error change for rank-1 approximation in TICA
                argument: ``--epsS=%f``
        migp: (a boolean)
                switch on MIGP data reduction
                argument: ``--migp``
        migp_factor: (an integer (int or long))
                Internal Factor of mem-threshold relative to number of Eigenmaps
                (default: 2)
                argument: ``--migp_factor %d``
        approach: (a unicode string)
                approach for decomposition, 2D: defl, symm (default), 3D: tica
                (default), concat
                argument: ``-a %s``
        update_mask: (a boolean)
                switch off mask updating
                argument: ``--update_mask``
        no_mask: (a boolean)
                switch off masking
                argument: ``--nomask``
        out_mean: (a boolean)
                output mean volume
                argument: ``--Omean``
        bg_threshold: (a float)
                brain/non-brain threshold used to mask non-brain voxels, as a
                percentage (only if --nobet selected)
                argument: ``--bgthreshold=%f``
        out_unmix: (a boolean)
                output unmixing matrix
                argument: ``--Ounmix``
        sep_vn: (a boolean)
                switch off joined variance normalization
                argument: ``--sep_vn``
        epsilon: (a float)
                minimum error change
                argument: ``--eps=%f``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        rem_cmp: (a list of items which are an integer (int or long))
                component numbers to remove
                argument: ``-f %d``
        remove_deriv: (a boolean)
                removes every second entry in paradigm file (EV derivatives)
                argument: ``--remove_deriv``
        bg_image: (an existing file name)
                specify background image for report (default: mean image)
                argument: ``--bgimage=%s``
        non_linearity: (a unicode string)
                nonlinearity: gauss, tanh, pow3, pow4
                argument: ``--nl=%s``
        out_pca: (a boolean)
                output PCA results
                argument: ``--Opca``
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        report: (a boolean)
                generate Melodic web report
                argument: ``--report``
        s_con: (an existing file name)
                t-contrast matrix across subject-domain
                argument: ``--Scon=%s``
        migp_shuffle: (a boolean)
                randomise MIGP file order (default: TRUE)
                argument: ``--migp_shuffle``
        dim: (an integer (int or long))
                dimensionality reduction into #num dimensions (default: automatic
                estimation)
                argument: ``-d %d``
        s_des: (an existing file name)
                design matrix across subject-domain
                argument: ``--Sdes=%s``
        no_bet: (a boolean)
                switch off BET
                argument: ``--nobet``
        mask: (an existing file name)
                file name of mask for thresholding
                argument: ``-m %s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        max_restart: (an integer (int or long))
                maximum number of restarts
                argument: ``--maxrestart=%d``
        mm_thresh: (a float)
                threshold for Mixture Model based inference
                argument: ``--mmthresh=%f``
        ICs: (an existing file name)
                filename of the IC components file for mixture modelling
                argument: ``--ICs=%s``
        out_stats: (a boolean)
                output thresholded maps and probability maps
                argument: ``--Ostats``
        out_white: (a boolean)
                output whitening/dewhitening matrices
                argument: ``--Owhite``

Outputs::

        report_dir: (an existing directory name)
        out_dir: (an existing directory name)

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.model.MultipleRegressDesign:


.. index:: MultipleRegressDesign

MultipleRegressDesign
---------------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/model.py#L1416>`__

Generate multiple regression design

.. note::
  FSL does not demean columns for higher level analysis.

Please see `FSL documentation
<http://www.fmrib.ox.ac.uk/fsl/feat5/detail.html#higher>`_
for more details on model specification for higher level analysis.

Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import MultipleRegressDesign
>>> model = MultipleRegressDesign()
>>> model.inputs.contrasts = [['group mean', 'T',['reg1'],[1]]]
>>> model.inputs.regressors = dict(reg1=[1, 1, 1], reg2=[2.,-4, 3])
>>> model.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        contrasts: (a list of items which are a tuple of the form: (a unicode
                  string, u'T', a list of items which are a unicode string, a list
                  of items which are a float) or a tuple of the form: (a unicode
                  string, u'F', a list of items which are a tuple of the form: (a
                  unicode string, u'T', a list of items which are a unicode string,
                  a list of items which are a float)))
                List of contrasts with each contrast being a list of the form -
                [('name', 'stat', [condition list], [weight list])]. if session list
                is None or not provided, all sessions are used. For F contrasts, the
                condition list should contain previously defined T-contrasts without
                any weight list.
        regressors: (a dictionary with keys which are a unicode string and
                  with values which are a list of items which are a float)
                dictionary containing named lists of regressors

        [Optional]
        groups: (a list of items which are an integer (int or long))
                list of group identifiers (defaults to single group)

Outputs::

        design_fts: (an existing file name)
                design f-contrast file
        design_grp: (an existing file name)
                design group file
        design_mat: (an existing file name)
                design matrix file
        design_con: (an existing file name)
                design t-contrast file

.. _nipype.interfaces.fsl.model.Randomise:


.. index:: Randomise

Randomise
---------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/model.py#L2193>`__

Wraps the executable command ``randomise``.

FSL Randomise: feeds the 4D projected FA data into GLM
modelling and thresholding
in order to find voxels which correlate with your model

Example
~~~~~~~
>>> import nipype.interfaces.fsl as fsl
>>> rand = fsl.Randomise(in_file='allFA.nii', mask = 'mask.nii', tcon='design.con', design_mat='design.mat')
>>> rand.cmdline
'randomise -i allFA.nii -o "randomise" -d design.mat -t design.con -m mask.nii'

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                4D input file
                argument: ``-i %s``, position: 0

        [Optional]
        one_sample_group_mean: (a boolean)
                perform 1-sample group-mean test instead of generic permutation test
                argument: ``-1``
        vox_p_values: (a boolean)
                output voxelwise (corrected and uncorrected) p-value images
                argument: ``-x``
        show_total_perms: (a boolean)
                print out how many unique permutations would be generated and exit
                argument: ``-q``
        tfce2D: (a boolean)
                carry out Threshold-Free Cluster Enhancement with 2D optimisation
                argument: ``--T2``
        f_cm_thresh: (a float)
                carry out f cluster-mass thresholding
                argument: ``-S %.2f``
        p_vec_n_dist_files: (a boolean)
                output permutation vector and null distribution text files
                argument: ``-P``
        cm_thresh: (a float)
                carry out cluster-mass-based thresholding
                argument: ``-C %.1f``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        f_only: (a boolean)
                calculate f-statistics only
                argument: ``--f_only``
        tfce_H: (a float)
                TFCE height parameter (default=2)
                argument: ``--tfce_H=%.2f``
        tfce: (a boolean)
                carry out Threshold-Free Cluster Enhancement
                argument: ``-T``
        tfce_E: (a float)
                TFCE extent parameter (default=0.5)
                argument: ``--tfce_E=%.2f``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        tfce_C: (a float)
                TFCE connectivity (6 or 26; default=6)
                argument: ``--tfce_C=%.2f``
        raw_stats_imgs: (a boolean)
                output raw ( unpermuted ) statistic images
                argument: ``-R``
        f_c_thresh: (a float)
                carry out f cluster thresholding
                argument: ``-F %.2f``
        var_smooth: (an integer (int or long))
                use variance smoothing (std is in mm)
                argument: ``-v %d``
        design_mat: (an existing file name)
                design matrix file
                argument: ``-d %s``, position: 2
        tcon: (an existing file name)
                t contrasts file
                argument: ``-t %s``, position: 3
        show_info_parallel_mode: (a boolean)
                print out information required for parallel mode and exit
                argument: ``-Q``
        base_name: (a unicode string, nipype default value: randomise)
                the rootname that all generated files will have
                argument: ``-o "%s"``, position: 1
        num_perm: (an integer (int or long))
                number of permutations (default 5000, set to 0 for exhaustive)
                argument: ``-n %d``
        mask: (an existing file name)
                mask image
                argument: ``-m %s``
        c_thresh: (a float)
                carry out cluster-based thresholding
                argument: ``-c %.1f``
        x_block_labels: (an existing file name)
                exchangeability block labels file
                argument: ``-e %s``
        seed: (an integer (int or long))
                specific integer seed for random number generator
                argument: ``--seed=%d``
        demean: (a boolean)
                demean data temporally before model fitting
                argument: ``-D``
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        fcon: (an existing file name)
                f contrasts file
                argument: ``-f %s``

Outputs::

        tstat_files: (a list of items which are an existing file name)
                t contrast raw statistic
        t_p_files: (a list of items which are an existing file name)
                f contrast uncorrected p values files
        f_p_files: (a list of items which are an existing file name)
                f contrast uncorrected p values files
        f_corrected_p_files: (a list of items which are an existing file
                  name)
                f contrast FWE (Family-wise error) corrected p values files
        t_corrected_p_files: (a list of items which are an existing file
                  name)
                t contrast FWE (Family-wise error) corrected p values files
        fstat_files: (a list of items which are an existing file name)
                f contrast raw statistic

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.model.SMM:


.. index:: SMM

SMM
---

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/model.py#L1573>`__

Wraps the executable command ``mm --ld=logdir``.

Spatial Mixture Modelling. For more detail on the spatial mixture modelling
see Mixture Models with Adaptive Spatial Regularisation for Segmentation
with an Application to FMRI Data; Woolrich, M., Behrens, T., Beckmann, C.,
and Smith, S.; IEEE Trans. Medical Imaging, 24(1):1-11, 2005.

Inputs::

        [Mandatory]
        spatial_data_file: (an existing file name)
                statistics spatial map
                argument: ``--sdf="%s"``, position: 0
        mask: (an existing file name)
                mask file
                argument: ``--mask="%s"``, position: 1

        [Optional]
        no_deactivation_class: (a boolean)
                enforces no deactivation class
                argument: ``--zfstatmode``, position: 2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

Outputs::

        activation_p_map: (an existing file name)
        deactivation_p_map: (an existing file name)
        null_p_map: (an existing file name)

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.model.SmoothEstimate:


.. index:: SmoothEstimate

SmoothEstimate
--------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/model.py#L1805>`__

Wraps the executable command ``smoothest``.

Estimates the smoothness of an image

Examples
~~~~~~~~

>>> est = SmoothEstimate()
>>> est.inputs.zstat_file = 'zstat1.nii.gz'
>>> est.inputs.mask_file = 'mask.nii'
>>> est.cmdline
'smoothest --mask=mask.nii --zstat=zstat1.nii.gz'

Inputs::

        [Mandatory]
        mask_file: (an existing file name)
                brain mask volume
                argument: ``--mask=%s``
        dof: (an integer (int or long))
                number of degrees of freedom
                argument: ``--dof=%d``
                mutually_exclusive: zstat_file

        [Optional]
        residual_fit_file: (an existing file name)
                residual-fit image file
                argument: ``--res=%s``
                requires: dof
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        zstat_file: (an existing file name)
                zstat image file
                argument: ``--zstat=%s``
                mutually_exclusive: dof
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

Outputs::

        volume: (an integer (int or long))
                number of voxels in mask
        resels: (a float)
                number of resels
        dlh: (a float)
                smoothness estimate sqrt(det(Lambda))

References:
~~~~~~~~~~~
None

.. module:: nipype.interfaces.fsl.model


.. _nipype.interfaces.fsl.model.load_template:

:func:`load_template`
---------------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/model.py#L2412>`__



Load a template from the model_templates directory

Parameters
~~~~~~~~~~
name : str
    The name of the file to load

Returns
~~~~~~~
template : string.Template

