iterfield=['fsf_file', 'ev_files'])
"""
Use :class:`nipype.interfaces.fsl.FILMGLS` to estimate a model specified by a
mat file and a functional run
"""
modelestimate = pe.MapNode(interface=fsl.FILMGLS(smooth_autocorr=True,
mask_size=5,
threshold=1000),
name='modelestimate',
iterfield=['design_file', 'in_file'])
"""
Use :class:`nipype.interfaces.fsl.ContrastMgr` to generate contrast estimates
"""
conestimate = pe.MapNode(interface=fsl.ContrastMgr(),
name='conestimate',
iterfield=[
'tcon_file', 'param_estimates', 'sigmasquareds',
'corrections', 'dof_file'
])
modelfit.connect([
(modelspec, level1design, [('session_info', 'session_info')]),
(level1design, modelgen, [('fsf_files', 'fsf_file'),
('ev_files', 'ev_files')]),
(modelgen, modelestimate, [('design_file', 'design_file')]),
(modelgen, conestimate, [('con_file', 'tcon_file')]),
(modelestimate, conestimate, [('param_estimates', 'param_estimates'),
('sigmasquareds', 'sigmasquareds'),
('corrections', 'corrections'),
def create_first(name='modelfit'):
"""First level task-fMRI modelling workflow
Parameters
----------
name : name of workflow. Default = 'modelfit'
Inputs
------
inputspec.session_info :
inputspec.interscan_interval :
inputspec.contrasts :
inputspec.film_threshold :
inputspec.functional_data :
inputspec.bases :
inputspec.model_serial_correlations :
Outputs
-------
outputspec.copes :
outputspec.varcopes :
outputspec.dof_file :
outputspec.pfiles :
outputspec.parameter_estimates :
outputspec.zstats :
outputspec.tstats :
outputspec.design_image :
outputspec.design_file :
outputspec.design_cov :
Returns
-------
workflow : first-level workflow
"""
import nipype.interfaces.fsl as fsl # fsl
import nipype.pipeline.engine as pe
import nipype.interfaces.utility as util
modelfit = pe.Workflow(name=name)
inputspec = pe.Node(util.IdentityInterface(fields=[
'session_info', 'interscan_interval', 'contrasts', 'film_threshold',
'functional_data', 'bases', 'model_serial_correlations'
]),
name='inputspec')
level1design = pe.Node(interface=fsl.Level1Design(),
name="create_level1_design")
modelgen = pe.MapNode(interface=fsl.FEATModel(),
name='generate_model',
iterfield=['fsf_file', 'ev_files'])
modelestimate = pe.MapNode(interface=fsl.FILMGLS(smooth_autocorr=True,
mask_size=5),
name='estimate_model',
iterfield=['design_file', 'in_file'])
conestimate = pe.MapNode(interface=fsl.ContrastMgr(),
name='estimate_contrast',
iterfield=[
'tcon_file', 'param_estimates',
'sigmasquareds', 'corrections', 'dof_file'
])
ztopval = pe.MapNode(interface=fsl.ImageMaths(op_string='-ztop',
suffix='_pval'),
name='z2pval',
iterfield=['in_file'])
outputspec = pe.Node(util.IdentityInterface(fields=[
'copes', 'varcopes', 'dof_file', 'pfiles', 'parameter_estimates',
'zstats', 'tstats', 'design_image', 'design_file', 'design_cov',
'sigmasquareds'
]),
name='outputspec')
# Utility function
pop_lambda = lambda x: x[0]
# Setup the connections
modelfit.connect([
(inputspec, level1design,
[('interscan_interval', 'interscan_interval'),
('session_info', 'session_info'), ('contrasts', 'contrasts'),
('bases', 'bases'),
('model_serial_correlations', 'model_serial_correlations')]),
(inputspec, modelestimate, [('film_threshold', 'threshold'),
('functional_data', 'in_file')]),
(level1design, modelgen, [('fsf_files', 'fsf_file'),
('ev_files', 'ev_files')]),
(modelgen, modelestimate, [('design_file', 'design_file')]),
(modelgen, conestimate, [('con_file', 'tcon_file')]),
(modelestimate, conestimate, [('param_estimates', 'param_estimates'),
('sigmasquareds', 'sigmasquareds'),
('corrections', 'corrections'),
('dof_file', 'dof_file')]),
(conestimate, ztopval, [(('zstats', pop_lambda), 'in_file')]),
(ztopval, outputspec, [('out_file', 'pfiles')]),
(modelestimate, outputspec, [('param_estimates',
'parameter_estimates'),
('dof_file', 'dof_file'),
('sigmasquareds', 'sigmasquareds')]),
(conestimate, outputspec, [('copes', 'copes'),
('varcopes', 'varcopes'),
('tstats', 'tstats'), ('zstats', 'zstats')])
])
modelfit.connect(modelgen, 'design_image', outputspec, 'design_image')
modelfit.connect(modelgen, 'design_file', outputspec, 'design_file')
modelfit.connect(modelgen, 'design_cov', outputspec, 'design_cov')
return modelfit
def modelfit_fsl(wf_name='modelfit'):
"""
Fit 1st level GLM using FSL routines
Usage (TODO)
modelfit.inputs.inputspec.fwhm = 12
modelfit.inputs.inputspec.brain_mask = ['/opt/shared2/nipype-test/testblock/example_func_brain_mask.nii.gz', '/opt/shared2/nipype-test/testblock/example_func_brain_mask.nii.gz']
modelfit.inputs.inputspec.input_units = 'secs'
modelfit.inputs.inputspec.in_file = ['/opt/shared2/nipype-test/testblock/mc_data_brain.nii.gz', '/opt/shared2/nipype-test/testblock/mc_data_brain.nii.gz']
modelfit.inputs.inputspec.TR = 2
modelfit.inputs.inputspec.high_pass_filter_cutoff = 100 #sigma in TR
modelfit.inputs.inputspec.event_files = ['/opt/shared2/nipype-test/testblock/a']
cont1 = ['whisker', 'T', ['a', 'a'], [1.0, 0.0]]
cont2 = ['-whisker', 'T', ['a', 'a'], [-1.0, 0.0]]
cont3 = ['Task','F', [cont1, cont2]]
contrasts = [cont1]
modelfit.inputs.inputspec.contrasts = contrasts #TODO: change condition names
modelfit.inputs.inputspec.bases_function = {'dgamma': {'derivs': True}}
modelfit.inputs.inputspec.model_serial_correlations = True
#modelfit.write_graph('graph.dot');
modelfit.write_graph('graph.dot', graph2use='colored');
x=modelfit.run()
#x=modelfit.run(plugin='MultiProc', plugin_args={'n_procs': 8})
server.serve_content(modelfit)
"""
modelfit = pe.Workflow(name=wf_name)
"""
Set up a node to define all inputs required for the preprocessing workflow
"""
inputnode = pe.Node(interface=util.IdentityInterface(
fields=[
'in_file', 'ev_file', 'confounders', 'contrasts',
'high_pass_filter_cutoff', 'fwhm', 'interscan_interval', 'TR',
'input_units', 'bases_function', 'model_serial_correlations',
'brain_mask'
],
mandatory_inputs=True),
name='inputspec')
#TODO: eliminate brain mask
#inputnode.iterables=[('high_pass_filter_cutoff', [30, 60, 90, 120, 500])]
"""
Set up a node to define outputs for the preprocessing workflow
"""
outputnode = pe.Node(interface=util.IdentityInterface(
fields=['zstats', 'zfstats', 'copes', 'varcopes'],
mandatory_inputs=True),
name='outputspec')
# collect subject info
getsubjectinfo = pe.MapNode(util.Function(
input_names=['ev_file', 'confounders'],
output_names=['subject_info'],
function=get_subject_info),
name='getsubjectinfo',
iterfield=['confounders'])
# nipype.algorithms.modelgen.SpecifyModel to generate design information.
modelspec = pe.MapNode(interface=model.SpecifyModel(),
name="modelspec",
iterfield=['subject_info'])
# smooth #TODO: move into preproc pipeline
smooth = preproc.create_susan_smooth("smooth")
#smooth.get_node( "smooth").iterables=[('fwhm', [6., 8., 10., 12., 14., 16.])]
toSigma = pe.Node(interface=util.Function(
input_names=['high_pass_filter_cutoff', 'TR'],
output_names=['high_pass_filter_opstring'],
function=highpass_operand),
name='toSigma')
highpass = pe.MapNode(interface=fsl.ImageMaths(suffix='_tempfilt',
op_string=''),
iterfield=['in_file'],
name='highpass')
# Use nipype.interfaces.fsl.Level1Design to generate a run specific fsf file for analysis
level1design = pe.MapNode(interface=fsl.Level1Design(),
name="level1design",
iterfield='session_info')
# Use nipype.interfaces.fsl.FEATModel to generate a run specific mat file for use by FILMGLS
modelgen = pe.MapNode(interface=fsl.FEATModel(),
name='modelgen',
iterfield=['fsf_file', 'ev_files'])
# Use nipype.interfaces.fsl.FILMGLS to estimate a model specified by a mat file and a functional run
modelestimate = pe.MapNode(
interface=fsl.FILMGLS(smooth_autocorr=True, mask_size=5,
threshold=200),
name='modelestimate',
#iterfield=['design_file', 'in_file'])
iterfield=['in_file', 'design_file'])
# Use nipype.interfaces.fsl.ContrastMgr to generate contrast estimates
conestimate = pe.MapNode(interface=fsl.ContrastMgr(),
name='conestimate',
iterfield=[
'param_estimates', 'sigmasquareds',
'corrections', 'dof_file', 'tcon_file'
])
modelfit.connect([
(
inputnode,
smooth,
[
('in_file', 'inputnode.in_files'),
('fwhm', 'inputnode.fwhm'), # in iterable
('brain_mask', 'inputnode.mask_file')
]),
(smooth, highpass, [('outputnode.smoothed_files', 'in_file')]),
(inputnode, toSigma, [('high_pass_filter_cutoff',
'high_pass_filter_cutoff')]),
(inputnode, toSigma, [('TR', 'TR')]),
(toSigma, highpass, [('high_pass_filter_opstring', 'op_string')]),
(inputnode, getsubjectinfo, [('ev_file', 'ev_file'),
('confounders', 'confounders')]),
(getsubjectinfo, modelspec, [('subject_info', 'subject_info')]),
(highpass, modelspec, [('out_file', 'functional_runs')]),
(highpass, modelestimate, [('out_file', 'in_file')]),
(inputnode, modelspec, [
('input_units', 'input_units'),
('TR', 'time_repetition'),
('high_pass_filter_cutoff', 'high_pass_filter_cutoff'),
]),
(inputnode, level1design, [('TR', 'interscan_interval'),
('model_serial_correlations',
'model_serial_correlations'),
('bases_function', 'bases'),
('contrasts', 'contrasts')]),
(modelspec, level1design, [('session_info', 'session_info')]),
(level1design, modelgen, [('fsf_files', 'fsf_file'),
('ev_files', 'ev_files')]),
(modelgen, modelestimate, [('design_file', 'design_file')]),
(modelgen, conestimate, [('con_file', 'tcon_file')]),
(modelestimate, conestimate, [('param_estimates', 'param_estimates'),
('sigmasquareds', 'sigmasquareds'),
('corrections', 'corrections'),
('dof_file', 'dof_file')]),
(conestimate, outputnode, [('zstats', 'zstats'),
('zfstats', 'zfstats'), ('copes', 'copes'),
('varcopes', 'varcopes')])
])
return modelfit
def create_nuisance_modelfit_workflow(name='modelfit', f_contrasts=False):
"""
Create an FSL modelfitting workflow that returns also
residual4d and sigmasquareds.
Example
-------
# >>> modelfit = create_modelfit_workflow()
# >>> modelfit.base_dir = '.'
# >>> info = dict()
# >>> modelfit.inputs.inputspec.session_info = info
# >>> modelfit.inputs.inputspec.interscan_interval = 3.
# >>> modelfit.inputs.inputspec.film_threshold = 1000
# >>> modelfit.run() #doctest: +SKIP
Inputs::
inputspec.session_info : info generated by modelgen.SpecifyModel
inputspec.interscan_interval : interscan interval
inputspec.contrasts : list of contrasts
inputspec.film_threshold : image threshold for FILM estimation
inputspec.model_serial_correlations
inputspec.bases
Outputs::
outputspec.copes
outputspec.varcopes
outputspec.dof_file
outputspec.pfiles
outputspec.zfiles
outputspec.parameter_estimates
outputspec.residual4d
outputspec.sigmasquareds
"""
version = 0
if fsl.Info.version() and \
LooseVersion(fsl.Info.version()) > LooseVersion('5.0.6'):
version = 507
modelfit = pe.Workflow(name=name)
"""
Create the nodes
"""
inputspec = pe.Node(util.IdentityInterface(fields=[
'session_info', 'interscan_interval', 'contrasts', 'film_threshold',
'functional_data', 'bases', 'model_serial_correlations'
]),
name='inputspec')
level1design = pe.Node(interface=fsl.Level1Design(), name="level1design")
modelgen = pe.MapNode(interface=fsl.FEATModel(),
name='modelgen',
iterfield=['fsf_file', 'ev_files'])
if version < 507:
modelestimate = pe.MapNode(interface=fsl.FILMGLS(smooth_autocorr=True,
mask_size=5),
name='modelestimate',
iterfield=['design_file', 'in_file'])
else:
if f_contrasts:
iterfield = ['design_file', 'in_file', 'tcon_file', 'fcon_file']
else:
iterfield = ['design_file', 'in_file', 'tcon_file']
modelestimate = pe.MapNode(interface=fsl.FILMGLS(smooth_autocorr=True,
mask_size=5),
name='modelestimate',
iterfield=iterfield)
if version < 507:
if f_contrasts:
iterfield = [
'tcon_file', 'fcon_file', 'param_estimates', 'sigmasquareds',
'corrections', 'dof_file'
]
else:
iterfield = [
'tcon_file', 'param_estimates', 'sigmasquareds', 'corrections',
'dof_file'
]
conestimate = pe.MapNode(interface=fsl.ContrastMgr(),
name='conestimate',
iterfield=[
'tcon_file', 'fcon_file',
'param_estimates', 'sigmasquareds',
'corrections', 'dof_file'
])
if f_contrasts:
iterfield = ['in1', 'in2']
else:
iterfield = ['in1']
merge_contrasts = pe.MapNode(interface=util.Merge(2),
name='merge_contrasts',
iterfield=iterfield)
ztopval = pe.MapNode(interface=fsl.ImageMaths(op_string='-ztop',
suffix='_pval'),
nested=True,
name='ztop',
iterfield=['in_file'])
outputspec = pe.Node(util.IdentityInterface(fields=[
'copes', 'varcopes', 'dof_file', 'pfiles', 'zfiles',
'parameter_estimates', 'residual4d', 'sigmasquareds'
]),
name='outputspec')
"""
Setup the connections
"""
modelfit.connect([
(inputspec, level1design,
[('interscan_interval', 'interscan_interval'),
('session_info', 'session_info'), ('contrasts', 'contrasts'),
('bases', 'bases'),
('model_serial_correlations', 'model_serial_correlations')]),
(inputspec, modelestimate, [('film_threshold', 'threshold'),
('functional_data', 'in_file')]),
(level1design, modelgen, [('fsf_files', 'fsf_file'),
('ev_files', 'ev_files')]),
(modelgen, modelestimate, [('design_file', 'design_file')]),
# connect also residual4d and sigmasquared
(modelestimate, outputspec, [('param_estimates',
'parameter_estimates'),
('dof_file', 'dof_file'),
('residual4d', 'residual4d'),
('sigmasquareds', 'sigmasquareds')]),
])
if version < 507:
modelfit.connect([
(modelgen, conestimate, [('con_file', 'tcon_file'),
('fcon_file', 'fcon_file')]),
(modelestimate, conestimate, [('param_estimates',
'param_estimates'),
('sigmasquareds', 'sigmasquareds'),
('corrections', 'corrections'),
('dof_file', 'dof_file')]),
(conestimate, outputspec, [('copes', 'copes'),
('varcopes', 'varcopes')]),
])
else:
modelfit.connect([
(modelgen, modelestimate, [('con_file', 'tcon_file'),
('fcon_file', 'fcon_file')]),
(modelestimate, outputspec, [('copes', 'copes'),
('varcopes', 'varcopes')]),
])
return modelfit
def create_modelfit_workflow(name='modelfit'):
"""Create an FSL individual modelfitting workflow
Example
-------
>>> modelfit = create_modelfit_workflow()
>>> modelfit.base_dir = '.'
>>> info = dict()
>>> modelfit.inputs.inputspec.session_info = info
>>> modelfit.inputs.inputspec.interscan_interval = 3.
>>> modelfit.inputs.inputspec.film_threshold = 1000
>>> modelfit.run() #doctest: +SKIP
Inputs::
inputspec.session_info : info generated by modelgen.SpecifyModel
inputspec.interscan_interval : interscan interval
inputspec.contrasts : list of contrasts
inputspec.film_threshold : image threshold for FILM estimation
Outputs::
outputspec.realignment_parameters : realignment parameter files
outputspec.smoothed_files : smoothed functional files
outputspec.outlier_files : list of outliers
outputspec.outlier_stats : statistics of outliers
outputspec.outlier_plots : images of outliers
outputspec.mask_file : binary mask file in reference image space
outputspec.reg_file : registration file that maps reference image to
freesurfer space
outputspec.reg_cost : cost of registration (useful for detecting
misalignment)
"""
modelfit = pe.Workflow(name=name)
"""
Create the nodes
"""
inputspec = pe.Node(util.IdentityInterface(fields=['session_info',
'interscan_interval',
'contrasts',
'film_threshold',
'functional_data',
'bases',
'model_serial_correlations']),
name='inputspec')
level1design = pe.Node(interface=fsl.Level1Design(), name="level1design")
modelgen = pe.MapNode(interface=fsl.FEATModel(), name='modelgen',
iterfield=['fsf_file', 'ev_files'])
modelestimate = pe.MapNode(interface=fsl.FILMGLS(smooth_autocorr=True,
mask_size=5),
name='modelestimate',
iterfield=['design_file', 'in_file'])
conestimate = pe.MapNode(interface=fsl.ContrastMgr(), name='conestimate',
iterfield=['tcon_file', 'param_estimates',
'sigmasquareds', 'corrections',
'dof_file'])
ztopval = pe.MapNode(interface=fsl.ImageMaths(op_string='-ztop',
suffix='_pval'),
name='ztop',
iterfield=['in_file'])
outputspec = pe.Node(util.IdentityInterface(fields=['copes', 'varcopes',
'dof_file', 'pfiles',
'parameter_estimates']),
name='outputspec')
"""
Utility function
"""
pop_lambda = lambda x: x[0]
"""
Setup the connections
"""
modelfit.connect([
(inputspec, level1design, [('interscan_interval', 'interscan_interval'),
('session_info', 'session_info'),
('contrasts', 'contrasts'),
('bases', 'bases'),
('model_serial_correlations',
'model_serial_correlations')]),
(inputspec, modelestimate, [('film_threshold', 'threshold'),
('functional_data', 'in_file')]),
(level1design, modelgen, [('fsf_files', 'fsf_file'),
('ev_files', 'ev_files')]),
(modelgen, modelestimate, [('design_file', 'design_file')]),
(modelgen, conestimate, [('con_file', 'tcon_file')]),
(modelestimate, conestimate, [('param_estimates', 'param_estimates'),
('sigmasquareds', 'sigmasquareds'),
('corrections', 'corrections'),
('dof_file', 'dof_file')]),
(conestimate, ztopval, [(('zstats', pop_lambda), 'in_file')]),
(ztopval, outputspec, [('out_file', 'pfiles')]),
(modelestimate, outputspec, [('param_estimates', 'parameter_estimates'),
('dof_file', 'dof_file')]),
(conestimate, outputspec, [('copes', 'copes'),
('varcopes', 'varcopes')]),
])
return modelfit