def mod_despike(in_file, do_despike):
out_file=in_file
if do_despike:
from nipype.interfaces.afni import Despike
ds = Despike(in_file=in_file)
out_file = ds.run().outputs.out_file
return out_file
def mod_despike(in_file, do_despike):
out_file = in_file
if do_despike:
from nipype.interfaces.afni import Despike
ds = Despike(in_file=in_file)
out_file = ds.run().outputs.out_file
return out_file
def mod_despike(in_file, do_despike):
out_file=in_file
if do_despike:
from nipype.interfaces.afni import Despike
from nipype.utils.filemanip import fname_presuffix
ds = Despike(in_file=in_file,out_file=fname_presuffix(in_file,'','_despike'))
out_file = ds.run().outputs.out_file
return out_file
def mod_despike(in_file, do_despike):
out_file = in_file
if do_despike:
from nipype.interfaces.afni import Despike
from nipype.utils.filemanip import fname_presuffix
ds = Despike(in_file=in_file,
out_file=fname_presuffix(in_file, '', '_despike'))
out_file = ds.run().outputs.out_file
return out_file
def hmc(name='fMRI_HMC'):
"""
Create a :abbr:`HMC (head motion correction)` workflow for fMRI.
.. workflow::
from mriqc.workflows.functional import hmc
from mriqc.testing import mock_config
with mock_config():
wf = hmc()
"""
from nipype.algorithms.confounds import FramewiseDisplacement
from nipype.interfaces.afni import Calc, TShift, Refit, Despike, Volreg
from niworkflows.interfaces.registration import EstimateReferenceImage
mem_gb = config.workflow.biggest_file_gb
workflow = pe.Workflow(name=name)
inputnode = pe.Node(niu.IdentityInterface(
fields=['in_file', 'fd_radius', 'start_idx', 'stop_idx']),
name='inputnode')
outputnode = pe.Node(niu.IdentityInterface(fields=['out_file', 'out_fd']),
name='outputnode')
if any((config.workflow.start_idx is not None, config.workflow.stop_idx
is not None)):
drop_trs = pe.Node(Calc(expr='a', outputtype='NIFTI_GZ'),
name='drop_trs')
workflow.connect([
(inputnode, drop_trs, [('in_file', 'in_file_a'),
('start_idx', 'start_idx'),
('stop_idx', 'stop_idx')]),
])
else:
drop_trs = pe.Node(niu.IdentityInterface(fields=['out_file']),
name='drop_trs')
workflow.connect([
(inputnode, drop_trs, [('in_file', 'out_file')]),
])
gen_ref = pe.Node(EstimateReferenceImage(mc_method="AFNI"), name="gen_ref")
# calculate hmc parameters
hmc = pe.Node(Volreg(args='-Fourier -twopass',
zpad=4,
outputtype='NIFTI_GZ'),
name='motion_correct',
mem_gb=mem_gb * 2.5)
# Compute the frame-wise displacement
fdnode = pe.Node(FramewiseDisplacement(normalize=False,
parameter_source="AFNI"),
name='ComputeFD')
workflow.connect([
(inputnode, fdnode, [('fd_radius', 'radius')]),
(gen_ref, hmc, [('ref_image', 'basefile')]),
(hmc, outputnode, [('out_file', 'out_file')]),
(hmc, fdnode, [('oned_file', 'in_file')]),
(fdnode, outputnode, [('out_file', 'out_fd')]),
])
# Slice timing correction, despiking, and deoblique
st_corr = pe.Node(TShift(outputtype='NIFTI_GZ'), name='TimeShifts')
deoblique_node = pe.Node(Refit(deoblique=True), name='deoblique')
despike_node = pe.Node(Despike(outputtype='NIFTI_GZ'), name='despike')
if all((config.workflow.correct_slice_timing, config.workflow.despike,
config.workflow.deoblique)):
workflow.connect([
(drop_trs, st_corr, [('out_file', 'in_file')]),
(st_corr, despike_node, [('out_file', 'in_file')]),
(despike_node, deoblique_node, [('out_file', 'in_file')]),
(deoblique_node, gen_ref, [('out_file', 'in_file')]),
(deoblique_node, hmc, [('out_file', 'in_file')]),
])
elif config.workflow.correct_slice_timing and config.workflow.despike:
workflow.connect([
(drop_trs, st_corr, [('out_file', 'in_file')]),
(st_corr, despike_node, [('out_file', 'in_file')]),
(despike_node, gen_ref, [('out_file', 'in_file')]),
(despike_node, hmc, [('out_file', 'in_file')]),
])
elif config.workflow.correct_slice_timing and config.workflow.deoblique:
workflow.connect([
(drop_trs, st_corr, [('out_file', 'in_file')]),
(st_corr, deoblique_node, [('out_file', 'in_file')]),
(deoblique_node, gen_ref, [('out_file', 'in_file')]),
(deoblique_node, hmc, [('out_file', 'in_file')]),
])
elif config.workflow.correct_slice_timing:
workflow.connect([
(drop_trs, st_corr, [('out_file', 'in_file')]),
(st_corr, gen_ref, [('out_file', 'in_file')]),
(st_corr, hmc, [('out_file', 'in_file')]),
])
elif config.workflow.despike and config.workflow.deoblique:
workflow.connect([
(drop_trs, despike_node, [('out_file', 'in_file')]),
(despike_node, deoblique_node, [('out_file', 'in_file')]),
(deoblique_node, gen_ref, [('out_file', 'in_file')]),
(deoblique_node, hmc, [('out_file', 'in_file')]),
])
elif config.workflow.despike:
workflow.connect([
(drop_trs, despike_node, [('out_file', 'in_file')]),
(despike_node, gen_ref, [('out_file', 'in_file')]),
(despike_node, hmc, [('out_file', 'in_file')]),
])
elif config.workflow.deoblique:
workflow.connect([
(drop_trs, deoblique_node, [('out_file', 'in_file')]),
(deoblique_node, gen_ref, [('out_file', 'in_file')]),
(deoblique_node, hmc, [('out_file', 'in_file')]),
])
else:
workflow.connect([
(drop_trs, gen_ref, [('out_file', 'in_file')]),
(drop_trs, hmc, [('out_file', 'in_file')]),
])
return workflow
def preproc_workflow(input_dir,
output_dir,
subject_list,
ses_list,
anat_file,
func_file,
scan_size=477,
bet_frac=0.37):
"""
The preprocessing workflow used in the preparation of the psilocybin vs escitalopram rsFMRI scans.
Workflows and notes are defined throughout. Inputs are designed to be general and masks/default MNI space is provided
:param input_dir: The input file directory containing all scans in BIDS format
:param output_dir: The output file directory
:param subject_list: a list of subject numbers
:param ses_list: a list of scan numbers (session numbers)
:param anat_file: The format of the anatomical scan within the input directory
:param func_file: The format of the functional scan within the input directory
:param scan_size: The length of the scan by number of images, most 10 minutes scans are around 400-500 depending
upon scanner defaults and parameters - confirm by looking at your data
:param bet_frac: brain extraction fractional intensity threshold
:return: the preprocessing workflow
"""
preproc = Workflow(name='preproc')
preproc.base_dir = output_dir
# Infosource - a function free node to iterate over the list of subject names
infosource = Node(IdentityInterface(fields=['subject_id', 'ses']),
name="infosource")
infosource.iterables = [('subject_id', subject_list), ('ses', ses_list)]
# SelectFiles - to grab the data (alternative to DataGrabber)
templates = {
'anat': anat_file,
'func': func_file
} # define the template of each file input
selectfiles = Node(SelectFiles(templates, base_directory=input_dir),
name="selectfiles")
# Datasink - creates output folder for important outputs
datasink = Node(DataSink(base_directory=output_dir, container=output_dir),
name="datasink")
preproc.connect([(infosource, selectfiles, [('subject_id', 'subject_id'),
('ses', 'ses')])])
'''
This is your functional processing workflow, used to trim scans, despike the signal, slice-time correct,
and motion correct your data
'''
fproc = Workflow(name='fproc') # the functional processing workflow
# ExtractROI - skip dummy scans at the beginning of the recording by removing the first three
trim = Node(ExtractROI(t_min=3, t_size=scan_size, output_type='NIFTI_GZ'),
name="trim")
# 3dDespike - despike
despike = Node(Despike(outputtype='NIFTI_GZ', args='-NEW'), name="despike")
fproc.connect([(trim, despike, [('roi_file', 'in_file')])])
preproc.connect([(selectfiles, fproc, [('func', 'trim.in_file')])])
# 3dTshift - slice time correction
slicetime = Node(TShift(outputtype='NIFTI_GZ', tpattern='alt+z2'),
name="slicetime")
fproc.connect([(despike, slicetime, [('out_file', 'in_file')])])
# 3dVolreg - correct motion and output 1d matrix
moco = Node(Volreg(outputtype='NIFTI_GZ',
interp='Fourier',
zpad=4,
args='-twopass'),
name="moco")
fproc.connect([(slicetime, moco, [('out_file', 'in_file')])])
moco_bpfdt = Node(
MOCObpfdt(), name='moco_bpfdt'
) # use the matlab function to correct the motion regressor
fproc.connect([(moco, moco_bpfdt, [('oned_file', 'in_file')])])
'''
This is the co-registration workflow using FSL and ANTs
'''
coreg = Workflow(name='coreg')
# BET - structural data brain extraction
bet_anat = Node(BET(output_type='NIFTI_GZ', frac=bet_frac, robust=True),
name="bet_anat")
# FSL segmentation process to get WM map
seg = Node(FAST(bias_iters=6,
img_type=1,
output_biascorrected=True,
output_type='NIFTI_GZ'),
name="seg")
coreg.connect([(bet_anat, seg, [('out_file', 'in_files')])])
# functional to structural registration
mean = Node(MCFLIRT(mean_vol=True, output_type='NIFTI_GZ'), name="mean")
# BBR using linear methods for initial transform fit
func2struc = Node(FLIRT(cost='bbr', dof=6, output_type='NIFTI_GZ'),
name='func2struc')
coreg.connect([(seg, func2struc, [('restored_image', 'reference')])])
coreg.connect([(mean, func2struc, [('mean_img', 'in_file')])])
coreg.connect([(seg, func2struc, [(('tissue_class_files', pickindex, 2),
'wm_seg')])])
# convert the FSL linear transform into a C3d format for AFNI
f2s_c3d = Node(C3dAffineTool(itk_transform=True, fsl2ras=True),
name='f2s_c3d')
coreg.connect([(func2struc, f2s_c3d, [('out_matrix_file', 'transform_file')
])])
coreg.connect([(mean, f2s_c3d, [('mean_img', 'source_file')])])
coreg.connect([(seg, f2s_c3d, [('restored_image', 'reference_file')])])
# Functional to structural registration via ANTs non-linear registration
reg = Node(Registration(
fixed_image='default_images/MNI152_T1_2mm_brain.nii.gz',
transforms=['Affine', 'SyN'],
transform_parameters=[(0.1, ), (0.1, 3.0, 0.0)],
number_of_iterations=[[1500, 1000, 1000], [100, 70, 50, 20]],
dimension=3,
write_composite_transform=True,
collapse_output_transforms=True,
metric=['MI'] + ['CC'],
metric_weight=[1] * 2,
radius_or_number_of_bins=[32] + [4],
convergence_threshold=[1.e-8, 1.e-9],
convergence_window_size=[20] + [10],
smoothing_sigmas=[[2, 1, 0], [4, 2, 1, 0]],
sigma_units=['vox'] * 2,
shrink_factors=[[4, 2, 1], [6, 4, 2, 1]],
use_histogram_matching=[False] + [True],
use_estimate_learning_rate_once=[True, True],
output_warped_image=True),
name='reg')
coreg.connect([(seg, reg, [('restored_image', 'moving_image')])
]) # connect segmentation node to registration node
merge1 = Node(niu.Merge(2), iterfield=['in2'],
name='merge1') # merge the linear and nonlinear transforms
coreg.connect([(f2s_c3d, merge1, [('itk_transform', 'in2')])])
coreg.connect([(reg, merge1, [('composite_transform', 'in1')])])
# warp the functional images into MNI space using the transforms from FLIRT and SYN
warp = Node(ApplyTransforms(
reference_image='default_images/MNI152_T1_2mm_brain.nii.gz',
input_image_type=3),
name='warp')
coreg.connect([(moco, warp, [('out_file', 'input_image')])])
coreg.connect([(merge1, warp, [('out', 'transforms')])])
preproc.connect([(selectfiles, coreg, [('anat', 'bet_anat.in_file')])])
preproc.connect([(fproc, coreg, [('moco.out_file', 'mean.in_file')])])
'''
Scrubbing workflow - find the motion outliers, bandpass filter, re-mean the data after bpf
'''
scrub = Workflow(name='scrub')
# Generate the Scrubbing Regressor
scrub_metrics = Node(MotionOutliers(dummy=4,
out_file='FD_outliers.1D',
metric='fd',
threshold=0.4),
name="scrub_metrics")
# regress out timepoints
scrub_frames = Node(Bandpass(highpass=0,
lowpass=99999,
outputtype='NIFTI_GZ'),
name='scrub_frames')
scrub.connect([(scrub_metrics, scrub_frames, [('out_file',
'orthogonalize_file')])])
preproc.connect([(coreg, scrub, [('warp.output_image',
'scrub_frames.in_file')])])
preproc.connect([(selectfiles, scrub, [('func', 'scrub_metrics.in_file')])
])
# mean image for remeaning after bandpass
premean = Node(TStat(args='-mean', outputtype='NIFTI_GZ'), name='premean')
# remean the image
remean2 = Node(Calc(expr='a+b', outputtype='NIFTI_GZ'), name='remean2')
scrub.connect([(scrub_frames, remean2, [('out_file', 'in_file_a')])])
scrub.connect([(premean, remean2, [('out_file', 'in_file_b')])])
preproc.connect([(coreg, scrub, [('warp.output_image', 'premean.in_file')])
])
'''
Regressors for final cleaning steps
'''
regressors = Workflow(name='regressors')
# Using registered structural image to create the masks for both WM and CSF
regbet = Node(BET(robust=True, frac=0.37, output_type='NIFTI_GZ'),
name='regbet')
regseg = Node(FAST(img_type=1,
output_type='NIFTI_GZ',
no_pve=True,
no_bias=True,
segments=True),
name='regseg')
regressors.connect([(regbet, regseg, [('out_file', 'in_files')])])
preproc.connect([(coreg, regressors, [('reg.warped_image',
'regbet.in_file')])])
'''
Create a cerebrospinal fluid (CSF) regressor
'''
# subtract subcortical GM from the CSF mask
subcortgm = Node(BinaryMaths(
operation='sub',
operand_file='default_images/subcortical_gm_mask_bin.nii.gz',
output_type='NIFTI_GZ',
args='-bin'),
name='subcortgm')
regressors.connect([(regseg, subcortgm, [(('tissue_class_files', pickindex,
0), 'in_file')])])
# Fill the mask holes
fillcsf = Node(MaskTool(fill_holes=True, outputtype='NIFTI_GZ'),
name='fillcsf')
regressors.connect([(subcortgm, fillcsf, [('out_file', 'in_file')])])
# Erode the mask
erocsf = Node(MaskTool(outputtype='NIFTI_GZ', dilate_inputs='-1'),
name='erocsf')
regressors.connect([(fillcsf, erocsf, [('out_file', 'in_file')])])
# Take mean csf signal from functional image
meancsf = Node(ImageMeants(output_type='NIFTI_GZ'), name='meancsf')
regressors.connect([(erocsf, meancsf, [('out_file', 'mask')])])
preproc.connect([(coreg, regressors, [('warp.output_image',
'meancsf.in_file')])])
bpf_dt_csf = Node(CSFbpfdt(), name='bpf_dt_csf')
regressors.connect([(meancsf, bpf_dt_csf, [('out_file', 'in_file')])])
'''
Creates a local white matter regressor
'''
# subtract subcortical gm
subcortgm2 = Node(BinaryMaths(
operation='sub',
operand_file='default_images/subcortical_gm_mask_bin.nii.gz',
output_type='NIFTI_GZ',
args='-bin'),
name='subcortgm2')
regressors.connect([(regseg, subcortgm2, [(('tissue_class_files',
pickindex, 2), 'in_file')])])
# fill mask
fillwm = Node(MaskTool(fill_holes=True, outputtype='NIFTI_GZ'),
name='fillwm')
regressors.connect([(subcortgm2, fillwm, [('out_file', 'in_file')])])
# erod mask
erowm = Node(MaskTool(outputtype='NIFTI_GZ', dilate_inputs='-1'),
name='erowm')
regressors.connect([(fillwm, erowm, [('out_file', 'in_file')])])
# generate local wm
localwm = Node(Localstat(neighborhood=('SPHERE', 25),
stat='mean',
nonmask=True,
outputtype='NIFTI_GZ'),
name='localwm')
regressors.connect([(erowm, localwm, [('out_file', 'mask_file')])])
preproc.connect([(coreg, regressors, [('warp.output_image',
'localwm.in_file')])])
# bandpass filter the local wm regressor
localwm_bpf = Node(Fourier(highpass=0.01,
lowpass=0.08,
args='-retrend',
outputtype='NIFTI_GZ'),
name='loacwm_bpf')
regressors.connect([(localwm, localwm_bpf, [('out_file', 'in_file')])])
# detrend the local wm regressor
localwm_bpf_dt = Node(Detrend(args='-polort 2', outputtype='NIFTI_GZ'),
name='localwm_bpf_dt')
regressors.connect([(localwm_bpf, localwm_bpf_dt, [('out_file', 'in_file')
])])
'''
Clean up your functional image with the regressors you have created above
'''
# create a mask for blurring filtering, and detrending
clean = Workflow(name='clean')
mask = Node(BET(mask=True, functional=True), name='mask')
mean_mask = Node(MCFLIRT(mean_vol=True, output_type='NIFTI_GZ'),
name="mean_mask")
dilf = Node(DilateImage(operation='max', output_type='NIFTI_GZ'),
name='dilf')
clean.connect([(mask, dilf, [('mask_file', 'in_file')])])
preproc.connect([(scrub, clean, [('remean2.out_file', 'mask.in_file')])])
fill = Node(MaskTool(in_file='default_images/MNI152_T1_2mm_brain.nii.gz',
fill_holes=True,
outputtype='NIFTI_GZ'),
name='fill')
axb = Node(Calc(expr='a*b', outputtype='NIFTI_GZ'), name='axb')
clean.connect([(dilf, axb, [('out_file', 'in_file_a')])])
clean.connect([(fill, axb, [('out_file', 'in_file_b')])])
bxc = Node(Calc(expr='ispositive(a)*b', outputtype='NIFTI_GZ'), name='bxc')
clean.connect([(mean_mask, bxc, [('mean_img', 'in_file_a')])])
clean.connect([(axb, bxc, [('out_file', 'in_file_b')])])
preproc.connect([(scrub, clean, [('remean2.out_file', 'mean_mask.in_file')
])])
#### BLUR, FOURIER BPF, and DETREND
blurinmask = Node(BlurInMask(fwhm=6, outputtype='NIFTI_GZ'),
name='blurinmask')
clean.connect([(bxc, blurinmask, [('out_file', 'mask')])])
preproc.connect([(scrub, clean, [('remean2.out_file', 'blurinmask.in_file')
])])
fourier = Node(Fourier(highpass=0.01,
lowpass=0.08,
retrend=True,
outputtype='NIFTI_GZ'),
name='fourier')
clean.connect([(blurinmask, fourier, [('out_file', 'in_file')])])
tstat = Node(TStat(args='-mean', outputtype='NIFTI_GZ'), name='tstat')
clean.connect([(fourier, tstat, [('out_file', 'in_file')])])
detrend = Node(Detrend(args='-polort 2', outputtype='NIFTI_GZ'),
name='detrend')
clean.connect([(fourier, detrend, [('out_file', 'in_file')])])
remean = Node(Calc(expr='a+b', outputtype='NIFTI_GZ'), name='remean')
clean.connect([(detrend, remean, [('out_file', 'in_file_a')])])
clean.connect([(tstat, remean, [('out_file', 'in_file_b')])])
concat = Node(ConcatModel(), name='concat')
# Removes nuisance regressors via regression function
clean_rs = Node(Bandpass(highpass=0, lowpass=99999, outputtype='NIFTI_GZ'),
name='clean_rs')
clean.connect([(concat, clean_rs, [('out_file', 'orthogonalize_file')])])
remean1 = Node(Calc(expr='a+b', outputtype='NIFTI_GZ'), name='remean1')
clean.connect([(clean_rs, remean1, [('out_file', 'in_file_a')])])
clean.connect([(tstat, remean1, [('out_file', 'in_file_b')])])
preproc.connect([(regressors, clean, [('bpf_dt_csf.out_file',
'concat.in_file_a')])])
preproc.connect([(fproc, clean, [('moco_bpfdt.out_file',
'concat.in_file_b')])])
preproc.connect([(regressors, clean, [('localwm_bpf_dt.out_file',
'clean_rs.orthogonalize_dset')])])
clean.connect([(remean, clean_rs, [('out_file', 'in_file')])])
'''
Write graphical output detailing the workflows and nodes
'''
fproc.write_graph(graph2use='flat',
format='png',
simple_form=True,
dotfilename='./fproc.dot')
fproc.write_graph(graph2use='colored',
format='png',
simple_form=True,
dotfilename='./fproc_color.dot')
coreg.write_graph(graph2use='flat',
format='png',
simple_form=True,
dotfilename='./coreg.dot')
coreg.write_graph(graph2use='colored',
format='png',
simple_form=True,
dotfilename='./coreg_color.dot')
scrub.write_graph(graph2use='flat',
format='png',
simple_form=True,
dotfilename='./scrub.dot')
scrub.write_graph(graph2use='colored',
format='png',
simple_form=True,
dotfilename='./scrub_color.dot')
regressors.write_graph(graph2use='flat',
format='png',
simple_form=True,
dotfilename='./reg.dot')
regressors.write_graph(graph2use='colored',
format='png',
simple_form=True,
dotfilename='./reg_color.dot')
preproc.write_graph(graph2use='flat',
format='png',
simple_form=True,
dotfilename='./preproc.dot')
preproc.write_graph(graph2use='colored',
format='png',
simple_form=True,
dotfilename='./preproc_color.dot')
return preproc
def hmc(name="fMRI_HMC"):
"""
Create a :abbr:`HMC (head motion correction)` workflow for fMRI.
.. workflow::
from mriqc.workflows.functional import hmc
from mriqc.testing import mock_config
with mock_config():
wf = hmc()
"""
from nipype.algorithms.confounds import FramewiseDisplacement
from nipype.interfaces.afni import Calc, Despike, Refit, TShift, Volreg
mem_gb = config.workflow.biggest_file_gb
workflow = pe.Workflow(name=name)
inputnode = pe.Node(
niu.IdentityInterface(
fields=["in_file", "fd_radius", "start_idx", "stop_idx"]),
name="inputnode",
)
outputnode = pe.Node(niu.IdentityInterface(fields=["out_file", "out_fd"]),
name="outputnode")
if any((
config.workflow.start_idx is not None,
config.workflow.stop_idx is not None,
)):
drop_trs = pe.Node(Calc(expr="a", outputtype="NIFTI_GZ"),
name="drop_trs")
# fmt: off
workflow.connect([
(inputnode, drop_trs, [("in_file", "in_file_a"),
("start_idx", "start_idx"),
("stop_idx", "stop_idx")]),
])
# fmt: on
else:
drop_trs = pe.Node(niu.IdentityInterface(fields=["out_file"]),
name="drop_trs")
# fmt: off
workflow.connect([
(inputnode, drop_trs, [("in_file", "out_file")]),
])
# fmt: on
# calculate hmc parameters
hmc = pe.Node(
Volreg(args="-Fourier -twopass", zpad=4, outputtype="NIFTI_GZ"),
name="motion_correct",
mem_gb=mem_gb * 2.5,
)
# Compute the frame-wise displacement
fdnode = pe.Node(
FramewiseDisplacement(normalize=False, parameter_source="AFNI"),
name="ComputeFD",
)
# fmt: off
workflow.connect([
(inputnode, fdnode, [("fd_radius", "radius")]),
(hmc, outputnode, [("out_file", "out_file")]),
(hmc, fdnode, [("oned_file", "in_file")]),
(fdnode, outputnode, [("out_file", "out_fd")]),
])
# fmt: on
# Slice timing correction, despiking, and deoblique
st_corr = pe.Node(TShift(outputtype="NIFTI_GZ"), name="TimeShifts")
deoblique_node = pe.Node(Refit(deoblique=True), name="deoblique")
despike_node = pe.Node(Despike(outputtype="NIFTI_GZ"), name="despike")
if all((
config.workflow.correct_slice_timing,
config.workflow.despike,
config.workflow.deoblique,
)):
# fmt: off
workflow.connect([
(drop_trs, st_corr, [("out_file", "in_file")]),
(st_corr, despike_node, [("out_file", "in_file")]),
(despike_node, deoblique_node, [("out_file", "in_file")]),
(deoblique_node, hmc, [("out_file", "in_file")]),
])
# fmt: on
elif config.workflow.correct_slice_timing and config.workflow.despike:
# fmt: off
workflow.connect([
(drop_trs, st_corr, [("out_file", "in_file")]),
(st_corr, despike_node, [("out_file", "in_file")]),
(despike_node, hmc, [("out_file", "in_file")]),
])
# fmt: on
elif config.workflow.correct_slice_timing and config.workflow.deoblique:
# fmt: off
workflow.connect([
(drop_trs, st_corr, [("out_file", "in_file")]),
(st_corr, deoblique_node, [("out_file", "in_file")]),
(deoblique_node, hmc, [("out_file", "in_file")]),
])
# fmt: on
elif config.workflow.correct_slice_timing:
# fmt: off
workflow.connect([
(drop_trs, st_corr, [("out_file", "in_file")]),
(st_corr, hmc, [("out_file", "in_file")]),
])
# fmt: on
elif config.workflow.despike and config.workflow.deoblique:
# fmt: off
workflow.connect([
(drop_trs, despike_node, [("out_file", "in_file")]),
(despike_node, deoblique_node, [("out_file", "in_file")]),
(deoblique_node, hmc, [("out_file", "in_file")]),
])
# fmt: on
elif config.workflow.despike:
# fmt: off
workflow.connect([
(drop_trs, despike_node, [("out_file", "in_file")]),
(despike_node, hmc, [("out_file", "in_file")]),
])
# fmt: on
elif config.workflow.deoblique:
# fmt: off
workflow.connect([
(drop_trs, deoblique_node, [("out_file", "in_file")]),
(deoblique_node, hmc, [("out_file", "in_file")]),
])
# fmt: on
else:
# fmt: off
workflow.connect([
(drop_trs, hmc, [("out_file", "in_file")]),
])
# fmt: on
return workflow
##Define Experiment Parameters
experiment_dir = '/Users/srk482-admin/Documents/forcemem_mriDat/nipype_tutorial' # location of experiment folder
data_dir = '/Users/srk482-admin/Documents/forcemem_mriDat/'
subject_list = ['2017062801', '2017070601', '2017062701', '2017062101']
block_list = ['block1', 'block2', 'block3', 'block4', 'block5']
# list of subject identifiers
output_dir = 'output_fMRI_example_1st' # name of 1st-level output folder
working_dir = 'workingdir_fMRI_example_1st' # name of 1st-level working directory
number_of_slices = 48 # number of slices in volume
TR = 2.0 # time repetition of volume
fwhm_size = 6 # size of FWHM in mm
# Despike - Removes 'spikes' from the 3D+time input dataset
despike = MapNode(Despike(outputtype='NIFTI'),
name="despike",
iterfield=['in_file'])
# Slicetiming - correct for slice wise acquisition
interleaved_order = range(1, number_of_slices + 1, 2) + range(
2, number_of_slices + 1, 2)
sliceTiming = Node(SliceTiming(num_slices=number_of_slices,
time_repetition=TR,
time_acquisition=TR - TR / number_of_slices,
slice_order=interleaved_order,
ref_slice=2),
name="sliceTiming")
# Realign - correct for motion
realign = Node(Realign(register_to_mean=True), name="realign")
def create_lvl1pipe_wf(options):
'''
Input [Mandatory]:
~~~~~~~~~~~ Set in command call:
options: dictionary with the following entries
remove_steadystateoutlier [boolean]:
Should always be True. Remove steady state outliers from bold timecourse, specified in fmriprep confounds file.
smooth [boolean]:
If True, then /smooth subfolder created and populated with results. If False, then /nosmooth subfolder created and populated with results.
censoring [string]:
Either '' or 'despike', which implements nipype.interfaces.afni.Despike
ICA_AROMA [boolean]:
Use AROMA error components, from fmriprep confounds file.
run_contrasts [boolean]:
If False, then components related to contrasts and p values are removed from nipype.workflows.fmri.fsl.estimate.create_modelfit_workflow()
keep_resid [boolean]:
If False, then only sum of squares residuals will be outputted. If True, then timecourse residuals kept.
poly_trend [integer. Use None to skip]:
If given, polynomial trends will be added to run confounds, up to the order of the integer
e.g. "0", gives an intercept, "1" gives intercept + linear trend,
"2" gives intercept + linear trend + quadratic.
DO NOT use in conjnuction with high pass filters.
dct_basis [integer. Use None to skip]:
If given, adds a discrete cosine transform, with a length (in seconds) of the interger specified.
Adds unit scaled cosine basis functions to Design_Matrix columns,
based on spm-style discrete cosine transform for use in
high-pass filtering. Does not add intercept/constant.
DO NOT use in conjnuction with high pass filters.
~~~~~~~~~~~ Set through inputs.inputspec
input_dir [string]:
path to folder containing fmriprep preprocessed data.
e.g. model_wf.inputs.inputspec.input_dir = '/home/neuro/data'
output_dir [string]:
path to desired output folder. Workflow will create a new subfolder based on proj_name.
e.g. model_wf.inputs.inputspec.output_dir = '/home/neuro/output'
proj_name [string]:
name for project subfolder within output_dir. Ideally something unique, or else workflow will write to an existing folder.
e.g. model_wf.inputs.inputspec.proj_name = 'FSMAP_stress'
design_col [string]:
Name of column within events.tsv with values corresponding to entries specified in params.
e.g. model_wf.inputs.inputspec.design_col = 'trial_type'
params [list fo strings]:
values within events.tsv design_col that correspond to events to be modeled.
e.g. ['Instructions', 'Speech_prep', 'No_speech']
conditions [list, of either strings or lists],
each condition must be a string within the events.tsv design_col.
These conditions correspond to event conditions to be modeled.
Give a list, instead of a string, to model parametric terms.
These parametric terms give a event condition, then a parametric term, which is another column in the events.tsv file.
The parametric term can be centered and normed using entries 3 and 4 in the list.
e.g. model_wf.inputs.inputspec.params = ['condition1',
'condition2',
['condition1', 'parametric1', 'no_cent', 'no_norm'],
['condition2', 'paramatric2', 'cent', 'norm']]
entry 1 is a condition within the design_col column
entry 2 is a column in the events folder, which will be used for parametric weightings.
entry 3 is either 'no_cent', or 'cent', indicating whether to center the parametric variable.
entry 4 is either 'no_norm', or 'norm', indicating whether to normalize the parametric variable.
Onsets and durations will be taken from corresponding values for entry 1
parametric weighting specified by entry 2, scaled/centered as specified, then
appended to the design matrix.
contrasts [list of lists]:
Specifies contrasts to be performed. using params selected above.
e.g. model_wf.inputs.inputspec.contrasts =
[['Instructions', 'T', ['Instructions'], [1]],
['Speech_prep', 'T', ['Speech_prep'], [1]],
['No_speech', 'T', ['No_speech'], [1]],
['Speech_prep>No_speech', 'T', ['Speech_prep', 'No_speech'], [1, -1]]]
noise_regressors [list of strings]:
column names in confounds.tsv, specifying desired noise regressors for model.
IF noise_transforms are to be applied to a regressor, add '*' to the name.
e.g. model_wf.inputs.inputspec.noise_regressors = ['CSF', 'WhiteMatter', 'GlobalSignal', 'X*', 'Y*', 'Z*', 'RotX*', 'RotY*', 'RotZ*']
noise_transforms [list of strings]:
noise transforms to be applied to select noise_regressors above. Possible values are 'quad', 'tderiv', and 'quadtderiv', standing for quadratic function of value, temporal derivative of value, and quadratic function of temporal derivative.
e.g. model_wf.inputs.inputspec.noise_transforms = ['quad', 'tderiv', 'quadtderiv']
TR [float]:
Scanner TR value in seconds.
e.g. model_wf.inputs.inputspec.TR = 2.
FILM_threshold [integer]:
Cutoff value for modeling threshold. 1000: p <.001; 1: p <=1, i.e. unthresholded.
e.g. model_wf.inputs.inputspec.FILM_threshold = 1
hpf_cutoff [float]:
high pass filter value. DO NOT USE THIS in conjunction with poly_trend or dct_basis.
e.g. model_wf.inputs.inputspec.hpf_cutoff = 120.
bases: (a dictionary with keys which are 'hrf' or 'fourier' or 'fourier_han' or 'gamma' or 'fir' and with values which are any value)
dict {'name':{'basesparam1':val,...}}
name : string
Name of basis function (hrf, fourier, fourier_han, gamma, fir)
hrf :
derivs : 2-element list
Model HRF Derivatives. No derivatives: [0,0],
Time derivatives : [1,0],
Time and Dispersion derivatives: [1,1]
fourier, fourier_han, gamma, fir:
length : int
Post-stimulus window length (in seconds)
order : int
Number of basis functions
e.g. model_wf.inputs.inputspec.bases = {'dgamma':{'derivs': False}}
model_serial_correlations [boolean]:
Allow prewhitening, with 5mm spatial smoothing.
model_wf.inputs.inputspec.model_serial_correlations = True
sinker_subs [list of tuples]:
passed to nipype.interfaces.io.Datasink. Changes names when passing to output directory.
e.g. model_wf.inputs.inputspec.sinker_subs =
[('pe1', 'pe1_instructions'),
('pe2', 'pe2_speech_prep'),
('pe3', 'pe3_no_speech')]
bold_template [dictionary with string entry]:
Specifies path, with wildcard, to grab all relevant BOLD files. Each subject_list entry should uniquely identify the ONE relevant file.
e.g. model_wf.inputs.inputspec.bold_template =
{'bold': '/home/neuro/data/sub-*/func/sub-*_task-stress_bold_space-MNI152NLin2009cAsym_preproc.nii.gz'}
This would grab the functional run for all subjects, and when subject_id = 'sub-001', there is ONE file in the list that the ID could possible correspond to.
To handle multiple runs, list the run information in the subject_id. e.g. 'sub-01_task-trag_run-01'.
mask_template [dictionary with string entry]:
Specifies path, with wildcard, to grab all relevant MASK files, corresponding to functional images. Each subject_list entry should uniquely identify the ONE relevant file.
e.g. model_wf.inputs.inputspec.mask_template =
{'mask': '/home/neuro/data/sub-*/func/sub-*_task-stress_bold_space-MNI152NLin2009cAsym_brainmask.nii.gz'}
See bold_template for more detail.
task_template [dictionary with string entry]:
Specifies path, with wildcard, to grab all relevant events.tsv files, corresponding to functional images. Each subject_list entry should uniquely identify the ONE relevant file.
e.g. model_wf.inputs.inputspec.task_template =
{'task': '/home/neuro/data/sub-*/func/sub-*_task-stress_events.tsv'}
See bold_template for more detail.
confound_template [dictionary with string entry]:
Specifies path, with wildcard, to grab all relevant confounds.tsv files, corresponding to functional images. Each subject_list entry should uniquely identify the ONE relevant file.
e.g. model_wf.inputs.inputspec.confound_template =
{'confound': '/home/neuro/data/sub-*/func/sub-*_task-stress_bold_confounds.tsv'}
See bold_template for more detail.
smooth_gm_mask_template [dictionary with string entry]:
Specifies path, with wildcard, to grab all relevant grey matter mask .nii.gz files, pulling from each subject's /anat fodler. Each subject_list entry should uniquely identify the ONE relevant file (BUT SEE THE NOTE BELOW).
e.g. model_wf.inputs.inputspec.smooth_gm_mask_template =
{'gm_mask': '/scratch/data/sub-*/anat/sub-*_T1w_space-MNI152NLin2009cAsym_class-GM_probtissue.nii.gz'}
NOTE: If the subject_id value has more information than just the ID (e.g. sub-01_task-trag_run-01), then JUST the sub-01 portion will be used to identify the grey matter mask. This is because multiple runs will have the same anatomical data. i.e. sub-01_run-01, sub-01_run-02, sub-01_run-03, all correspond to sub-01_T1w_space-MNI152NLin2009cAsym_class-GM_probtissue.nii.gz.
fwhm [float]. Redundant if options['smooth']: False
Determines smoothing kernel. Multiple kernels can be run in parallel by iterating through an outside workflow. Also see subject_id below for another example of iterables.
e.g.
model_wf.inputs.inputspec.fwhm = 1.5
OR Iterable e.g.
import nipype.pipeline.engine as pe
fwhm_list = [1.5, 6]
infosource = pe.Node(IdentityInterface(fields=['fwhm']),
name='infosource')
infosource.iterables = [('fwhm', fwhm_list)]
full_model_wf = pe.Workflow(name='full_model_wf')
full_model_wf.connect([(infosource, model_wf, [('subject_id', 'inputspec.subject_id')])])
full_model_wf.run()
subject_id [string]:
Identifies subject in conjnuction with template. See bold_template note above.
Can also be entered as an iterable from an outside workflow, in which case iterables are run in parallel to the extent that cpu cores are available.
e.g.
model_wf.inputs.inputspec.subject_id = 'sub-01'
OR Iterable e.g.
import nipype.pipeline.engine as pe
subject_list = ['sub-001', 'sub-002']
infosource = pe.Node(IdentityInterface(fields=['subject_id']),
name='infosource')
infosource.iterables = [('subject_id', subject_list)]
full_model_wf = pe.Workflow(name='full_model_wf')
full_model_wf.connect([(infosource, model_wf, [('subject_id', 'inputspec.subject_id')])])
full_model_wf.run()
'''
import nipype.pipeline.engine as pe # pypeline engine
import nipype.interfaces.fsl as fsl
import os
from nipype import IdentityInterface, SelectFiles
from nipype.interfaces.utility.wrappers import Function
################## Setup workflow.
lvl1pipe_wf = pe.Workflow(name='lvl_one_pipe')
inputspec = pe.Node(IdentityInterface(
fields=['input_dir',
'output_dir',
'design_col',
'noise_regressors',
'noise_transforms',
'TR', # in seconds.
'FILM_threshold',
'hpf_cutoff',
'conditions',
'contrasts',
'bases',
'model_serial_correlations',
'sinker_subs',
'bold_template',
'mask_template',
'task_template',
'confound_template',
'smooth_gm_mask_template',
'gmmask_args',
'subject_id',
'fwhm',
'proj_name',
],
mandatory_inputs=False),
name='inputspec')
################## Select Files
def get_file(subj_id, template):
import glob
temp_list = []
out_list = []
if '_' in subj_id and '/anat/' in list(template.values())[0]:
subj_id = subj_id[:subj_id.find('_')]
# if looking for gmmask, and subj_id includes additional info (e.g. sub-001_task-trag_run-01) then just take the subject id component, as the run info will not be present for the anatomical data.
for x in glob.glob(list(template.values())[0]):
if subj_id in x:
temp_list.append(x)
for file in temp_list: # ensure no duplicate entries.
if file not in out_list:
out_list.append(file)
if len(out_list) == 0:
assert (len(out_list) == 1), 'Each combination of template and subject ID should return 1 file. 0 files were returned.'
if len(out_list) > 1:
assert (len(out_list) == 1), 'Each combination of template and subject ID should return 1 file. Multiple files returned.'
out_file = out_list[0]
return out_file
get_bold = pe.Node(Function(
input_names=['subj_id', 'template'],
output_names=['out_file'],
function=get_file),
name='get_bold')
get_mask = pe.Node(Function(
input_names=['subj_id', 'template'],
output_names=['out_file'],
function=get_file),
name='get_mask')
get_task = pe.Node(Function(
input_names=['subj_id', 'template'],
output_names=['out_file'],
function=get_file),
name='get_task')
get_confile = pe.Node(Function(
input_names=['subj_id', 'template'],
output_names=['out_file'],
function=get_file),
name='get_confile')
# get_bold.inputs.subj_id # From inputspec
# get_bold.inputs.templates # From inputspec
if options['smooth']:
get_gmmask = pe.Node(Function(
input_names=['subj_id', 'template'],
output_names=['out_file'],
function=get_file),
name='get_gmmask')
mod_gmmask = pe.Node(fsl.maths.MathsCommand(),
name='mod_gmmask')
# mod_gmmask.inputs.in_file = # from get_gmmask
# mod_gmmask.inputs.args = from inputspec
def fit_mask(mask_file, ref_file):
from nilearn.image import resample_img
import nibabel as nib
import os
out_file = resample_img(nib.load(mask_file),
target_affine=nib.load(ref_file).affine,
target_shape=nib.load(ref_file).shape[0:3],
interpolation='nearest')
nib.save(out_file, os.path.join(os.getcwd(), mask_file.split('.nii')[0]+'_fit.nii.gz'))
out_mask = os.path.join(os.getcwd(), mask_file.split('.nii')[0]+'_fit.nii.gz')
return out_mask
fit_mask = pe.Node(Function(
input_names=['mask_file', 'ref_file'],
output_names=['out_mask'],
function=fit_mask),
name='fit_mask')
################## Setup confounds
def get_terms(confound_file, noise_transforms, noise_regressors, TR, options):
'''
Gathers confounds (and transformations) into a pandas dataframe.
Input [Mandatory]:
confound_file [string]: path to confound.tsv file, given by fmriprep.
noise_transforms [list of strings]:
noise transforms to be applied to select noise_regressors above. Possible values are 'quad', 'tderiv', and 'quadtderiv', standing for quadratic function of value, temporal derivative of value, and quadratic function of temporal derivative.
e.g. model_wf.inputs.inputspec.noise_transforms = ['quad', 'tderiv', 'quadtderiv']
noise_regressors [list of strings]:
column names in confounds.tsv, specifying desired noise regressors for model.
IF noise_transforms are to be applied to a regressor, add '*' to the name.
e.g. model_wf.inputs.inputspec.noise_regressors = ['CSF', 'WhiteMatter', 'GlobalSignal', 'X*', 'Y*', 'Z*', 'RotX*', 'RotY*', 'RotZ*']
TR [float]:
Scanner TR value in seconds.
options: dictionary with the following entries
remove_steadystateoutlier [boolean]:
Should always be True. Remove steady state outliers from bold timecourse, specified in fmriprep confounds file.
ICA_AROMA [boolean]:
Use AROMA error components, from fmriprep confounds file.
poly_trend [integer. Use None to skip]:
If given, polynomial trends will be added to run confounds, up to the order of the integer
e.g. "0", gives an intercept, "1" gives intercept + linear trend,
"2" gives intercept + linear trend + quadratic.
dct_basis [integer. Use None to skip]:
If given, adds a discrete cosine transform, with a length (in seconds) of the interger specified.
Adds unit scaled cosine basis functions to Design_Matrix columns,
based on spm-style discrete cosine transform for use in
high-pass filtering. Does not add intercept/constant.
'''
import numpy as np
import pandas as pd
from nltools.data import Design_Matrix
df_cf = pd.DataFrame(pd.read_csv(confound_file, sep='\t', parse_dates=False))
transfrm_list = []
for idx, entry in enumerate(noise_regressors): # get entries marked with *, indicating they should be transformed.
if '*' in entry:
transfrm_list.append(entry.replace('*', '')) # add entry to transformation list if it has *.
noise_regressors[idx] = entry.replace('*', '')
confounds = df_cf[noise_regressors]
transfrmd_cnfds = df_cf[transfrm_list] # for transforms
TR_time = pd.Series(np.arange(0.0, TR*transfrmd_cnfds.shape[0], TR)) # time series for derivatives.
if 'quad' in noise_transforms:
quad = np.square(transfrmd_cnfds)
confounds = confounds.join(quad, rsuffix='_quad')
if 'tderiv' in noise_transforms:
tderiv = pd.DataFrame(pd.Series(np.gradient(transfrmd_cnfds[col]), TR_time)
for col in transfrmd_cnfds).T
tderiv.columns = transfrmd_cnfds.columns
tderiv.index = confounds.index
confounds = confounds.join(tderiv, rsuffix='_tderiv')
if 'quadtderiv' in noise_transforms:
quadtderiv = np.square(tderiv)
confounds = confounds.join(quadtderiv, rsuffix='_quadtderiv')
if options['remove_steadystateoutlier']:
if not df_cf[df_cf.columns[df_cf.columns.to_series().str.contains('^non_steady_state_outlier')]].empty:
confounds = confounds.join(df_cf[df_cf.columns[df_cf.columns.to_series().str.contains('^non_steady_state_outlier')]])
elif not df_cf[df_cf.columns[df_cf.columns.to_series().str.contains('^NonSteadyStateOutlier')]].empty:
confounds = confounds.join(df_cf[df_cf.columns[df_cf.columns.to_series().str.contains('^NonSteadyStateOutlier')]]) # old syntax
if options['ICA_AROMA']:
if not df_cf[df_cf.columns[df_cf.columns.to_series().str.contains('^aroma_motion')]].empty:
confounds = confounds.join(df_cf[df_cf.columns[df_cf.columns.to_series().str.contains('^aroma_motion')]])
elif not df_cf[df_cf.columns[df_cf.columns.to_series().str.contains('^AROMAAggrComp')]].empty:
confounds = confounds.join(df_cf[df_cf.columns[df_cf.columns.to_series().str.contains('^AROMAAggrComp')]]) # old syntax
confounds = Design_Matrix(confounds, sampling_freq=1/TR)
if isinstance(options['poly_trend'], int):
confounds = confounds.add_poly(order = options['poly_trend']) # these do not play nice with high pass filters.
if isinstance(options['dct_basis'], int):
confounds = confounds.add_dct_basis(duration=options['dct_basis']) # these do not play nice with high pass filters.
return confounds
get_confounds = pe.Node(Function(input_names=['confound_file', 'noise_transforms',
'noise_regressors', 'TR', 'options'],
output_names=['confounds'],
function=get_terms),
name='get_confounds')
# get_confounds.inputs.confound_file = # From get_confile
# get_confounds.inputs.noise_transforms = # From inputspec
# get_confounds.inputs.noise_regressors = # From inputspec
# get_confounds.inputs.TR = # From inputspec
get_confounds.inputs.options = options
################## Create bunch to run FSL first level model.
def get_subj_info(task_file, design_col, confounds, conditions):
'''
Makes a Bunch, giving all necessary data about conditions, onsets, and durations to
FSL first level model. Needs a task file to run.
Inputs:
task file [string], path to the subject events.tsv file, as per BIDS format.
design_col [string], column name within task file, identifying event conditions to model.
confounds [pandas dataframe], pd.df of confounds, gathered from get_confounds node.
conditions [list],
e.g. ['condition1',
'condition2',
['condition1', 'parametric1', 'no_cent', 'no_norm'],
['condition2', 'paramatric2', 'cent', 'norm']]
each string entry (e.g. 'condition1') specifies a event condition in the design_col column.
each list entry includes 4 strings:
entry 1 is a condition within the design_col column
entry 2 is a column in the events folder, which will be used for parametric weightings.
entry 3 is either 'no_cent', or 'cent', indicating whether to center the parametric variable.
entry 4 is either 'no_norm', or 'norm', indicating whether to normalize the parametric variable.
Onsets and durations will be taken from corresponding values for entry 1
parametric weighting specified by entry 2, scaled/centered as specified, then
appended to the design matrix.
'''
from nipype.interfaces.base import Bunch
import pandas as pd
import numpy as np
from sklearn.preprocessing import scale
onsets = []
durations = []
amplitudes = []
df = pd.read_csv(task_file, sep='\t', parse_dates=False)
for idx, cond in enumerate(conditions):
if isinstance(cond, list):
if cond[2] == 'no_cent': # determine whether to center/scale
c = False
elif cond[2] == 'cent':
c = True
if cond[3] == 'no_norm':
n = False
elif cond[3] == 'norm':
n = True
# grab parametric terms.
onsets.append(list(df[df[design_col] == cond[0]].onset))
durations.append(list(df[df[design_col] == cond[0]].duration))
amp_temp = list(scale(df[df[design_col] == cond[0]][cond[1]].tolist(),
with_mean=c, with_std=n)) # scale
amp_temp = pd.Series(amp_temp, dtype=object).fillna(0).tolist() # fill na
amplitudes.append(amp_temp) # append
conditions[idx] = cond[0]+'_'+cond[1] # combine condition/parametric names and replace.
elif isinstance(cond, str):
onsets.append(list(df[df[design_col] == cond].onset))
durations.append(list(df[df[design_col] == cond].duration))
# dummy code 1's for non-parametric conditions.
amplitudes.append(list(np.repeat(1, len(df[df[design_col] == cond].onset))))
else:
print('cannot identify condition:', cond)
# return None
output = Bunch(conditions= conditions,
onsets=onsets,
durations=durations,
amplitudes=amplitudes,
tmod=None,
pmod=None,
regressor_names=confounds.columns.values,
regressors=confounds.T.values.tolist()) # movement regressors added here. List of lists.
return output
make_bunch = pe.Node(Function(input_names=['task_file', 'design_col', 'confounds', 'conditions'],
output_names=['subject_info'],
function=get_subj_info),
name='make_bunch')
# make_bunch.inputs.task_file = # From get_task
# make_bunch.inputs.confounds = # From get_confounds
# make_bunch.inputs.design_col = # From inputspec
# make_bunch.inputs.conditions = # From inputspec
def mk_outdir(output_dir, options, proj_name):
import os
from time import gmtime, strftime
prefix = proj_name
if options['smooth']:
new_out_dir = os.path.join(output_dir, prefix, 'smooth')
else:
new_out_dir = os.path.join(output_dir, prefix, 'nosmooth')
if not os.path.isdir(new_out_dir):
os.makedirs(new_out_dir)
return new_out_dir
make_outdir = pe.Node(Function(input_names=['output_dir', 'options', 'proj_name'],
output_names=['new_out_dir'],
function=mk_outdir),
name='make_outdir')
# make_outdir.inputs.proj_name = from inputspec
# make_outdir.inputs.output_dir = from inputspec
make_outdir.inputs.options = options
################## Mask functional data.
from jtnipyutil.util import mask_img
maskBold = pe.Node(Function(input_names=['img_file', 'mask_file'],
output_names=['out_file'],
function=mask_img),
name='maskBold')
# maskBold.inputs.img_file # From get_bold, or smooth_wf
# maskBold.inputs.mask_file # From get_mask
################## Despike
from nipype.interfaces.afni import Despike
despike = pe.Node(Despike(),
name='despike')
# despike.inputs.in_file = # From Mask
despike.inputs.outputtype = 'NIFTI_GZ'
from nipype.workflows.fmri.fsl.preprocess import create_susan_smooth
smooth_wf = create_susan_smooth()
# smooth_wf.inputs.inputnode.in_files = # from maskBold
# smooth_wf.inputs.inputnode.fwhm = # from inputspec
################## Model Generation.
import nipype.algorithms.modelgen as model
specify_model = pe.Node(interface=model.SpecifyModel(), name='specify_model')
specify_model.inputs.input_units = 'secs'
# specify_model.functional_runs # From maskBold, despike, or smooth_wf
# specify_model.subject_info # From make_bunch.outputs.subject_info
# specify_model.high_pass_filter_cutoff # From inputspec
# specify_model.time_repetition # From inputspec
################## Estimate workflow
from nipype.workflows.fmri.fsl import estimate # fsl workflow
modelfit = estimate.create_modelfit_workflow()
modelfit.base_dir = '.'
# modelfit.inputs.inputspec.session_info = # From specify_model
# modelfit.inputs.inputspec.functional_data = # from maskBold
# modelfit.inputs.inputspec.interscan_interval = # From inputspec
# modelfit.inputs.inputspec.film_threshold = # From inputspec
# modelfit.inputs.inputspec.bases = # From inputspec
# modelfit.inputs.inputspec.model_serial_correlations = # From inputspec
# modelfit.inputs.inputspec.contrasts = # From inputspec
if not options['run_contrasts']: # drop contrast part of modelfit if contrasts aren't required.
modelestimate = modelfit.get_node('modelestimate')
merge_contrasts = modelfit.get_node('merge_contrasts')
ztop = modelfit.get_node('ztop')
outputspec = modelfit.get_node('outputspec')
modelfit.disconnect([(modelestimate, merge_contrasts, [('zstats', 'in1'),
('zfstats', 'in2')]),
(merge_contrasts, ztop, [('out', 'in_file')]),
(merge_contrasts, outputspec, [('out', 'zfiles')]),
(ztop, outputspec, [('out_file', 'pfiles')])
])
modelfit.remove_nodes([merge_contrasts, ztop])
################## DataSink
from nipype.interfaces.io import DataSink
import os.path
sinker = pe.Node(DataSink(), name='sinker')
# sinker.inputs.substitutions = # From inputspec
# sinker.inputs.base_directory = # frm make_outdir
def negate(input):
return not input
def unlist(input):
return input[0]
lvl1pipe_wf.connect([
# grab subject/run info
(inputspec, get_bold, [('subject_id', 'subj_id'),
('bold_template', 'template')]),
(inputspec, get_mask, [('subject_id', 'subj_id'),
('mask_template', 'template')]),
(inputspec, get_task, [('subject_id', 'subj_id'),
('task_template', 'template')]),
(inputspec, get_confile, [('subject_id', 'subj_id'),
('confound_template', 'template')]),
(inputspec, get_confounds, [('noise_transforms', 'noise_transforms'),
('noise_regressors', 'noise_regressors'),
('TR', 'TR')]),
(inputspec, make_bunch, [('design_col', 'design_col'),
('conditions', 'conditions')]),
(inputspec, make_outdir, [('output_dir', 'output_dir'),
('proj_name', 'proj_name')]),
(inputspec, specify_model, [('hpf_cutoff', 'high_pass_filter_cutoff'),
('TR', 'time_repetition')]),
(inputspec, modelfit, [('TR', 'inputspec.interscan_interval'),
('FILM_threshold', 'inputspec.film_threshold'),
('bases', 'inputspec.bases'),
('model_serial_correlations', 'inputspec.model_serial_correlations'),
(('model_serial_correlations', negate), 'modelestimate.autocorr_noestimate'),
('contrasts', 'inputspec.contrasts')]),
(get_confile, get_confounds, [('out_file', 'confound_file')]),
(get_confounds, make_bunch, [('confounds', 'confounds')]),
(get_task, make_bunch, [('out_file', 'task_file')]),
(make_bunch, specify_model, [('subject_info', 'subject_info')]),
(get_mask, maskBold, [('out_file', 'mask_file')]),
])
if options['censoring'] == 'despike':
lvl1pipe_wf.connect([
(get_bold, despike, [('out_file', 'in_file')])
])
if options['smooth']:
lvl1pipe_wf.connect([
(inputspec, smooth_wf, [('fwhm', 'inputnode.fwhm')]),
(inputspec, get_gmmask, [('subject_id', 'subj_id'),
('smooth_gm_mask_template', 'template')]),
(get_gmmask, mod_gmmask, [('out_file', 'in_file')]),
(inputspec, mod_gmmask, [('gmmask_args', 'args')]),
(mod_gmmask, fit_mask, [('out_file', 'mask_file')]),
(get_bold, fit_mask, [('out_file', 'ref_file')]),
(fit_mask, smooth_wf, [('out_mask', 'inputnode.mask_file')]),
(fit_mask, sinker, [('out_mask', 'smoothing_mask')]),
(despike, smooth_wf, [('out_file', 'inputnode.in_files')]),
(smooth_wf, maskBold, [(('outputnode.smoothed_files', unlist), 'img_file')]),
(maskBold, specify_model, [('out_file', 'functional_runs')]),
(maskBold, modelfit, [('out_file', 'inputspec.functional_data')])
])
else:
lvl1pipe_wf.connect([
(despike, specify_model, [('out_file', 'functional_runs')]),
(despike, modelfit, [('out_file', 'inputspec.functional_data')]),
(despike, sinker, [('out_file', 'despike')])
])
else:
if options['smooth']:
lvl1pipe_wf.connect([
(inputspec, smooth_wf, [('fwhm', 'inputnode.fwhm')]),
(inputspec, get_gmmask, [('subject_id', 'subj_id'),
('smooth_gm_mask_template', 'template')]),
(get_gmmask, mod_gmmask, [('out_file', 'in_file')]),
(inputspec, mod_gmmask, [('gmmask_args', 'args')]),
(mod_gmmask, fit_mask, [('out_file', 'mask_file')]),
(get_bold, fit_mask, [('out_file', 'ref_file')]),
(fit_mask, smooth_wf, [('out_mask', 'inputnode.mask_file')]),
(fit_mask, sinker, [('out_mask', 'smoothing_mask')]),
(get_bold, smooth_wf, [('out_file', 'inputnode.in_files')]),
(smooth_wf, maskBold, [(('outputnode.smoothed_files', unlist), 'img_file')]),
(maskBold, specify_model, [('out_file', 'functional_runs')]),
(maskBold, modelfit, [('out_file', 'inputspec.functional_data')])
])
else:
lvl1pipe_wf.connect([
(get_bold, maskBold, [('out_file', 'img_file')]),
(maskBold, specify_model, [('out_file', 'functional_runs')]),
(maskBold, modelfit, [('out_file', 'inputspec.functional_data')])
])
lvl1pipe_wf.connect([
(specify_model, modelfit, [('session_info', 'inputspec.session_info')]),
(inputspec, sinker, [('subject_id','container'),
('sinker_subs', 'substitutions')]), # creates folder for each subject.
(make_outdir, sinker, [('new_out_dir', 'base_directory')]),
(modelfit, sinker, [('outputspec.parameter_estimates', 'model'),
('outputspec.dof_file','model.@dof'), #.@ puts this in the model folder.
('outputspec.copes','model.@copes'),
('outputspec.varcopes','model.@varcopes'),
('outputspec.zfiles','stats'),
('outputspec.pfiles', 'stats.@pfiles'),
('level1design.ev_files', 'design'),
('level1design.fsf_files', 'design.@fsf'),
('modelgen.con_file', 'design.@confile'),
('modelgen.fcon_file', 'design.@fconfile'),
('modelgen.design_cov', 'design.@covmatriximg'),
('modelgen.design_image', 'design.@designimg'),
('modelgen.design_file', 'design.@designfile'),
('modelestimate.logfile', 'design.@log'),
('modelestimate.sigmasquareds', 'model.@resid_sum'),
('modelestimate.fstats', 'stats.@fstats'),
('modelestimate.thresholdac', 'model.@serial_corr'),
])
])
if options['keep_resid']:
lvl1pipe_wf.connect([
(modelfit, sinker, [('modelestimate.residual4d', 'model.@resid')
])
])
return lvl1pipe_wf
