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})