def z_score_standardize(workflow,
output_name,
mask_name,
strat,
num_strat,
map_node=False):
# call the z-scoring sub-workflow builder
z_score_std = get_zscore(output_name, map_node,
'z_score_std_%s_%d' % (output_name, num_strat))
node, out_file = strat[output_name]
workflow.connect(node, out_file, z_score_std, 'inputspec.input_file')
# get the mask
if type(mask_name) == str:
node, out_file = strat[mask_name]
workflow.connect(node, out_file, z_score_std, 'inputspec.mask_file')
else:
# mask_name is a direct file path and not the name of a
# resource pool key
workflow.connect(mask_name, 'local_path', z_score_std,
'inputspec.mask_file')
strat.append_name(z_score_std.name)
strat.update_resource_pool({
'{0}_zstd'.format(output_name): (z_score_std, 'outputspec.z_score_img')
})
return strat
def z_score_standardize(wf_name, input_image_type='func_derivative',
opt=None):
wf = pe.Workflow(name=wf_name)
map_node = False
if input_image_type == 'func_derivative_multi':
map_node = True
inputnode = pe.Node(util.IdentityInterface(fields=['in_file',
'mask']),
name='inputspec')
z_score_std = get_zscore(map_node, 'z_score_std')
wf.connect(inputnode, 'in_file', z_score_std, 'inputspec.input_file')
wf.connect(inputnode, 'mask', z_score_std, 'inputspec.mask_file')
outputnode = pe.Node(util.IdentityInterface(fields=['out_file']),
name='outputspec')
wf.connect(z_score_std, 'outputspec.z_score_img', outputnode, 'out_file')
return wf
def calc_local_metrics(cfg):
import os
from nipype import config
from nipype.pipeline.engine import Node, Workflow, MapNode
import nipype.interfaces.utility as util
import nipype.interfaces.io as nio
import nipype.interfaces.fsl as fsl
import nipype.interfaces.freesurfer as freesurfer
import CPAC.alff.alff as cpac_alff
import CPAC.reho.reho as cpac_reho
import CPAC.utils.utils as cpac_utils
import CPAC.vmhc.vmhc as cpac_vmhc
import CPAC.registration.registration as cpac_registration
import CPAC.network_centrality.z_score as cpac_centrality_z_score
import utils as calc_metrics_utils
# INPUT PARAMETERS
dicom_dir = cfg['dicom_dir']
preprocessed_data_dir = cfg['preprocessed_data_dir']
working_dir = cfg['working_dir']
freesurfer_dir = cfg['freesurfer_dir']
template_dir = cfg['template_dir']
script_dir = cfg['script_dir']
ds_dir = cfg['ds_dir']
subject_id = cfg['subject_id']
TR_list = cfg['TR_list']
vols_to_drop = cfg['vols_to_drop']
rois_list = cfg['rois_list']
lp_cutoff_freq = cfg['lp_cutoff_freq']
hp_cutoff_freq = cfg['hp_cutoff_freq']
use_fs_brainmask = cfg['use_fs_brainmask']
use_n_procs = cfg['use_n_procs']
plugin_name = cfg['plugin_name']
#####################################
# GENERAL SETTINGS
#####################################
fsl.FSLCommand.set_default_output_type('NIFTI_GZ')
freesurfer.FSCommand.set_default_subjects_dir(freesurfer_dir)
wf = Workflow(name='LeiCA_metrics')
wf.base_dir = os.path.join(working_dir)
nipype_cfg = dict(logging=dict(workflow_level='DEBUG'), execution={'stop_on_first_crash': True,
'remove_unnecessary_outputs': True,
'job_finished_timeout': 120})
config.update_config(nipype_cfg)
wf.config['execution']['crashdump_dir'] = os.path.join(working_dir, 'crash')
ds = Node(nio.DataSink(base_directory=ds_dir), name='ds')
ds.inputs.substitutions = [('_TR_id_', 'TR_')]
ds.inputs.regexp_substitutions = [('_variabilty_MNIspace_3mm[0-9]*/', ''), ('_z_score[0-9]*/', '')]
#####################################
# SET ITERATORS
#####################################
# GET SCAN TR_ID ITERATOR
scan_infosource = Node(util.IdentityInterface(fields=['TR_id']), name='scan_infosource')
scan_infosource.iterables = ('TR_id', TR_list)
# get atlas data
templates_atlases = { # 'GM_mask_MNI_2mm': 'SPM_GM/SPM_GM_mask_2mm.nii.gz',
# 'GM_mask_MNI_3mm': 'SPM_GM/SPM_GM_mask_3mm.nii.gz',
'FSL_MNI_3mm_template': 'MNI152_T1_3mm_brain.nii.gz',
'vmhc_symm_brain': 'cpac_image_resources/symmetric/MNI152_T1_2mm_brain_symmetric.nii.gz',
'vmhc_symm_brain_3mm': 'cpac_image_resources/symmetric/MNI152_T1_3mm_brain_symmetric.nii.gz',
'vmhc_symm_skull': 'cpac_image_resources/symmetric/MNI152_T1_2mm_symmetric.nii.gz',
'vmhc_symm_brain_mask_dil': 'cpac_image_resources/symmetric/MNI152_T1_2mm_brain_mask_symmetric_dil.nii.gz',
'vmhc_config_file_2mm': 'cpac_image_resources/symmetric/T1_2_MNI152_2mm_symmetric.cnf'
}
selectfiles_anat_templates = Node(nio.SelectFiles(templates_atlases,
base_directory=template_dir),
name="selectfiles_anat_templates")
# GET SUBJECT SPECIFIC FUNCTIONAL AND STRUCTURAL DATA
selectfiles_templates = {
'epi_2_MNI_warp': '{subject_id}/rsfMRI_preprocessing/registration/epi_2_MNI_warp/TR_{TR_id}/*.nii.gz',
'epi_mask': '{subject_id}/rsfMRI_preprocessing/masks/brain_mask_epiSpace/TR_{TR_id}/*.nii.gz',
'preproc_epi_full_spectrum': '{subject_id}/rsfMRI_preprocessing/epis/01_denoised/TR_{TR_id}/*.nii.gz',
'preproc_epi_bp': '{subject_id}/rsfMRI_preprocessing/epis/02_denoised_BP/TR_{TR_id}/*.nii.gz',
'preproc_epi_bp_tNorm': '{subject_id}/rsfMRI_preprocessing/epis/03_denoised_BP_tNorm/TR_{TR_id}/*.nii.gz',
'epi_2_struct_mat': '{subject_id}/rsfMRI_preprocessing/registration/epi_2_struct_mat/TR_{TR_id}/*.mat',
't1w': '{subject_id}/raw_niftis/sMRI/t1w_reoriented.nii.gz',
't1w_brain': '{subject_id}/rsfMRI_preprocessing/struct_prep/t1w_brain/t1w_reoriented_maths.nii.gz',
}
selectfiles = Node(nio.SelectFiles(selectfiles_templates,
base_directory=preprocessed_data_dir),
name="selectfiles")
wf.connect(scan_infosource, 'TR_id', selectfiles, 'TR_id')
selectfiles.inputs.subject_id = subject_id
# CREATE TRANSFORMATIONS
# creat MNI 2 epi warp
MNI_2_epi_warp = Node(fsl.InvWarp(), name='MNI_2_epi_warp')
MNI_2_epi_warp.inputs.reference = fsl.Info.standard_image('MNI152_T1_2mm.nii.gz')
wf.connect(selectfiles, 'epi_mask', MNI_2_epi_warp, 'reference')
wf.connect(selectfiles, 'epi_2_MNI_warp', MNI_2_epi_warp, 'warp')
# # CREATE GM MASK IN EPI SPACE
# GM_mask_epiSpace = Node(fsl.ApplyWarp(), name='GM_mask_epiSpace')
# GM_mask_epiSpace.inputs.out_file = 'GM_mask_epiSpace.nii.gz'
#
# wf.connect(selectfiles_anat_templates, 'GM_mask_MNI_2mm', GM_mask_epiSpace, 'in_file')
# wf.connect(selectfiles, 'epi_mask', GM_mask_epiSpace, 'ref_file')
# wf.connect(MNI_2_epi_warp, 'inverse_warp', GM_mask_epiSpace, 'field_file')
# wf.connect(GM_mask_epiSpace, 'out_file', ds, 'GM_mask_epiSpace')
# fixme
# # CREATE TS IN MNI SPACE
# # is it ok to apply the 2mm warpfield to the 3mm template?
# # seems ok: https://www.jiscmail.ac.uk/cgi-bin/webadmin?A2=ind0904&L=FSL&P=R14011&1=FSL&9=A&J=on&d=No+Match%3BMatch%3BMatches&z=4
# epi_bp_MNIspace_3mm = Node(fsl.ApplyWarp(), name='epi_bp_MNIspace_3mm')
# epi_bp_MNIspace_3mm.inputs.interp = 'spline'
# epi_bp_MNIspace_3mm.plugin_args = {'submit_specs': 'request_memory = 4000'}
# wf.connect(selectfiles_anat_templates, 'FSL_MNI_3mm_template', epi_bp_MNIspace_3mm, 'ref_file')
# wf.connect(selectfiles, 'preproc_epi_bp', epi_bp_MNIspace_3mm, 'in_file')
# wf.connect(selectfiles, 'epi_2_MNI_warp', epi_bp_MNIspace_3mm, 'field_file')
# CREATE EPI MASK IN MNI SPACE
epi_mask_MNIspace_3mm = Node(fsl.ApplyWarp(), name='epi_mask_MNIspace_3mm')
epi_mask_MNIspace_3mm.inputs.interp = 'nn'
epi_mask_MNIspace_3mm.plugin_args = {'submit_specs': 'request_memory = 4000'}
wf.connect(selectfiles_anat_templates, 'FSL_MNI_3mm_template', epi_mask_MNIspace_3mm, 'ref_file')
wf.connect(selectfiles, 'epi_mask', epi_mask_MNIspace_3mm, 'in_file')
wf.connect(selectfiles, 'epi_2_MNI_warp', epi_mask_MNIspace_3mm, 'field_file')
wf.connect(epi_mask_MNIspace_3mm, 'out_file', ds, 'epi_mask_MNIspace_3mm')
#####################
# CALCULATE METRICS
#####################
# f/ALFF
alff = cpac_alff.create_alff('alff')
alff.inputs.hp_input.hp = 0.01
alff.inputs.lp_input.lp = 0.1
wf.connect(selectfiles, 'preproc_epi_full_spectrum', alff, 'inputspec.rest_res')
# wf.connect(GM_mask_epiSpace, 'out_file', alff, 'inputspec.rest_mask')
wf.connect(selectfiles, 'epi_mask', alff, 'inputspec.rest_mask')
wf.connect(alff, 'outputspec.alff_img', ds, 'alff.alff')
wf.connect(alff, 'outputspec.falff_img', ds, 'alff.falff')
# f/ALFF 2 MNI
# fixme spline or default?
alff_MNIspace_3mm = Node(fsl.ApplyWarp(), name='alff_MNIspace_3mm')
alff_MNIspace_3mm.inputs.interp = 'spline'
alff_MNIspace_3mm.plugin_args = {'submit_specs': 'request_memory = 4000'}
wf.connect(selectfiles_anat_templates, 'FSL_MNI_3mm_template', alff_MNIspace_3mm, 'ref_file')
wf.connect(alff, 'outputspec.alff_img', alff_MNIspace_3mm, 'in_file')
wf.connect(selectfiles, 'epi_2_MNI_warp', alff_MNIspace_3mm, 'field_file')
wf.connect(alff_MNIspace_3mm, 'out_file', ds, 'alff.alff_MNI_3mm')
falff_MNIspace_3mm = Node(fsl.ApplyWarp(), name='falff_MNIspace_3mm')
falff_MNIspace_3mm.inputs.interp = 'spline'
falff_MNIspace_3mm.plugin_args = {'submit_specs': 'request_memory = 4000'}
wf.connect(selectfiles_anat_templates, 'FSL_MNI_3mm_template', falff_MNIspace_3mm, 'ref_file')
wf.connect(alff, 'outputspec.falff_img', falff_MNIspace_3mm, 'in_file')
wf.connect(selectfiles, 'epi_2_MNI_warp', falff_MNIspace_3mm, 'field_file')
wf.connect(falff_MNIspace_3mm, 'out_file', ds, 'alff.falff_MNI_3mm')
# f/ALFF_MNI Z-SCORE
alff_MNIspace_3mm_Z = cpac_utils.get_zscore(input_name='alff_MNIspace_3mm', wf_name='alff_MNIspace_3mm_Z')
wf.connect(alff_MNIspace_3mm, 'out_file', alff_MNIspace_3mm_Z, 'inputspec.input_file')
# wf.connect(selectfiles_anat_templates, 'GM_mask_MNI_3mm', alff_MNIspace_3mm_Z, 'inputspec.mask_file')
wf.connect(epi_mask_MNIspace_3mm, 'out_file', alff_MNIspace_3mm_Z, 'inputspec.mask_file')
wf.connect(alff_MNIspace_3mm_Z, 'outputspec.z_score_img', ds, 'alff.alff_MNI_3mm_Z')
falff_MNIspace_3mm_Z = cpac_utils.get_zscore(input_name='falff_MNIspace_3mm', wf_name='falff_MNIspace_3mm_Z')
wf.connect(falff_MNIspace_3mm, 'out_file', falff_MNIspace_3mm_Z, 'inputspec.input_file')
# wf.connect(selectfiles_anat_templates, 'GM_mask_MNI_3mm', falff_MNIspace_3mm_Z, 'inputspec.mask_file')
wf.connect(epi_mask_MNIspace_3mm, 'out_file', falff_MNIspace_3mm_Z, 'inputspec.mask_file')
wf.connect(falff_MNIspace_3mm_Z, 'outputspec.z_score_img', ds, 'alff.falff_MNI_3mm_Z')
# f/ALFF_MNI STANDARDIZE BY MEAN
alff_MNIspace_3mm_standardized_mean = calc_metrics_utils.standardize_divide_by_mean(
wf_name='alff_MNIspace_3mm_standardized_mean')
wf.connect(alff_MNIspace_3mm, 'out_file', alff_MNIspace_3mm_standardized_mean, 'inputnode.in_file')
wf.connect(epi_mask_MNIspace_3mm, 'out_file', alff_MNIspace_3mm_standardized_mean, 'inputnode.mask_file')
wf.connect(alff_MNIspace_3mm_standardized_mean, 'outputnode.out_file', ds, 'alff.alff_MNI_3mm_standardized_mean')
falff_MNIspace_3mm_standardized_mean = calc_metrics_utils.standardize_divide_by_mean(
wf_name='falff_MNIspace_3mm_standardized_mean')
wf.connect(falff_MNIspace_3mm, 'out_file', falff_MNIspace_3mm_standardized_mean, 'inputnode.in_file')
wf.connect(epi_mask_MNIspace_3mm, 'out_file', falff_MNIspace_3mm_standardized_mean, 'inputnode.mask_file')
wf.connect(falff_MNIspace_3mm_standardized_mean, 'outputnode.out_file', ds, 'alff.falff_MNI_3mm_standardized_mean')
# REHO
reho = cpac_reho.create_reho()
reho.inputs.inputspec.cluster_size = 27
wf.connect(selectfiles, 'preproc_epi_bp', reho, 'inputspec.rest_res_filt')
# wf.connect(GM_mask_epiSpace, 'out_file', reho, 'inputspec.rest_mask')
wf.connect(selectfiles, 'epi_mask', reho, 'inputspec.rest_mask')
wf.connect(reho, 'outputspec.raw_reho_map', ds, 'reho.reho')
# REHO 2 MNI
# fixme spline or default?
reho_MNIspace_3mm = Node(fsl.ApplyWarp(), name='reho_MNIspace_3mm')
reho_MNIspace_3mm.inputs.interp = 'spline'
reho_MNIspace_3mm.plugin_args = {'submit_specs': 'request_memory = 4000'}
wf.connect(selectfiles_anat_templates, 'FSL_MNI_3mm_template', reho_MNIspace_3mm, 'ref_file')
wf.connect(reho, 'outputspec.raw_reho_map', reho_MNIspace_3mm, 'in_file')
wf.connect(selectfiles, 'epi_2_MNI_warp', reho_MNIspace_3mm, 'field_file')
wf.connect(reho_MNIspace_3mm, 'out_file', ds, 'reho.reho_MNI_3mm')
# REHO_MNI Z-SCORE
reho_MNIspace_3mm_Z = cpac_utils.get_zscore(input_name='reho_MNIspace_3mm', wf_name='reho_MNIspace_3mm_Z')
wf.connect(alff_MNIspace_3mm, 'out_file', reho_MNIspace_3mm_Z, 'inputspec.input_file')
# wf.connect(selectfiles_anat_templates, 'GM_mask_MNI_3mm', reho_MNIspace_3mm_Z, 'inputspec.mask_file')
wf.connect(epi_mask_MNIspace_3mm, 'out_file', reho_MNIspace_3mm_Z, 'inputspec.mask_file')
wf.connect(reho_MNIspace_3mm_Z, 'outputspec.z_score_img', ds, 'reho.reho_MNI_3mm_Z')
# REHO_MNI STANDARDIZE BY MEAN
reho_MNIspace_3mm_standardized_mean = calc_metrics_utils.standardize_divide_by_mean(
wf_name='reho_MNIspace_3mm_standardized_mean')
wf.connect(reho_MNIspace_3mm, 'out_file', reho_MNIspace_3mm_standardized_mean, 'inputnode.in_file')
wf.connect(epi_mask_MNIspace_3mm, 'out_file', reho_MNIspace_3mm_standardized_mean, 'inputnode.mask_file')
wf.connect(reho_MNIspace_3mm_standardized_mean, 'outputnode.out_file', ds, 'reho.reho_MNI_3mm_standardized_mean')
# VMHC
# create registration to symmetrical MNI template
struct_2_MNI_symm = cpac_registration.create_nonlinear_register(name='struct_2_MNI_symm')
wf.connect(selectfiles_anat_templates, 'vmhc_config_file_2mm', struct_2_MNI_symm, 'inputspec.fnirt_config')
wf.connect(selectfiles_anat_templates, 'vmhc_symm_brain', struct_2_MNI_symm, 'inputspec.reference_brain')
wf.connect(selectfiles_anat_templates, 'vmhc_symm_skull', struct_2_MNI_symm, 'inputspec.reference_skull')
wf.connect(selectfiles_anat_templates, 'vmhc_symm_brain_mask_dil', struct_2_MNI_symm, 'inputspec.ref_mask')
wf.connect(selectfiles, 't1w', struct_2_MNI_symm, 'inputspec.input_skull')
wf.connect(selectfiles, 't1w_brain', struct_2_MNI_symm, 'inputspec.input_brain')
wf.connect(struct_2_MNI_symm, 'outputspec.output_brain', ds, 'vmhc.symm_reg.@output_brain')
wf.connect(struct_2_MNI_symm, 'outputspec.linear_xfm', ds, 'vmhc.symm_reg.@linear_xfm')
wf.connect(struct_2_MNI_symm, 'outputspec.invlinear_xfm', ds, 'vmhc.symm_reg.@invlinear_xfm')
wf.connect(struct_2_MNI_symm, 'outputspec.nonlinear_xfm', ds, 'vmhc.symm_reg.@nonlinear_xfm')
# fixme
vmhc = cpac_vmhc.create_vmhc(use_ants=False, name='vmhc')
vmhc.inputs.fwhm_input.fwhm = 4
wf.connect(selectfiles_anat_templates, 'vmhc_symm_brain_3mm', vmhc, 'inputspec.standard_for_func')
wf.connect(selectfiles, 'preproc_epi_bp_tNorm', vmhc, 'inputspec.rest_res')
wf.connect(selectfiles, 'epi_2_struct_mat', vmhc, 'inputspec.example_func2highres_mat')
wf.connect(struct_2_MNI_symm, 'outputspec.nonlinear_xfm', vmhc, 'inputspec.fnirt_nonlinear_warp')
# wf.connect(GM_mask_epiSpace, 'out_file', vmhc, 'inputspec.rest_mask')
wf.connect(selectfiles, 'epi_mask', vmhc, 'inputspec.rest_mask')
wf.connect(vmhc, 'outputspec.rest_res_2symmstandard', ds, 'vmhc.rest_res_2symmstandard')
wf.connect(vmhc, 'outputspec.VMHC_FWHM_img', ds, 'vmhc.VMHC_FWHM_img')
wf.connect(vmhc, 'outputspec.VMHC_Z_FWHM_img', ds, 'vmhc.VMHC_Z_FWHM_img')
wf.connect(vmhc, 'outputspec.VMHC_Z_stat_FWHM_img', ds, 'vmhc.VMHC_Z_stat_FWHM_img')
# VARIABILITY SCORES
variability = Node(util.Function(input_names=['in_file'],
output_names=['out_file_list'],
function=calc_metrics_utils.calc_variability),
name='variability')
wf.connect(selectfiles, 'preproc_epi_bp', variability, 'in_file')
wf.connect(variability, 'out_file_list', ds, 'variability.subjectSpace.@out_files')
# #fixme spline?
variabilty_MNIspace_3mm = MapNode(fsl.ApplyWarp(), iterfield=['in_file'], name='variabilty_MNIspace_3mm')
variabilty_MNIspace_3mm.inputs.interp = 'spline'
variabilty_MNIspace_3mm.plugin_args = {'submit_specs': 'request_memory = 4000'}
wf.connect(selectfiles_anat_templates, 'FSL_MNI_3mm_template', variabilty_MNIspace_3mm, 'ref_file')
wf.connect(selectfiles, 'epi_2_MNI_warp', variabilty_MNIspace_3mm, 'field_file')
wf.connect(variability, 'out_file_list', variabilty_MNIspace_3mm, 'in_file')
wf.connect(variabilty_MNIspace_3mm, 'out_file', ds, 'variability.MNI_3mm.@out_file')
# CALC Z SCORE
variabilty_MNIspace_3mm_Z = cpac_centrality_z_score.get_cent_zscore(wf_name='variabilty_MNIspace_3mm_Z')
wf.connect(variabilty_MNIspace_3mm, 'out_file', variabilty_MNIspace_3mm_Z, 'inputspec.input_file')
# wf.connect(selectfiles_anat_templates, 'GM_mask_MNI_3mm', variabilty_MNIspace_3mm_Z, 'inputspec.mask_file')
wf.connect(epi_mask_MNIspace_3mm, 'out_file', variabilty_MNIspace_3mm_Z, 'inputspec.mask_file')
wf.connect(variabilty_MNIspace_3mm_Z, 'outputspec.z_score_img', ds, 'variability.MNI_3mm_Z.@out_file')
# STANDARDIZE BY MEAN
variabilty_MNIspace_3mm_standardized_mean = calc_metrics_utils.standardize_divide_by_mean(
wf_name='variabilty_MNIspace_3mm_standardized_mean')
wf.connect(variabilty_MNIspace_3mm, 'out_file', variabilty_MNIspace_3mm_standardized_mean, 'inputnode.in_file')
wf.connect(epi_mask_MNIspace_3mm, 'out_file', variabilty_MNIspace_3mm_standardized_mean, 'inputnode.mask_file')
wf.connect(variabilty_MNIspace_3mm_standardized_mean, 'outputnode.out_file', ds,
'variability.MNI_3mm_standardized_mean.@out_file')
wf.write_graph(dotfilename=wf.name, graph2use='colored', format='pdf') # 'hierarchical')
wf.write_graph(dotfilename=wf.name, graph2use='orig', format='pdf')
wf.write_graph(dotfilename=wf.name, graph2use='flat', format='pdf')
if plugin_name == 'CondorDAGMan':
wf.run(plugin=plugin_name)
if plugin_name == 'MultiProc':
wf.run(plugin=plugin_name, plugin_args={'n_procs': use_n_procs})
def calc_local_metrics(brain_mask,
preprocessed_data_dir,
subject_id,
parcellations_dict,
bp_freq_list,
TR,
selectfiles_templates,
working_dir,
ds_dir,
use_n_procs,
plugin_name):
import os
from nipype import config
from nipype.pipeline.engine import Node, Workflow, MapNode
import nipype.interfaces.utility as util
import nipype.interfaces.io as nio
import nipype.interfaces.fsl as fsl
from nipype.interfaces.freesurfer.preprocess import MRIConvert
import CPAC.alff.alff as cpac_alff
import CPAC.reho.reho as cpac_reho
import CPAC.utils.utils as cpac_utils
import utils as calc_metrics_utils
from motion import calculate_FD_P, calculate_FD_J
#####################################
# GENERAL SETTINGS
#####################################
fsl.FSLCommand.set_default_output_type('NIFTI_GZ')
wf = Workflow(name='LeiCA_LIFE_metrics')
wf.base_dir = os.path.join(working_dir)
nipype_cfg = dict(logging=dict(workflow_level='DEBUG'), execution={'stop_on_first_crash': True,
'remove_unnecessary_outputs': True,
'job_finished_timeout': 15})
config.update_config(nipype_cfg)
wf.config['execution']['crashdump_dir'] = os.path.join(working_dir, 'crash')
ds = Node(nio.DataSink(base_directory=ds_dir), name='ds')
ds.inputs.regexp_substitutions = [('MNI_resampled_brain_mask_calc.nii.gz', 'falff.nii.gz'),
('residual_filtered_3dT.nii.gz', 'alff.nii.gz'),
('_parcellation_', ''),
('_bp_freqs_', 'bp_'),
]
#####################
# ITERATORS
#####################
# PARCELLATION ITERATOR
parcellation_infosource = Node(util.IdentityInterface(fields=['parcellation']), name='parcellation_infosource')
parcellation_infosource.iterables = ('parcellation', parcellations_dict.keys())
# BP FILTER ITERATOR
bp_filter_infosource = Node(util.IdentityInterface(fields=['bp_freqs']), name='bp_filter_infosource')
bp_filter_infosource.iterables = ('bp_freqs', bp_freq_list)
selectfiles = Node(nio.SelectFiles(selectfiles_templates,
base_directory=preprocessed_data_dir),
name='selectfiles')
selectfiles.inputs.subject_id = subject_id
# #####################
# # FIX TR IN HEADER
# #####################
# tr_msec = int(TR * 1000)
# tr_str = '-tr %s' % tr_msec
#
# fixed_tr_bp = Node(MRIConvert(out_type='niigz', args=tr_str), name='fixed_tr_bp')
# wf.connect(selectfiles, 'epi_MNI_bp', fixed_tr_bp, 'in_file')
#
# fixed_tr_fullspectrum = Node(MRIConvert(out_type='niigz', args=tr_str), name='fixed_tr_fullspectrum')
# wf.connect(selectfiles, 'epi_MNI_fullspectrum', fixed_tr_fullspectrum, 'in_file')
#####################
# calc FD
#####################
FD_P = Node(util.Function(input_names=['in_file'],
output_names=['FD_ts_file', 'mean_FD_file', 'max_FD_file'],
function=calculate_FD_P),
name='FD_P')
wf.connect(selectfiles, 'moco_parms_file', FD_P, 'in_file')
wf.connect(FD_P, 'FD_ts_file', ds, 'QC.@FD')
wf.connect(FD_P, 'mean_FD_file', ds, 'QC.@mean_FD')
wf.connect(FD_P, 'max_FD_file', ds, 'QC.@max_FD')
FD_J = Node(util.Function(input_names=['in_file'],
output_names=['FD_ts_file', 'mean_FD_file', 'max_FD_file'],
function=calculate_FD_J),
name='FD_J')
wf.connect(selectfiles, 'jenkinson_file', FD_J, 'in_file')
wf.connect(FD_J, 'FD_ts_file', ds, 'QC.@FD_J')
wf.connect(FD_J, 'mean_FD_file', ds, 'QC.@mean_FD_J')
wf.connect(FD_J, 'max_FD_file', ds, 'QC.@max_FD_J')
wf.connect(selectfiles, 'rest2anat_cost_file', ds, 'QC.@cost_file')
#####################
# CALCULATE METRICS
#####################
# f/ALFF
alff = cpac_alff.create_alff('alff')
alff.inputs.hp_input.hp = 0.01
alff.inputs.lp_input.lp = 0.1
alff.inputs.inputspec.rest_mask = brain_mask
#wf.connect(fixed_tr_fullspectrum, 'out_file', alff, 'inputspec.rest_res')
wf.connect(selectfiles, 'epi_MNI_fullspectrum', alff, 'inputspec.rest_res')
wf.connect(alff, 'outputspec.alff_img', ds, 'alff.@alff')
wf.connect(alff, 'outputspec.falff_img', ds, 'alff.@falff')
# f/ALFF_MNI Z-SCORE
alff_z = cpac_utils.get_zscore(input_name='alff', wf_name='alff_z')
alff_z.inputs.inputspec.mask_file = brain_mask
wf.connect(alff, 'outputspec.alff_img', alff_z, 'inputspec.input_file')
wf.connect(alff_z, 'outputspec.z_score_img', ds, 'alff_z.@alff')
falff_z = cpac_utils.get_zscore(input_name='falff', wf_name='falff_z')
falff_z.inputs.inputspec.mask_file = brain_mask
wf.connect(alff, 'outputspec.falff_img', falff_z, 'inputspec.input_file')
wf.connect(falff_z, 'outputspec.z_score_img', ds, 'alff_z.@falff')
# REHO
reho = cpac_reho.create_reho()
reho.inputs.inputspec.cluster_size = 27
reho.inputs.inputspec.rest_mask = brain_mask
#wf.connect(fixed_tr_bp, 'out_file', reho, 'inputspec.rest_res_filt')
wf.connect(selectfiles, 'epi_MNI_BP', reho, 'inputspec.rest_res_filt')
wf.connect(reho, 'outputspec.raw_reho_map', ds, 'reho.@reho')
# VARIABILITY SCORES
variability = Node(util.Function(input_names=['in_file'],
output_names=['out_file'],
function=calc_metrics_utils.calc_variability),
name='variability')
#wf.connect(fixed_tr_bp, 'out_file', variability, 'in_file')
wf.connect(selectfiles, 'epi_MNI_BP', variability, 'in_file')
wf.connect(variability, 'out_file', ds, 'variability.@SD')
variability_z = cpac_utils.get_zscore(input_name='ts_std', wf_name='variability_z')
variability_z.inputs.inputspec.mask_file = brain_mask
wf.connect(variability, 'out_file', variability_z, 'inputspec.input_file')
wf.connect(variability_z, 'outputspec.z_score_img', ds, 'variability_z.@variability_z')
##############
## CON MATS
##############
##############
## extract ts
##############
parcellated_ts = Node(
util.Function(input_names=['in_data', 'parcellation_name', 'parcellations_dict', 'bp_freqs', 'tr'],
output_names=['parcellation_time_series', 'parcellation_time_series_file', 'masker_file'],
function=calc_metrics_utils.extract_parcellation_time_series),
name='parcellated_ts')
parcellated_ts.inputs.parcellations_dict = parcellations_dict
parcellated_ts.inputs.tr = TR
#wf.connect(fixed_tr_fullspectrum, 'out_file', parcellated_ts, 'in_data')
wf.connect(selectfiles, 'epi_MNI_fullspectrum', parcellated_ts, 'in_data')
wf.connect(parcellation_infosource, 'parcellation', parcellated_ts, 'parcellation_name')
wf.connect(bp_filter_infosource, 'bp_freqs', parcellated_ts, 'bp_freqs')
##############
## get conmat
##############
con_mat = Node(util.Function(input_names=['in_data', 'extraction_method'],
output_names=['matrix', 'matrix_file'],
function=calc_metrics_utils.calculate_connectivity_matrix),
name='con_mat')
con_mat.inputs.extraction_method = 'correlation'
wf.connect(parcellated_ts, 'parcellation_time_series', con_mat, 'in_data')
##############
## ds
##############
wf.connect(parcellated_ts, 'parcellation_time_series_file', ds, 'con_mat.parcellated_time_series.@parc_ts')
wf.connect(parcellated_ts, 'masker_file', ds, 'con_mat.parcellated_time_series.@masker')
wf.connect(con_mat, 'matrix_file', ds, 'con_mat.matrix.@mat')
wf.write_graph(dotfilename=wf.name, graph2use='colored', format='pdf') # 'hierarchical')
wf.write_graph(dotfilename=wf.name, graph2use='orig', format='pdf')
wf.write_graph(dotfilename=wf.name, graph2use='flat', format='pdf')
if plugin_name == 'CondorDAGMan':
wf.run(plugin=plugin_name, plugin_args={'initial_specs': 'request_memory = 1500'})
if plugin_name == 'MultiProc':
wf.run(plugin=plugin_name, plugin_args={'n_procs': use_n_procs})
def calc_local_metrics(gm_wm_mask,
preprocessed_data_dir,
subject_id,
selectfiles_templates,
working_dir,
ds_dir,
use_n_procs,
plugin_name):
import os
from nipype import config
from nipype.pipeline.engine import Node, Workflow, MapNode
import nipype.interfaces.utility as util
import nipype.interfaces.io as nio
import nipype.interfaces.fsl as fsl
from nipype.interfaces.freesurfer.preprocess import MRIConvert
import CPAC.alff.alff as cpac_alff
import CPAC.reho.reho as cpac_reho
import CPAC.utils.utils as cpac_utils
import utils as calc_metrics_utils
from motion import calculate_FD_P, calculate_FD_J
#####################################
# GENERAL SETTINGS
#####################################
fsl.FSLCommand.set_default_output_type('NIFTI_GZ')
wf = Workflow(name='LeiCA_LIFE_metrics')
wf.base_dir = os.path.join(working_dir)
nipype_cfg = dict(logging=dict(workflow_level='DEBUG'), execution={'stop_on_first_crash': True,
'remove_unnecessary_outputs': True,
'job_finished_timeout': 15})
config.update_config(nipype_cfg)
wf.config['execution']['crashdump_dir'] = os.path.join(working_dir, 'crash')
ds = Node(nio.DataSink(base_directory=ds_dir), name='ds')
ds.inputs.regexp_substitutions = [('MNI_resampled_brain_mask_calc.nii.gz', 'falff.nii.gz'),
('residual_filtered_3dT.nii.gz', 'alff.nii.gz'),
('_parcellation_', ''),
('_bp_freqs_', 'bp_'),
]
#####################
# ITERATORS
#####################
selectfiles = Node(nio.SelectFiles(selectfiles_templates,
base_directory=preprocessed_data_dir),
name='selectfiles')
selectfiles.inputs.subject_id = subject_id
#####################
# CALCULATE METRICS
#####################
# f/ALFF_MNI Z-SCORE
alff_z = cpac_utils.get_zscore(input_name='alff', wf_name='alff_gm_wm_z')
alff_z.inputs.inputspec.mask_file = gm_wm_mask
wf.connect(selectfiles, 'alff', alff_z, 'inputspec.input_file')
wf.connect(alff_z, 'outputspec.z_score_img', ds, 'alff_gm_wm_z.@alff')
falff_z = cpac_utils.get_zscore(input_name='falff', wf_name='falff_gm_wm_z')
falff_z.inputs.inputspec.mask_file = gm_wm_mask
wf.connect(selectfiles, 'falff', falff_z, 'inputspec.input_file')
wf.connect(falff_z, 'outputspec.z_score_img', ds, 'alff_gm_wm_z.@falff')
# VARIABILITY SCORES
variability_z = cpac_utils.get_zscore(input_name='ts_std', wf_name='variability_gm_wm_z')
variability_z.inputs.inputspec.mask_file = gm_wm_mask
wf.connect(selectfiles, 'variability', variability_z, 'inputspec.input_file')
wf.connect(variability_z, 'outputspec.z_score_img', ds, 'variability_gm_wm_z.@variability_z')
##############
## ds
##############
# wf.connect(parcellated_ts, 'parcellation_time_series_file', ds, 'con_mat.parcellated_time_series.@parc_ts')
# wf.connect(parcellated_ts, 'masker_file', ds, 'con_mat.parcellated_time_series.@masker')
# wf.connect(con_mat, 'matrix_file', ds, 'con_mat.matrix.@mat')
wf.write_graph(dotfilename=wf.name, graph2use='colored', format='pdf') # 'hierarchical')
wf.write_graph(dotfilename=wf.name, graph2use='orig', format='pdf')
wf.write_graph(dotfilename=wf.name, graph2use='flat', format='pdf')
if plugin_name == 'CondorDAGMan':
wf.run(plugin=plugin_name, plugin_args={'initial_specs': 'request_memory = 1500'})
if plugin_name == 'MultiProc':
wf.run(plugin=plugin_name, plugin_args={'n_procs': use_n_procs})
def calc_local_metrics(brain_mask, preprocessed_data_dir, subject_id,
parcellations_dict, bp_freq_list, TR,
selectfiles_templates, working_dir, ds_dir, use_n_procs,
plugin_name):
import os
from nipype import config
from nipype.pipeline.engine import Node, Workflow, MapNode
import nipype.interfaces.utility as util
import nipype.interfaces.io as nio
import nipype.interfaces.fsl as fsl
from nipype.interfaces.freesurfer.preprocess import MRIConvert
import CPAC.alff.alff as cpac_alff
import CPAC.reho.reho as cpac_reho
import CPAC.utils.utils as cpac_utils
import utils as calc_metrics_utils
from motion import calculate_FD_P, calculate_FD_J
#####################################
# GENERAL SETTINGS
#####################################
fsl.FSLCommand.set_default_output_type('NIFTI_GZ')
wf = Workflow(name='LeiCA_LIFE_metrics')
wf.base_dir = os.path.join(working_dir)
nipype_cfg = dict(logging=dict(workflow_level='DEBUG'),
execution={
'stop_on_first_crash': True,
'remove_unnecessary_outputs': True,
'job_finished_timeout': 15
})
config.update_config(nipype_cfg)
wf.config['execution']['crashdump_dir'] = os.path.join(
working_dir, 'crash')
ds = Node(nio.DataSink(base_directory=ds_dir), name='ds')
ds.inputs.regexp_substitutions = [
('MNI_resampled_brain_mask_calc.nii.gz', 'falff.nii.gz'),
('residual_filtered_3dT.nii.gz', 'alff.nii.gz'),
('_parcellation_', ''),
('_bp_freqs_', 'bp_'),
]
#####################
# ITERATORS
#####################
# PARCELLATION ITERATOR
parcellation_infosource = Node(
util.IdentityInterface(fields=['parcellation']),
name='parcellation_infosource')
parcellation_infosource.iterables = ('parcellation',
parcellations_dict.keys())
# BP FILTER ITERATOR
bp_filter_infosource = Node(util.IdentityInterface(fields=['bp_freqs']),
name='bp_filter_infosource')
bp_filter_infosource.iterables = ('bp_freqs', bp_freq_list)
selectfiles = Node(nio.SelectFiles(selectfiles_templates,
base_directory=preprocessed_data_dir),
name='selectfiles')
selectfiles.inputs.subject_id = subject_id
# #####################
# # FIX TR IN HEADER
# #####################
# tr_msec = int(TR * 1000)
# tr_str = '-tr %s' % tr_msec
#
# fixed_tr_bp = Node(MRIConvert(out_type='niigz', args=tr_str), name='fixed_tr_bp')
# wf.connect(selectfiles, 'epi_MNI_bp', fixed_tr_bp, 'in_file')
#
# fixed_tr_fullspectrum = Node(MRIConvert(out_type='niigz', args=tr_str), name='fixed_tr_fullspectrum')
# wf.connect(selectfiles, 'epi_MNI_fullspectrum', fixed_tr_fullspectrum, 'in_file')
#####################
# calc FD
#####################
FD_P = Node(util.Function(
input_names=['in_file'],
output_names=['FD_ts_file', 'mean_FD_file', 'max_FD_file'],
function=calculate_FD_P),
name='FD_P')
wf.connect(selectfiles, 'moco_parms_file', FD_P, 'in_file')
wf.connect(FD_P, 'FD_ts_file', ds, 'QC.@FD')
wf.connect(FD_P, 'mean_FD_file', ds, 'QC.@mean_FD')
wf.connect(FD_P, 'max_FD_file', ds, 'QC.@max_FD')
FD_J = Node(util.Function(
input_names=['in_file'],
output_names=['FD_ts_file', 'mean_FD_file', 'max_FD_file'],
function=calculate_FD_J),
name='FD_J')
wf.connect(selectfiles, 'jenkinson_file', FD_J, 'in_file')
wf.connect(FD_J, 'FD_ts_file', ds, 'QC.@FD_J')
wf.connect(FD_J, 'mean_FD_file', ds, 'QC.@mean_FD_J')
wf.connect(FD_J, 'max_FD_file', ds, 'QC.@max_FD_J')
wf.connect(selectfiles, 'rest2anat_cost_file', ds, 'QC.@cost_file')
#####################
# CALCULATE METRICS
#####################
# f/ALFF
alff = cpac_alff.create_alff('alff')
alff.inputs.hp_input.hp = 0.01
alff.inputs.lp_input.lp = 0.1
alff.inputs.inputspec.rest_mask = brain_mask
#wf.connect(fixed_tr_fullspectrum, 'out_file', alff, 'inputspec.rest_res')
wf.connect(selectfiles, 'epi_MNI_fullspectrum', alff, 'inputspec.rest_res')
wf.connect(alff, 'outputspec.alff_img', ds, 'alff.@alff')
wf.connect(alff, 'outputspec.falff_img', ds, 'alff.@falff')
# f/ALFF_MNI Z-SCORE
alff_z = cpac_utils.get_zscore(input_name='alff', wf_name='alff_z')
alff_z.inputs.inputspec.mask_file = brain_mask
wf.connect(alff, 'outputspec.alff_img', alff_z, 'inputspec.input_file')
wf.connect(alff_z, 'outputspec.z_score_img', ds, 'alff_z.@alff')
falff_z = cpac_utils.get_zscore(input_name='falff', wf_name='falff_z')
falff_z.inputs.inputspec.mask_file = brain_mask
wf.connect(alff, 'outputspec.falff_img', falff_z, 'inputspec.input_file')
wf.connect(falff_z, 'outputspec.z_score_img', ds, 'alff_z.@falff')
# REHO
reho = cpac_reho.create_reho()
reho.inputs.inputspec.cluster_size = 27
reho.inputs.inputspec.rest_mask = brain_mask
#wf.connect(fixed_tr_bp, 'out_file', reho, 'inputspec.rest_res_filt')
wf.connect(selectfiles, 'epi_MNI_BP', reho, 'inputspec.rest_res_filt')
wf.connect(reho, 'outputspec.raw_reho_map', ds, 'reho.@reho')
# VARIABILITY SCORES
variability = Node(util.Function(
input_names=['in_file'],
output_names=['out_file'],
function=calc_metrics_utils.calc_variability),
name='variability')
#wf.connect(fixed_tr_bp, 'out_file', variability, 'in_file')
wf.connect(selectfiles, 'epi_MNI_BP', variability, 'in_file')
wf.connect(variability, 'out_file', ds, 'variability.@SD')
variability_z = cpac_utils.get_zscore(input_name='ts_std',
wf_name='variability_z')
variability_z.inputs.inputspec.mask_file = brain_mask
wf.connect(variability, 'out_file', variability_z, 'inputspec.input_file')
wf.connect(variability_z, 'outputspec.z_score_img', ds,
'variability_z.@variability_z')
##############
## CON MATS
##############
##############
## extract ts
##############
parcellated_ts = Node(util.Function(
input_names=[
'in_data', 'parcellation_name', 'parcellations_dict', 'bp_freqs',
'tr'
],
output_names=[
'parcellation_time_series', 'parcellation_time_series_file',
'masker_file'
],
function=calc_metrics_utils.extract_parcellation_time_series),
name='parcellated_ts')
parcellated_ts.inputs.parcellations_dict = parcellations_dict
parcellated_ts.inputs.tr = TR
#wf.connect(fixed_tr_fullspectrum, 'out_file', parcellated_ts, 'in_data')
wf.connect(selectfiles, 'epi_MNI_fullspectrum', parcellated_ts, 'in_data')
wf.connect(parcellation_infosource, 'parcellation', parcellated_ts,
'parcellation_name')
wf.connect(bp_filter_infosource, 'bp_freqs', parcellated_ts, 'bp_freqs')
##############
## get conmat
##############
con_mat = Node(util.Function(
input_names=['in_data', 'extraction_method'],
output_names=['matrix', 'matrix_file'],
function=calc_metrics_utils.calculate_connectivity_matrix),
name='con_mat')
con_mat.inputs.extraction_method = 'correlation'
wf.connect(parcellated_ts, 'parcellation_time_series', con_mat, 'in_data')
##############
## ds
##############
wf.connect(parcellated_ts, 'parcellation_time_series_file', ds,
'con_mat.parcellated_time_series.@parc_ts')
wf.connect(parcellated_ts, 'masker_file', ds,
'con_mat.parcellated_time_series.@masker')
wf.connect(con_mat, 'matrix_file', ds, 'con_mat.matrix.@mat')
wf.write_graph(dotfilename=wf.name, graph2use='colored',
format='pdf') # 'hierarchical')
wf.write_graph(dotfilename=wf.name, graph2use='orig', format='pdf')
wf.write_graph(dotfilename=wf.name, graph2use='flat', format='pdf')
if plugin_name == 'CondorDAGMan':
wf.run(plugin=plugin_name,
plugin_args={'initial_specs': 'request_memory = 1500'})
if plugin_name == 'MultiProc':
wf.run(plugin=plugin_name, plugin_args={'n_procs': use_n_procs})
def calc_local_metrics(gm_wm_mask, preprocessed_data_dir, subject_id,
selectfiles_templates, working_dir, ds_dir, use_n_procs,
plugin_name):
import os
from nipype import config
from nipype.pipeline.engine import Node, Workflow, MapNode
import nipype.interfaces.utility as util
import nipype.interfaces.io as nio
import nipype.interfaces.fsl as fsl
from nipype.interfaces.freesurfer.preprocess import MRIConvert
import CPAC.alff.alff as cpac_alff
import CPAC.reho.reho as cpac_reho
import CPAC.utils.utils as cpac_utils
import utils as calc_metrics_utils
from motion import calculate_FD_P, calculate_FD_J
#####################################
# GENERAL SETTINGS
#####################################
fsl.FSLCommand.set_default_output_type('NIFTI_GZ')
wf = Workflow(name='LeiCA_LIFE_metrics')
wf.base_dir = os.path.join(working_dir)
nipype_cfg = dict(logging=dict(workflow_level='DEBUG'),
execution={
'stop_on_first_crash': True,
'remove_unnecessary_outputs': True,
'job_finished_timeout': 15
})
config.update_config(nipype_cfg)
wf.config['execution']['crashdump_dir'] = os.path.join(
working_dir, 'crash')
ds = Node(nio.DataSink(base_directory=ds_dir), name='ds')
ds.inputs.regexp_substitutions = [
('MNI_resampled_brain_mask_calc.nii.gz', 'falff.nii.gz'),
('residual_filtered_3dT.nii.gz', 'alff.nii.gz'),
('_parcellation_', ''),
('_bp_freqs_', 'bp_'),
]
#####################
# ITERATORS
#####################
selectfiles = Node(nio.SelectFiles(selectfiles_templates,
base_directory=preprocessed_data_dir),
name='selectfiles')
selectfiles.inputs.subject_id = subject_id
#####################
# CALCULATE METRICS
#####################
# f/ALFF_MNI Z-SCORE
alff_z = cpac_utils.get_zscore(input_name='alff', wf_name='alff_gm_wm_z')
alff_z.inputs.inputspec.mask_file = gm_wm_mask
wf.connect(selectfiles, 'alff', alff_z, 'inputspec.input_file')
wf.connect(alff_z, 'outputspec.z_score_img', ds, 'alff_gm_wm_z.@alff')
falff_z = cpac_utils.get_zscore(input_name='falff',
wf_name='falff_gm_wm_z')
falff_z.inputs.inputspec.mask_file = gm_wm_mask
wf.connect(selectfiles, 'falff', falff_z, 'inputspec.input_file')
wf.connect(falff_z, 'outputspec.z_score_img', ds, 'alff_gm_wm_z.@falff')
# VARIABILITY SCORES
variability_z = cpac_utils.get_zscore(input_name='ts_std',
wf_name='variability_gm_wm_z')
variability_z.inputs.inputspec.mask_file = gm_wm_mask
wf.connect(selectfiles, 'variability', variability_z,
'inputspec.input_file')
wf.connect(variability_z, 'outputspec.z_score_img', ds,
'variability_gm_wm_z.@variability_z')
##############
## ds
##############
# wf.connect(parcellated_ts, 'parcellation_time_series_file', ds, 'con_mat.parcellated_time_series.@parc_ts')
# wf.connect(parcellated_ts, 'masker_file', ds, 'con_mat.parcellated_time_series.@masker')
# wf.connect(con_mat, 'matrix_file', ds, 'con_mat.matrix.@mat')
wf.write_graph(dotfilename=wf.name, graph2use='colored',
format='pdf') # 'hierarchical')
wf.write_graph(dotfilename=wf.name, graph2use='orig', format='pdf')
wf.write_graph(dotfilename=wf.name, graph2use='flat', format='pdf')
if plugin_name == 'CondorDAGMan':
wf.run(plugin=plugin_name,
plugin_args={'initial_specs': 'request_memory = 1500'})
if plugin_name == 'MultiProc':
wf.run(plugin=plugin_name, plugin_args={'n_procs': use_n_procs})
