def create_converter_structural_pipeline(working_dir, ds_dir, name="converter_struct"): # initiate workflow converter_wf = Workflow(name=name) converter_wf.base_dir = os.path.join(working_dir, "LeiCA_resting") # set fsl output fsl.FSLCommand.set_default_output_type("NIFTI_GZ") # inputnode inputnode = Node(util.IdentityInterface(fields=["t1w_dicom"]), name="inputnode") outputnode = Node(util.IdentityInterface(fields=["t1w"]), name="outputnode") niftisink = Node(nio.DataSink(), name="niftisink") niftisink.inputs.base_directory = os.path.join(ds_dir, "raw_niftis") # convert to nifti # todo check if geometry bugs attac. use dcm2nii? converter_t1w = Node(DcmStack(embed_meta=True), name="converter_t1w") converter_t1w.plugin_args = {"submit_specs": "request_memory = 2000"} converter_t1w.inputs.out_format = "t1w" converter_wf.connect(inputnode, "t1w_dicom", converter_t1w, "dicom_files") # reorient to standard orientation reor_2_std = Node(fsl.Reorient2Std(), name="reor_2_std") converter_wf.connect(converter_t1w, "out_file", reor_2_std, "in_file") converter_wf.connect(reor_2_std, "out_file", outputnode, "t1w") # save original niftis converter_wf.connect(reor_2_std, "out_file", niftisink, "sMRI") converter_wf.write_graph(dotfilename="converter_struct", graph2use="flat", format="pdf") return converter_wf
def create_structural(subject, working_dir, data_dir, freesurfer_dir, out_dir, standard_brain): # main workflow struct_preproc = Workflow(name='anat_preproc') struct_preproc.base_dir = working_dir struct_preproc.config['execution'][ 'crashdump_dir'] = struct_preproc.base_dir + "/crash_files" # select files #templates={'anat': '3T/nifti/MPRAGEADNI32Ch.nii.gz'} #selectfiles = Node(nio.SelectFiles(templates, base_directory=data_dir), name="selectfiles") # workflow to run freesurfer reconall reconall = create_reconall_pipeline() reconall.inputs.inputnode.fs_subjects_dir = freesurfer_dir reconall.inputs.inputnode.fs_subject_id = subject # workflow to get brain, head and wmseg from freesurfer and convert to nifti mgzconvert = create_mgzconvert_pipeline() mgzconvert.inputs.inputnode.fs_subjects_dir = freesurfer_dir mgzconvert.inputs.inputnode.fs_subject_id = subject normalize = create_normalize_pipeline() normalize.inputs.inputnode.standard = standard_brain # sink to store files sink = Node(nio.DataSink(base_directory=out_dir, parameterization=False, substitutions=[('transform_Warped', 'T1_brain2mni')]), name='sink') # connections struct_preproc.connect([ #(selectfiles, sink, [('anat', 'outputnode.test')]), #(selectfiles, reconall, [('anat', 'inputnode.anat')]), #(reconall, mgzconvert, [('outputnode.fs_subject_id', 'inputnode.fs_subject_id'), # ('outputnode.fs_subjects_dir', 'inputnode.fs_subjects_dir')]), #for second round of structural don't redo FREESURFER (mgzconvert, normalize, [('outputnode.anat_brain', 'inputnode.anat')]), (mgzconvert, sink, [('outputnode.anat_head', '@head')]), (mgzconvert, sink, [('outputnode.anat_brain', '@brain')]), (mgzconvert, sink, [('outputnode.anat_brain_mask', '@mask')]), (mgzconvert, sink, [('outputnode.wmedge', '@wmedge')]), (normalize, sink, [('outputnode.anat2std', '@anat2std'), ('outputnode.anat2std_transforms', 'transforms2mni.@anat2std_transforms'), ('outputnode.std2anat_transforms', 'transforms2mni.@std2anat_transforms')]) ]) struct_preproc.write_graph(dotfilename='struct_preproc.dot', graph2use='colored', format='pdf', simple_form=True) # struct_preproc.run() struct_preproc.run( ) #, plugin_args = {'initial_specs': 'request_memory = 1500'}plugin='CondorDAGMan'
def create_converter_diffusion_pipeline(working_dir, ds_dir, name='converter_diffusion'): # initiate workflow converter_wf = Workflow(name=name) converter_wf.base_dir = os.path.join(working_dir, 'LeiCA_resting') # set fsl output fsl.FSLCommand.set_default_output_type('NIFTI_GZ') # inputnode inputnode = Node(util.IdentityInterface(fields=['dMRI_dicom']), name='inputnode') outputnode = Node(util.IdentityInterface(fields=['dMRI']), name='outputnode') niftisink = Node(nio.DataSink(), name='niftisink') niftisink.inputs.base_directory = os.path.join(ds_dir, 'raw_niftis') ####### converter_dMRI = Node(Dcm2nii(), name="converter_dMRI") converter_dMRI.inputs.gzip_output = True converter_dMRI.inputs.nii_output = True converter_dMRI.inputs.anonymize = False converter_dMRI.plugin_args = {'submit_specs': 'request_memory = 2000'} converter_wf.connect(inputnode, 'dMRI_dicom', converter_dMRI, 'source_names') dMRI_rename = Node(util.Rename(format_string='DTI_mx_137.nii.gz'), name='dMRI_rename') converter_wf.connect(converter_dMRI, 'converted_files', dMRI_rename, 'in_file') bvecs_rename = Node(util.Rename(format_string='DTI_mx_137.bvecs'), name='bvecs_rename') converter_wf.connect(converter_dMRI, 'bvecs', bvecs_rename, 'in_file') bvals_rename = Node(util.Rename(format_string='DTI_mx_137.bvals'), name='bvals_rename') converter_wf.connect(converter_dMRI, "bvals", bvals_rename, 'in_file') # reorient to standard orientation reor_2_std = Node(fsl.Reorient2Std(), name='reor_2_std') converter_wf.connect(dMRI_rename, 'out_file', reor_2_std, 'in_file') converter_wf.connect(reor_2_std, 'out_file', outputnode, 'dMRI') # save original niftis converter_wf.connect(reor_2_std, 'out_file', niftisink, 'dMRI.@dwi') converter_wf.connect(bvals_rename, 'out_file', niftisink, 'dMRI.@bvals') converter_wf.connect(bvecs_rename, 'out_file', niftisink, 'dMRI.@bvecs') converter_wf.write_graph(dotfilename='converter_struct', graph2use='flat', format='pdf') return converter_wf
def ants_ct_wf(subjects_id, preprocessed_data_dir, working_dir, ds_dir, template_dir, 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 from nipype.interfaces.freesurfer.utils import ImageInfo ##################################### # GENERAL SETTINGS ##################################### wf = Workflow(name='ants_ct') 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') ##################################### # GET DATA ##################################### # GET SUBJECT SPECIFIC STRUCTURAL DATA in_data_templates = { 't1w': '{subject_id}/raw_niftis/sMRI/t1w_reoriented.nii.gz', } in_data = Node(nio.SelectFiles(in_data_templates, base_directory=preprocessed_data_dir), name="in_data") in_data.inputs.subject_id = subjects_id # GET NKI ANTs templates ants_templates_templates = { 'brain_template': 'NKI/T_template.nii.gz', 'brain_probability_mask': 'NKI/T_templateProbabilityMask.nii.gz', 'segmentation_priors': 'NKI/Priors/*.nii.gz', 't1_registration_template': 'NKI/T_template_BrainCerebellum.nii.gz' } ants_templates = Node(nio.SelectFiles(ants_templates_templates, base_directory=template_dir), name="ants_templates")
def ants_ct_wf(subjects_id, preprocessed_data_dir, working_dir, ds_dir, template_dir, 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 from nipype.interfaces.freesurfer.utils import ImageInfo ##################################### # GENERAL SETTINGS ##################################### wf = Workflow(name='ants_ct') 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') ##################################### # GET DATA ##################################### # GET SUBJECT SPECIFIC STRUCTURAL DATA in_data_templates = { 't1w': '{subject_id}/raw_niftis/sMRI/t1w_reoriented.nii.gz', } in_data = Node(nio.SelectFiles(in_data_templates, base_directory=preprocessed_data_dir), name="in_data") in_data.inputs.subject_id = subjects_id # GET NKI ANTs templates ants_templates_templates = { 'brain_template': 'NKI/T_template.nii.gz', 'brain_probability_mask': 'NKI/T_templateProbabilityMask.nii.gz', 'segmentation_priors': 'NKI/Priors/*.nii.gz', 't1_registration_template': 'NKI/T_template_BrainCerebellum.nii.gz' } ants_templates = Node(nio.SelectFiles(ants_templates_templates, base_directory=template_dir), name="ants_templates")
def create_conversion(name, subject, scans, working_dir, out_dir, folder, xnat_server, xnat_user, xnat_pass, project_id, exp_id): convert = Workflow(name=name) convert.base_dir = working_dir convert.config['execution'][ 'crashdump_dir'] = convert.base_dir + "/crash_files" # infosource to iterate over scans scan_infosource = Node( util.IdentityInterface(fields=['scan_key', 'scan_val']), name='scan_infosource') scan_infosource.iterables = [('scan_key', scans.keys()), ('scan_val', scans.values())] scan_infosource.synchronize = True # xnat source xnatsource = Node(nio.XNATSource( infields=['project_id', 'subject_id', 'exp_id', 'scan_id'], outfields=['dicom'], server=xnat_server, user=xnat_user, pwd=xnat_pass, cache_dir=working_dir), name='xnatsource') xnatsource.inputs.query_template = ( '/projects/%s/subjects/%s/experiments/%s/scans/%d/resources/DICOM/files' ) #files') xnatsource.inputs.query_template_args['dicom'] = [[ 'project_id', 'subject_id', 'exp_id', 'scan_id' ]] xnatsource.inputs.project_id = project_id xnatsource.inputs.subject_id = subject xnatsource.inputs.exp_id = exp_id convert.connect([(scan_infosource, xnatsource, [('scan_val', 'scan_id')])]) # workflow to convert dicoms dcmconvert = create_dcmconvert_pipeline() convert.connect([ (scan_infosource, dcmconvert, [('scan_key', 'inputnode.filename')]), (xnatsource, dcmconvert, [('dicom', 'inputnode.dicoms')]) ]) # xnat sink sink = Node(nio.DataSink(base_directory=out_dir, parameterization=False), name='sink') convert.connect([(dcmconvert, sink, [('outputnode.nifti', folder)])]) convert.run()
def create_conversion( name, subject, scans, working_dir, out_dir, folder, xnat_server, xnat_user, xnat_pass, project_id, exp_id ): convert = Workflow(name=name) convert.base_dir = working_dir convert.config["execution"]["crashdump_dir"] = convert.base_dir + "/crash_files" # infosource to iterate over scans scan_infosource = Node(util.IdentityInterface(fields=["scan_key", "scan_val"]), name="scan_infosource") scan_infosource.iterables = [("scan_key", scans.keys()), ("scan_val", scans.values())] scan_infosource.synchronize = True # xnat source xnatsource = Node( nio.XNATSource( infields=["project_id", "subject_id", "exp_id", "scan_id"], outfields=["dicom"], server=xnat_server, user=xnat_user, pwd=xnat_pass, cache_dir=working_dir, ), name="xnatsource", ) xnatsource.inputs.query_template = ( "/projects/%s/subjects/%s/experiments/%s/scans/%d/resources/DICOM/files" ) # files') xnatsource.inputs.query_template_args["dicom"] = [["project_id", "subject_id", "exp_id", "scan_id"]] xnatsource.inputs.project_id = project_id xnatsource.inputs.subject_id = subject xnatsource.inputs.exp_id = exp_id convert.connect([(scan_infosource, xnatsource, [("scan_val", "scan_id")])]) # workflow to convert dicoms dcmconvert = create_dcmconvert_pipeline() convert.connect( [ (scan_infosource, dcmconvert, [("scan_key", "inputnode.filename")]), (xnatsource, dcmconvert, [("dicom", "inputnode.dicoms")]), ] ) # xnat sink sink = Node(nio.DataSink(base_directory=out_dir, parameterization=False), name="sink") convert.connect([(dcmconvert, sink, [("outputnode.nifti", folder)])]) convert.run()
def create_workflow(xfm_dir, xfm_pattern, atlas_dir, atlas_pattern, source_dir, source_pattern, work_dir, out_dir, name="new_data_to_atlas_space"): wf = Workflow(name=name) wf.base_dir = os.path.join(work_dir) datasource_source = Node(interface=DataGrabber(sort_filelist=True), name='datasource_source') datasource_source.inputs.base_directory = os.path.abspath(source_dir) datasource_source.inputs.template = source_pattern datasource_xfm = Node(interface=DataGrabber(sort_filelist=True), name='datasource_xfm') datasource_xfm.inputs.base_directory = os.path.abspath(xfm_dir) datasource_xfm.inputs.template = xfm_pattern datasource_atlas = Node(interface=DataGrabber(sort_filelist=True), name='datasource_atlas') datasource_atlas.inputs.base_directory = os.path.abspath(atlas_dir) datasource_atlas.inputs.template = atlas_pattern resample = MapNode(interface=Resample(sinc_interpolation=True), name='resample_', iterfield=['input_file', 'transformation']) wf.connect(datasource_source, 'outfiles', resample, 'input_file') wf.connect(datasource_xfm, 'outfiles', resample, 'transformation') wf.connect(datasource_atlas, 'outfiles', resample, 'like') bigaverage = Node(interface=BigAverage(output_float=True, robust=False), name='bigaverage', iterfield=['input_file']) wf.connect(resample, 'output_file', bigaverage, 'input_files') datasink = Node(interface=DataSink(base_directory=out_dir, container=out_dir), name='datasink') wf.connect([(bigaverage, datasink, [('output_file', 'average')])]) wf.connect([(resample, datasink, [('output_file', 'atlas_space')])]) wf.connect([(datasource_xfm, datasink, [('outfiles', 'transforms')])]) return wf
def prepare_indT_cs(): outdirs = [ '/home/peter/Desktop/prepare/rest/output/sec_level/two_sample_con_vs_stroke/alff_analysis/', '/home/peter/Desktop/prepare/rest/output/sec_level/two_sample_con_vs_stroke/falff_analysis/' ] for n, outdir in enumerate(outdirs): stroke_hdir = '/home/peter/Desktop/prepare/rest/output/' all_stroke_files = glob.glob(stroke_hdir + '/*/f_alff/' + maps[n]) stroke_files = [x for x in all_stroke_files if '12months' not in x] healthy_hdir = '/home/peter/Desktop/Connect/rest/output/' all_healthy_files = glob.glob(healthy_hdir + '/D_H*/f_alff/' + maps[n]) healthy_files = [x for x in all_healthy_files if 'P2' not in x] ttest = Node(TwoSampleTTestDesign(), name='TwoSampleT') ttest.inputs.group1_files = healthy_files ttest.inputs.group2_files = stroke_files modelEst = Node(EstimateModel(), name='EstimateModel') modelEst.inputs.estimation_method = {'Classical': 1} conEst = Node(EstimateContrast(), name='EstimateContrasts') con_1 = ('Controls', 'T', ['Group_{1}', 'Group_{2}'], [1.0, 0.0]) con_2 = ('Patients', 'T', ['Group_{1}', 'Group_{2}'], [0.0, 1.0]) con_3 = ('Controls>Patients', 'T', ['Group_{1}', 'Group_{2}'], [1.0, -1.0]) con_4 = ('Patients>Controls', 'T', ['Group_{1}', 'Group_{2}'], [-1.0, 1.0]) contrasts = [con_1, con_2, con_3, con_4] conEst.inputs.contrasts = contrasts conEst.inputs.group_contrast = True l2analysis = Workflow(name='l2analysis') l2analysis.base_dir = outdir l2analysis.connect([ (ttest, modelEst, [('spm_mat_file', 'spm_mat_file')]), (modelEst, conEst, [('spm_mat_file', 'spm_mat_file'), ('beta_images', 'beta_images'), ('residual_image', 'residual_image')]), ]) l2analysis.write_graph(graph2use='colored') l2analysis.run('MultiProc', plugin_args={'n_procs': 1})
def results(cenc_participant_id, cenc_participant_dir, cenc_freesurfer_dir,cenc_results_dir, verbose): util.mkcd_dir( [ cenc_results_dir ], True) files_to_convert = [ os.path.join( cenc_freesurfer_dir, cenc_participant_id, 'mri', 'nu.mgz'), os.path.join( cenc_freesurfer_dir, cenc_participant_id, 'mri', 'aseg.mgz'), os.path.join( cenc_freesurfer_dir, cenc_participant_id, 'mri', 'brainmask.mgz'), os.path.join( cenc_freesurfer_dir, cenc_participant_id, 'mri', 'aparc.a2009s+aseg.mgz'), os.path.join( cenc_freesurfer_dir, cenc_participant_id, 'mri', 'wmparc.mgz') ] # Check if files exist print files_to_convert if util.check_files(files_to_convert, True) == False: sys.exit() # Create link to directory freesurfer_results_dir = os.path.abspath(os.path.join( cenc_participant_dir, 'freesurfer','results')) if not os.path.exists(freesurfer_results_dir): util.force_symbolic_link( os.path.join( cenc_freesurfer_dir, cenc_participant_id ), freesurfer_results_dir) # TODO use input node to run this instead of a loop mc = Node( fs.MRIConvert( out_type = 'niigz' ), name="mri_convert" ) mc.iterables = ( "in_file", files_to_convert ) reorient = Node( fsl.Reorient2Std(), name="reorient" ) workflow_convert = Workflow(name='cenc_freesurfer_nipype_workflow') workflow_convert.base_dir = cenc_results_dir workflow_convert.connect( [ (mc, reorient, [('out_file', 'in_file')] )] ) workflow_convert.run() # Create final brain mask. This takes forever. Speeding it up would be helpful. cenc.create_mask( os.path.join( cenc_results_dir, 'brainmask.nii.gz'), os.path.join( cenc_results_dir, 'aparc.a2009s+aseg.nii.gz'), os.path.join( cenc_results_dir, 'mask.nii.gz') )
def create_converter_diffusion_pipeline(working_dir, ds_dir, name="converter_diffusion"): # initiate workflow converter_wf = Workflow(name=name) converter_wf.base_dir = os.path.join(working_dir, "LeiCA_resting") # set fsl output fsl.FSLCommand.set_default_output_type("NIFTI_GZ") # inputnode inputnode = Node(util.IdentityInterface(fields=["dMRI_dicom"]), name="inputnode") outputnode = Node(util.IdentityInterface(fields=["dMRI"]), name="outputnode") niftisink = Node(nio.DataSink(), name="niftisink") niftisink.inputs.base_directory = os.path.join(ds_dir, "raw_niftis") ####### converter_dMRI = Node(Dcm2nii(), name="converter_dMRI") converter_dMRI.inputs.gzip_output = True converter_dMRI.inputs.nii_output = True converter_dMRI.inputs.anonymize = False converter_dMRI.plugin_args = {"submit_specs": "request_memory = 2000"} converter_wf.connect(inputnode, "dMRI_dicom", converter_dMRI, "source_names") dMRI_rename = Node(util.Rename(format_string="DTI_mx_137.nii.gz"), name="dMRI_rename") converter_wf.connect(converter_dMRI, "converted_files", dMRI_rename, "in_file") bvecs_rename = Node(util.Rename(format_string="DTI_mx_137.bvecs"), name="bvecs_rename") converter_wf.connect(converter_dMRI, "bvecs", bvecs_rename, "in_file") bvals_rename = Node(util.Rename(format_string="DTI_mx_137.bvals"), name="bvals_rename") converter_wf.connect(converter_dMRI, "bvals", bvals_rename, "in_file") # reorient to standard orientation reor_2_std = Node(fsl.Reorient2Std(), name="reor_2_std") converter_wf.connect(dMRI_rename, "out_file", reor_2_std, "in_file") converter_wf.connect(reor_2_std, "out_file", outputnode, "dMRI") # save original niftis converter_wf.connect(reor_2_std, "out_file", niftisink, "dMRI.@dwi") converter_wf.connect(bvals_rename, "out_file", niftisink, "dMRI.@bvals") converter_wf.connect(bvecs_rename, "out_file", niftisink, "dMRI.@bvecs") converter_wf.write_graph(dotfilename="converter_struct", graph2use="flat", format="pdf") return converter_wf
def index_lesion_workflow(msid, mseid, lesion): import nipype.interfaces.ants as ants from nipype.pipeline.engine import Node, Workflow, MapNode from nipype.interfaces.io import DataSink, DataGrabber from nipype.interfaces.utility import IdentityInterface, Function import nipype.interfaces.fsl as fsl from nipype.utils.filemanip import load_json working_directory = '/working/henry_temp/keshavan/' output_directory = os.path.split(lesion)[0] register = Workflow(name="indexed_lesion_{0}_{1}".format(msid, mseid)) register.base_dir = working_directory inputnode = Node(IdentityInterface(fields=["lesion"]), name="inputspec") inputnode.inputs.lesion = lesion bin_math = Node(fsl.BinaryMaths(), name="Convert_to_binary") bin_math.inputs.operand_value = 1 bin_math.inputs.operation = 'min' register.connect(inputnode, "lesion", bin_math, "in_file") cluster_lesion = Node(fsl.Cluster(threshold=0.0001, out_index_file=True, use_mm=True), name="cluster_lesion") sinker = Node(DataSink(), name="sinker") sinker.inputs.base_directory = output_directory sinker.inputs.container = '.' sinker.inputs.substitutions = [('_maths', '')] register.connect(bin_math, "out_file", cluster_lesion, "in_file") register.connect(cluster_lesion, "index_file", sinker, "@cluster") from nipype.interfaces.freesurfer import SegStats segstats_lesion = Node(SegStats(), name="segstats_lesion") register.connect(cluster_lesion, "index_file", segstats_lesion, "segmentation_file") register.connect(segstats_lesion, "summary_file", sinker, "@summaryfile") register.write_graph(graph2use='orig') register.config["Execution"] = { "keep_inputs": True, "remove_unnecessary_outputs": False } return register
def init_mriqc_wf(): """Create a multi-subject MRIQC workflow.""" from .. import config workflow = Workflow(name="mriqc_wf") workflow.base_dir = config.execution.work_dir if "bold" in config.workflow.inputs: workflow.add_nodes([fmri_qc_workflow()]) if set(("T1w", "T2w")).intersection( config.workflow.inputs.keys() ): workflow.add_nodes([anat_qc_workflow()]) if not workflow._get_all_nodes(): return None return workflow
def create_converter_structural_pipeline(working_dir, ds_dir, name='converter_struct'): # initiate workflow converter_wf = Workflow(name=name) converter_wf.base_dir = os.path.join(working_dir, 'LeiCA_resting') # set fsl output fsl.FSLCommand.set_default_output_type('NIFTI_GZ') # inputnode inputnode = Node(util.IdentityInterface(fields=['t1w_dicom']), name='inputnode') outputnode = Node(util.IdentityInterface(fields=['t1w']), name='outputnode') niftisink = Node(nio.DataSink(), name='niftisink') niftisink.inputs.base_directory = os.path.join(ds_dir, 'raw_niftis') # convert to nifti # todo check if geometry bugs attac. use dcm2nii? converter_t1w = Node(DcmStack(embed_meta=True), name='converter_t1w') converter_t1w.plugin_args = {'submit_specs': 'request_memory = 2000'} converter_t1w.inputs.out_format = 't1w' converter_wf.connect(inputnode, 't1w_dicom', converter_t1w, 'dicom_files') # reorient to standard orientation reor_2_std = Node(fsl.Reorient2Std(), name='reor_2_std') converter_wf.connect(converter_t1w, 'out_file', reor_2_std, 'in_file') converter_wf.connect(reor_2_std, 'out_file', outputnode, 't1w') # save original niftis converter_wf.connect(reor_2_std, 'out_file', niftisink, 'sMRI') converter_wf.write_graph(dotfilename='converter_struct', graph2use='flat', format='pdf') return converter_wf
def init_mriqc_wf(): """Create a multi-subject MRIQC workflow.""" from mriqc import config # Create parent workflow workflow = Workflow(name="mriqc_wf") workflow.base_dir = config.execution.work_dir # Create fMRI QC workflow if FMRI_KEY in config.workflow.inputs: workflow.add_nodes([fmri_qc_workflow()]) # Create sMRI QC workflow input_keys = config.workflow.inputs.keys() anatomical_flag = any(key in input_keys for key in ANATOMICAL_KEYS) if anatomical_flag: workflow.add_nodes([anat_qc_workflow()]) # Return non-empty workflow, else None if workflow._get_all_nodes(): return workflow
def create_structural(subject, working_dir, data_dir, freesurfer_dir, out_dir, standard_brain): # main workflow struct_preproc = Workflow(name='anat_preproc') struct_preproc.base_dir = working_dir struct_preproc.config['execution']['crashdump_dir'] = struct_preproc.base_dir + "/crash_files" # workflow to get brain, head and wmseg from freesurfer and convert to nifti mgzconvert = create_mgzconvert_pipeline() mgzconvert.inputs.inputnode.fs_subjects_dir = freesurfer_dir mgzconvert.inputs.inputnode.fs_subject_id = subject normalize = create_normalize_pipeline() normalize.inputs.inputnode.standard = standard_brain # sink to store files sink = Node(nio.DataSink(base_directory=out_dir, parameterization=False, substitutions=[ ('transform_Warped', 'T1_brain2mni')]), name='sink') # connections struct_preproc.connect( [(mgzconvert, normalize, [('outputnode.anat_brain', 'inputnode.anat')]), (mgzconvert, sink, [('outputnode.anat_head', '@head')]), (mgzconvert, sink, [('outputnode.anat_brain', '@brain')]), (mgzconvert, sink, [('outputnode.anat_brain_mask', '@mask')]), (normalize, sink, [('outputnode.anat2std', '@anat2std'), ('outputnode.anat2std_transforms', 'transforms2mni.@anat2std_transforms'), ('outputnode.std2anat_transforms', 'transforms2mni.@std2anat_transforms')]) ]) struct_preproc.write_graph(dotfilename='struct_preproc.dot', graph2use='colored', format='pdf', simple_form=True) # struct_preproc.run() struct_preproc.run(plugin='CondorDAGMan', plugin_args = {'initial_specs': 'request_memory = 1500'}) #
topup.connect([(inputnode, convertwarp, [('anat_head', 'reference')]), (epireg, convertwarp, [('shiftmap', 'shiftmap')]), (concat, convertwarp, [('out_file', 'postmat')]), (inputnode, applywarp, [('epi_mean', 'in_file'), ('anat_head', 'ref_file')]), (convertwarp, applywarp, [('out_field', 'field_file')]), (applywarp, outputnode, [('out_file', 'topup_mean_coreg')]), (convertwarp, outputnode, [('out_field', 'topup_fullwarp')]) ]) ##### in and output ############ topup.base_dir='/scr/kansas1/huntenburg/' topup.config['execution']={'remove_unnecessary_outputs': 'False'} data_dir='/scr/jessica2/Schaare/LEMON/' fs_subjects_dir='/scr/jessica2/Schaare/LEMON/freesurfer/freesurfer/' out_dir = '/scr/jessica2/Schaare/LEMON/preprocessed/' subjects=['LEMON001'] # subjects=[] # f = open('/scr/jessica2/Schaare/LEMON/done_freesurfer.txt','r') # for line in f: # subjects.append(line.strip()) # create inforsource to iterate over subjects infosource = Node(util.IdentityInterface(fields=['subject_id','fs_subjects_dir']), name='infosource') infosource.inputs.fs_subjects_dir=fs_subjects_dir
def collect_3d_metrics_run_glm_meanRegression(cfg): import os from nipype import config from nipype.pipeline.engine import Node, Workflow, MapNode, JoinNode import nipype.interfaces.utility as util import nipype.interfaces.io as nio import nipype.interfaces.fsl as fsl import nipype.interfaces.freesurfer as freesurfer # INPUT PARAMETERS metrics_data_dir = cfg['metrics_data_dir'] metrics_data_suffix = cfg['metrics_data_suffix'] metric_name = cfg['metric_name'] demos_df = cfg['demos_df'] qc_df = cfg['qc_df'] working_dir = cfg['working_dir'] ds_dir = cfg['ds_dir'] template_dir = cfg['template_dir'] subjects_list = cfg['subjects_list'] use_n_procs = cfg['use_n_procs'] plugin_name = cfg['plugin_name'] ##################################### # GENERAL SETTINGS ##################################### fsl.FSLCommand.set_default_output_type('NIFTI_GZ') wf = Workflow(name='LeiCA_collect_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') # 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', 'brain_mask_MNI_3mm': 'cpac_image_resources/MNI_3mm/MNI152_T1_3mm_brain_mask.nii.gz', 'brain_template_MNI_3mm': 'cpac_image_resources/MNI_3mm/MNI152_T1_3mm.nii.gz' } selectfiles_anat_templates = Node(nio.SelectFiles(templates_atlases, base_directory=template_dir), name="selectfiles_anat_templates") # EXPORT SUBJECT LIST def export_subjects_list_fct(subjects_list): import os out_file = os.path.join(os.getcwd(), 'subject_list.txt') file = open(out_file, 'w') for subject in subjects_list: file.write('%s\n'%subject) file.close() return out_file # RESTRICT SUBJECTS LIST TO ADULTS def get_subjects_list_adults_fct(df_path, df_qc_path, subjects_list): ''' excludes kids and subjects with missing sex or age ''' import pandas as pd import numpy as np df = pd.read_pickle(df_path) df_qc = pd.read_pickle(df_qc_path) df = pd.merge(df, df_qc, left_index=True, right_index=True) pd.to_pickle(df, 'testdf.pkl') df['subject_id'] = df.subject_id_x # fixme exclude subjects with mean_FD>.1 subjects_list_exclude = df[(df.age<18) | (df.mean_FD_Power>.1)].index subjects_list_adults = subjects_list for exclude_subject in subjects_list_exclude: if exclude_subject in subjects_list_adults: subjects_list_adults.remove(exclude_subject) missing_info = df[(df.age==999) | ((np.logical_or(df.sex=='M', df.sex=='F'))==False)].index for missing in missing_info: if missing in subjects_list_adults: subjects_list_adults.remove(missing) # remove subject from subject_list_adults for which no entry exists in df for subject in subjects_list_adults: if not(subject in df.index): subjects_list_adults.remove(subject) return subjects_list_adults get_subjects_list_adults = Node(util.Function(input_names=['df_path', 'df_qc_path', 'subjects_list'], output_names=['subjects_list_adults'], function=get_subjects_list_adults_fct), name='get_subjects_list_adults') get_subjects_list_adults.inputs.df_path = demos_df get_subjects_list_adults.inputs.df_qc_path = qc_df get_subjects_list_adults.inputs.subjects_list = subjects_list export_subjects_list = Node(util.Function(input_names=['subjects_list'], output_names=['out_file'], function=export_subjects_list_fct), name='export_subjects_list') wf.connect(get_subjects_list_adults, 'subjects_list_adults', export_subjects_list,'subjects_list') wf.connect(export_subjects_list, 'out_file', ds,'@subjects_list') # BUILD FILE LIST FOR MERGER def build_file_list_fct(prefix, subjects_list, suffix): import os out_file_list = [] for subject in subjects_list: out_file_list.append(os.path.join(prefix, subject, suffix)) return out_file_list build_file_list = Node(util.Function(input_names=['prefix', 'subjects_list', 'suffix'], output_names=['out_file_list'], function=build_file_list_fct), name='build_file_list') build_file_list.inputs.prefix = metrics_data_dir wf.connect(get_subjects_list_adults, 'subjects_list_adults', build_file_list,'subjects_list') build_file_list.inputs.suffix = metrics_data_suffix # MERGE FILES merge = Node(fsl.Merge(dimension='t'), name='merge') wf.connect(build_file_list, 'out_file_list', merge, 'in_files') merge.inputs.merged_file = metric_name + '_merge.nii.gz' wf.connect(merge, 'merged_file', ds,'@merge') # GET MEAN VALUE WITHIN MASK FOR REGRESSION get_mean_values = Node(fsl.ImageStats(), name='get_mean_values') get_mean_values.inputs.op_string='-k %s -m' get_mean_values.inputs.split_4d=True wf.connect(merge, 'merged_file', get_mean_values, 'in_file') wf.connect(selectfiles_anat_templates, 'brain_mask_MNI_3mm', get_mean_values, 'mask_file') # CALC MEAN mean = Node(fsl.MeanImage(), name='mean') mean.inputs.out_file = metric_name + '_mean.nii.gz' wf.connect(merge, 'merged_file', mean, 'in_file') wf.connect(mean, 'out_file', ds,'@mean') # CREATE DESIGN FILES def create_design_files_fct(df_demographics_path, df_qc_path, subjects_list, mean_values): ''' df_path: df should have columns sex ('M', 'F') & age function .restricts df to subjects_list .creates dummy sex vars, age**2, contrasts .writes mat & con files ''' import pandas as pd import numpy as np import os df = pd.read_pickle(df_demographics_path) df_qc = pd.read_pickle(df_qc_path) df = pd.merge(df, df_qc, left_index=True, right_index=True) df['dummy_m'] = (df.sex == 'M').astype('int') df['dummy_f'] = (df.sex == 'F').astype('int') df['age2'] = df.age**2 df_use = df.loc[subjects_list] df_use['mean_values'] = mean_values #fixme mat = df_use[['dummy_m', 'dummy_f', 'age','mean_FD_Power']].values mat_str = [ '/NumWaves %s'%str(mat.shape[1]), '/NumPoints %s'%str(mat.shape[0]), '/Matrix' ] n_cons = 6 cons_str = [ '/ContrastName1 pos_age', '/ContrastName2 neg_age', '/ContrastName3 m>f', '/ContrastName4 f>m', '/ContrastName5 pos_mean_FD_Power', '/ContrastName6 neg_mean_FD_Power', '/NumWaves %s'%str(mat.shape[1]), '/NumContrasts %s'%str(n_cons), '', '/Matrix', '0 0 1 0', '0 0 -1 0', '1 -1 0 0', '-1 1 0 0', '0 0 0 1', '0 0 0 -1' ] # mat = df_use[['dummy_m', 'dummy_f', 'age', 'age2','mean_FD_Power']].values # # mat_str = [ # '/NumWaves %s'%str(mat.shape[1]), # '/NumPoints %s'%str(mat.shape[0]), # '/Matrix' # ] # # n_cons = 10 # cons_str = [ # '/ContrastName1 pos_age', # '/ContrastName2 pos_age2', # '/ContrastName3 pos_age+age2', # '/ContrastName4 neg_age', # '/ContrastName5 neg_age2', # '/ContrastName6 neg_age+age2', # '/ContrastName7 m>f', # '/ContrastName8 f>m', # '/ContrastName9 pos_mean_FD_Power', # '/ContrastName10 neg_mean_FD_Power', # '/NumWaves %s'%str(mat.shape[1]), # '/NumContrasts %s'%str(n_cons), # '', # '/Matrix', # '0 0 1 0 0', # '0 0 0 1 0', # '0 0 .5 .5 0', # '0 0 -1 0 0', # '0 0 0 -1 0', # '0 0 -.5 -.5 0', # '1 -1 0 0 0', # '1 1 0 0 0', # '0 0 0 0 1', # '0 0 0 0 -1' # ] # mat_file = os.path.join(os.getcwd(), 'design.mat') mat_file_numerical = os.path.join(os.getcwd(), 'design_mat_num.txt') con_file = os.path.join(os.getcwd(), 'design.con') df_used_file = os.path.join(os.getcwd(), 'df_used.csv') # mat_str_out = '' # for line in mat_str: # mat_str_out = mat_str_out[:] + line + '\n' np.savetxt(mat_file_numerical, mat) num_file = open(mat_file_numerical, 'r') nums_str = num_file.read() num_file.close() out_file = open(mat_file, 'w') for line in mat_str: out_file.write('%s\n' % line) out_file.write(nums_str) out_file.close() out_file = open(con_file, 'w') for line in cons_str: out_file.write('%s\n' % line) out_file.close() df_use.to_csv(df_used_file) return mat_file, con_file, df_used_file, n_cons create_design_files = Node(util.Function(input_names=['df_demographics_path', 'df_qc_path', 'subjects_list', 'mean_values'], output_names=['mat_file', 'con_file', 'df_used_file', 'n_cons'], function=create_design_files_fct), name='create_design_files') create_design_files.inputs.df_demographics_path = demos_df create_design_files.inputs.df_qc_path = qc_df wf.connect(get_subjects_list_adults, 'subjects_list_adults', create_design_files,'subjects_list') wf.connect(get_mean_values, 'out_stat', create_design_files,'mean_values') wf.connect(create_design_files,'df_used_file', ds,'glm.@df_used') smooth = Node(fsl.utils.Smooth(fwhm=4), name='smooth') wf.connect(merge, 'merged_file', smooth, 'in_file') def run_randomise_fct(data_file, mat_file, con_file, mask_file): import os out_dir = os.path.join(os.getcwd(), 'glm') os.mkdir(out_dir) cmd_str = 'randomise -i %s -o glm/glm -d %s -t %s -m %s -n 500 -D -T' %(data_file,mat_file, con_file, mask_file) file = open('command.txt', 'w') file.write(cmd_str) file.close() os.system(cmd_str) return out_dir run_randomise = Node(util.Function(input_names=['data_file', 'mat_file', 'con_file', 'mask_file'], output_names=['out_dir'], function=run_randomise_fct), name='run_randomise') #fixme #wf.connect(merge, 'merged_file', run_randomise, 'data_file') wf.connect(smooth, 'smoothed_file', run_randomise, 'data_file') wf.connect(create_design_files, 'mat_file', run_randomise, 'mat_file') wf.connect(create_design_files, 'con_file', run_randomise, 'con_file') #wf.connect(selectfiles_anat_templates, 'GM_mask_MNI_3mm', run_randomise, 'mask_file') wf.connect(selectfiles_anat_templates, 'brain_mask_MNI_3mm', run_randomise, 'mask_file') def create_renders_fct(randomise_dir, n_cons, background_img): import os thresh = .95 out_files_list = [] corr_list = ['glm_tfce_corrp_tstat', 'glm_tfce_p_tstat'] for corr in corr_list: for con in range(1,n_cons+1): output_root = corr + str(con) in_file = os.path.join(randomise_dir, output_root + '.nii.gz') out_file = os.path.join(os.getcwd(), 'rendered_' + output_root + '.png') out_files_list.append(out_file) cmd_str = 'easythresh %s %s %s %s' % (in_file, str(thresh), background_img, output_root) file = open('command.txt', 'w') file.write(cmd_str) file.close() os.system(cmd_str) return out_files_list create_renders = Node(util.Function(input_names=['randomise_dir', 'n_cons', 'background_img'], output_names=['out_files_list'], function=create_renders_fct), name='create_renders') wf.connect(run_randomise, 'out_dir', create_renders, 'randomise_dir') wf.connect(create_design_files, 'n_cons', create_renders, 'n_cons') wf.connect(selectfiles_anat_templates, 'brain_template_MNI_3mm', create_renders, 'background_img') wf.connect(create_renders, 'out_files_list', ds, 'glm.@renders') 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})
fmapepi.connect([(inputnode, convertwarp, [('anat_head', 'reference')]), (convertwarp0, convertwarp, [('out_field', 'warp1')]), (bbregister, convertwarp, [('out_fsl_file', 'postmat')]), (inputnode, applywarp, [('epi_mean', 'in_file'), ('anat_head', 'ref_file')]), (convertwarp, applywarp, [('out_field', 'field_file')]), (applywarp, outputnode, [('out_file', 'fmap_mean_coreg')]), (convertwarp, outputnode, [('out_field', 'fmap_fullwarp')]) ]) #### running directly ############################################################################################################ fmapepi.base_dir='/scr/kansas1/huntenburg/lemon_missing/working_dir/' #fmapepi.config['execution']={'remove_unnecessary_outputs': 'False'} data_dir = '/scr/jessica2/Schaare/LEMON/' fs_subjects_dir='/scr/jessica2/Schaare/LEMON/freesurfer/' out_dir = '/scr/jessica2/Schaare/LEMON/preprocessed/' #subjects=['LEMON001'] subjects=[] f = open('/scr/jessica2/Schaare/LEMON/missing_subjects.txt','r') for line in f: subjects.append(line.strip()) # create inforsource to iterate over subjects infosource = Node(util.IdentityInterface(fields=['subject_id','fs_subjects_dir']), name='infosource') infosource.inputs.fs_subjects_dir=fs_subjects_dir infosource.iterables=('subject_id', subjects)
def create_resting(subject, working_dir, data_dir, freesurfer_dir, out_dir, vol_to_remove, TR, epi_resolution, highpass, lowpass, echo_space, pe_dir, standard_brain, standard_brain_resampled, standard_brain_mask, standard_brain_mask_resampled, fwhm_smoothing): # set fsl output type to nii.gz fsl.FSLCommand.set_default_output_type('NIFTI_GZ') # main workflow func_preproc = Workflow(name='resting_postscrub') func_preproc.base_dir = working_dir func_preproc.config['execution'][ 'crashdump_dir'] = func_preproc.base_dir + "/crash_files" # select files templates = { 'epi_scrubbed_interp': 'preprocessing/preprocessed/{subject}/scrubbed_interpolated/rest2anat_denoised_scrubbed_intep.nii.gz', 'anat_head': 'preprocessing/preprocessed/{subject}/structural/T1.nii.gz', 'anat_brain': 'preprocessing/preprocessed/{subject}/structural/brain.nii.gz', 'brain_mask': 'preprocessing/preprocessed/{subject}/structural/T1_brain_mask.nii.gz', 'ants_affine': 'preprocessing/preprocessed/{subject}/structural/transforms2mni/transform0GenericAffine.mat', 'ants_warp': 'preprocessing/preprocessed/{subject}/structural/transforms2mni/transform1Warp.nii.gz' } selectfiles = Node(nio.SelectFiles(templates, base_directory=data_dir), name="selectfiles") selectfiles.inputs.subject = subject # node to remove first volumes # remove_vol = Node(util.Function(input_names=['in_file', 't_min'], # output_names=["out_file"], # function=strip_rois_func), # name='remove_vol') # remove_vol.inputs.t_min = vol_to_remove # # workflow for motion correction # moco = create_moco_pipeline() # # # workflow for fieldmap correction and coregistration # topup_coreg = create_topup_coreg_pipeline() # topup_coreg.inputs.inputnode.fs_subjects_dir = freesurfer_dir # topup_coreg.inputs.inputnode.fs_subject_id = subject # topup_coreg.inputs.inputnode.echo_space = echo_space # topup_coreg.inputs.inputnode.pe_dir = pe_dir # # # workflow for applying transformations to timeseries # transform_ts = create_transform_pipeline() # transform_ts.inputs.inputnode.resolution = epi_resolution # # # # workflow to denoise timeseries denoise = create_denoise_pipeline() denoise.inputs.inputnode.highpass_sigma = 1. / (2 * TR * highpass) denoise.inputs.inputnode.lowpass_sigma = 1. / (2 * TR * lowpass) # https://www.jiscmail.ac.uk/cgi-bin/webadmin?A2=ind1205&L=FSL&P=R57592&1=FSL&9=A&I=-3&J=on&d=No+Match%3BMatch%3BMatches&z=4 denoise.inputs.inputnode.tr = TR # workflow to transform timeseries to MNI ants_registration = create_ants_registration_pipeline() ants_registration.inputs.inputnode.ref = standard_brain ants_registration.inputs.inputnode.tr_sec = TR # FL added fullspectrum # workflow to transform fullspectrum timeseries to MNI #ants_registration_full = create_ants_registration_pipeline('ants_registration_full') #ants_registration_full.inputs.inputnode.ref = standard_brain #ants_registration_full.inputs.inputnode.tr_sec = TR # workflow to smooth smoothing = create_smoothing_pipeline() smoothing.inputs.inputnode.fwhm = fwhm_smoothing # visualize registration results visualize = create_visualize_pipeline() visualize.inputs.inputnode.mni_template = standard_brain # sink to store files sink = Node(nio.DataSink( parameterization=False, base_directory=out_dir, substitutions=[('rest_denoised_bandpassed_norm_trans.nii.gz', 'rest_scrubbed_int_mni_unsmoothed.nii.gz'), ('rest_denoised_bandpassed_norm_trans_smooth.nii.gz', 'rest_scrubbed_int_mni_smoothed.nii.gz'), ('rest_denoised_bandpassed_norm.nii.gz', 'rest_denoised_scrubbed_int_bp.nii.gz')]), name='sink') # connections func_preproc.connect([ # remove the first volumes # (selectfiles, remove_vol, [('func', 'in_file')]), # # # align volumes and motion correction # (remove_vol, moco, [('out_file', 'inputnode.epi')]), # # # prepare field map # (selectfiles, topup_coreg, [('ap', 'inputnode.ap'), # ('pa', 'inputnode.pa'), # ('anat_head', 'inputnode.anat_head'), # ('anat_brain', 'inputnode.anat_brain') # ]), # (moco, topup_coreg, [('outputnode.epi_mean', 'inputnode.epi_mean')]), # # # transform timeseries # (remove_vol, transform_ts, [('out_file', 'inputnode.orig_ts')]), # (selectfiles, transform_ts, [('anat_head', 'inputnode.anat_head')]), # (selectfiles, transform_ts, [('brain_mask', 'inputnode.brain_mask')]), # (moco, transform_ts, [('outputnode.mat_moco', 'inputnode.mat_moco')]), # (topup_coreg, transform_ts, [('outputnode.fmap_fullwarp', 'inputnode.fullwarp')]), # # # correct slicetiming # # FIXME slice timing? # # (transform_ts, slicetiming, [('outputnode.trans_ts_masked', 'inputnode.ts')]), # # (slicetiming, denoise, [('outputnode.ts_slicetcorrected', 'inputnode.epi_coreg')]), # (transform_ts, denoise, [('outputnode.trans_ts_masked', 'inputnode.epi_coreg')]), # denoise data (selectfiles, denoise, [('brain_mask', 'inputnode.brain_mask'), ('anat_brain', 'inputnode.anat_brain'), ('epi_scrubbed_interp', 'inputnode.epi_denoised')]), (denoise, ants_registration, [('outputnode.normalized_file', 'inputnode.denoised_ts')]), # registration to MNI space (selectfiles, ants_registration, [('ants_affine', 'inputnode.ants_affine')]), (selectfiles, ants_registration, [('ants_warp', 'inputnode.ants_warp') ]), # FL added fullspectrum #(selectfiles, ants_registration_full, [('epi_scrubbed_interp', 'inputnode.denoised_ts')]), #(selectfiles, ants_registration_full, [('ants_affine', 'inputnode.ants_affine')]), #(selectfiles, ants_registration_full, [('ants_warp', 'inputnode.ants_warp')]), (ants_registration, smoothing, [('outputnode.ants_reg_ts', 'inputnode.ts_transformed')]), (smoothing, visualize, [('outputnode.ts_smoothed', 'inputnode.ts_transformed')]), ##all the output # (moco, sink, [ # ('outputnode.epi_moco', 'realign.@realigned_ts'), # ('outputnode.par_moco', 'realign.@par'), # ('outputnode.rms_moco', 'realign.@rms'), # ('outputnode.mat_moco', 'realign.MAT.@mat'), # ('outputnode.epi_mean', 'realign.@mean'), # ('outputnode.rotplot', 'realign.plots.@rotplot'), # ('outputnode.transplot', 'realign.plots.@transplot'), # ('outputnode.dispplots', 'realign.plots.@dispplots'), # ('outputnode.tsnr_file', 'realign.@tsnr')]), # (topup_coreg, sink, [('outputnode.fmap', 'coregister.transforms2anat.@fmap'), # # ('outputnode.unwarpfield_epi2fmap', 'coregister.@unwarpfield_epi2fmap'), # ('outputnode.unwarped_mean_epi2fmap', 'coregister.@unwarped_mean_epi2fmap'), # ('outputnode.epi2fmap', 'coregister.@epi2fmap'), # # ('outputnode.shiftmap', 'coregister.@shiftmap'), # ('outputnode.fmap_fullwarp', 'coregister.transforms2anat.@fmap_fullwarp'), # ('outputnode.epi2anat', 'coregister.@epi2anat'), # ('outputnode.epi2anat_mat', 'coregister.transforms2anat.@epi2anat_mat'), # ('outputnode.epi2anat_dat', 'coregister.transforms2anat.@epi2anat_dat'), # ('outputnode.epi2anat_mincost', 'coregister.@epi2anat_mincost') # ]), # # (transform_ts, sink, [('outputnode.trans_ts_masked', 'coregister.@full_transform_ts'), # ('outputnode.trans_ts_mean', 'coregister.@full_transform_mean'), # ('outputnode.resamp_brain', 'coregister.@resamp_brain')]), ( denoise, sink, [ ('outputnode.normalized_file', 'denoise.@normalized'), # FL added fullspectrum ]), (ants_registration, sink, [('outputnode.ants_reg_ts', 'ants.@antsnormalized')]), #(ants_registration_full, sink, [('outputnode.ants_reg_ts', 'ants.@antsnormalized_fullspectrum')]), (smoothing, sink, [('outputnode.ts_smoothed', '@smoothed.FWHM6')]), ]) func_preproc.write_graph(dotfilename='func_preproc.dot', graph2use='colored', format='pdf', simple_form=True) func_preproc.run()
def main(): """Entry point""" from nipype import config as ncfg from nipype.pipeline.engine import Workflow from mriqc import DEFAULTS from mriqc.utils.bids import collect_bids_data from mriqc.workflows.core import build_workflow # from mriqc.reports.utils import check_reports parser = ArgumentParser(description='MRI Quality Control', formatter_class=RawTextHelpFormatter) parser.add_argument('-v', '--version', action='version', version='mriqc v{}'.format(__version__)) parser.add_argument('bids_dir', action='store', help='The directory with the input dataset ' 'formatted according to the BIDS standard.') parser.add_argument( 'output_dir', action='store', help='The directory where the output files ' 'should be stored. If you are running group level analysis ' 'this folder should be prepopulated with the results of the' 'participant level analysis.') parser.add_argument( 'analysis_level', action='store', nargs='+', help='Level of the analysis that will be performed. ' 'Multiple participant level analyses can be run independently ' '(in parallel) using the same output_dir.', choices=['participant', 'group']) parser.add_argument( '--participant_label', '--subject_list', '-S', action='store', help='The label(s) of the participant(s) that should be analyzed. ' 'The label corresponds to sub-<participant_label> from the ' 'BIDS spec (so it does not include "sub-"). If this parameter ' 'is not provided all subjects should be analyzed. Multiple ' 'participants can be specified with a space separated list.', nargs="*") g_input = parser.add_argument_group('mriqc specific inputs') g_input.add_argument('-m', '--modalities', action='store', nargs='*', choices=['T1w', 'bold', 'T2w'], default=['T1w', 'bold', 'T2w']) g_input.add_argument('-s', '--session-id', action='store') g_input.add_argument('-r', '--run-id', action='store') g_input.add_argument('--nthreads', action='store', type=int, help='number of threads') g_input.add_argument('--n_procs', action='store', default=0, type=int, help='number of threads') g_input.add_argument('--mem_gb', action='store', default=0, type=int, help='available total memory') g_input.add_argument('--write-graph', action='store_true', default=False, help='Write workflow graph.') g_input.add_argument('--dry-run', action='store_true', default=False, help='Do not run the workflow.') g_input.add_argument('--use-plugin', action='store', default=None, help='nipype plugin configuration file') g_input.add_argument('--testing', action='store_true', default=False, help='use testing settings for a minimal footprint') g_input.add_argument( '--hmc-afni', action='store_true', default=True, help='Use ANFI 3dvolreg for head motion correction (HMC)') g_input.add_argument( '--hmc-fsl', action='store_true', default=False, help='Use FSL MCFLIRT for head motion correction (HMC)') g_input.add_argument( '-f', '--float32', action='store_true', default=DEFAULTS['float32'], help= "Cast the input data to float32 if it's represented in higher precision " "(saves space and improves perfomance)") g_input.add_argument('--fft-spikes-detector', action='store_true', default=False, help='Turn on FFT based spike detector (slow).') g_outputs = parser.add_argument_group('mriqc specific outputs') g_outputs.add_argument('-w', '--work-dir', action='store', default=op.join(os.getcwd(), 'work')) g_outputs.add_argument('--report-dir', action='store') g_outputs.add_argument('--verbose-reports', default=False, action='store_true') # ANTs options g_ants = parser.add_argument_group( 'specific settings for ANTs registrations') g_ants.add_argument( '--ants-nthreads', action='store', type=int, default=DEFAULTS['ants_nthreads'], help='number of threads that will be set in ANTs processes') g_ants.add_argument('--ants-settings', action='store', help='path to JSON file with settings for ANTS') # AFNI head motion correction settings g_afni = parser.add_argument_group( 'specific settings for AFNI head motion correction') g_afni.add_argument( '--deoblique', action='store_true', default=False, help='Deoblique the functional scans during head motion ' 'correction preprocessing') g_afni.add_argument( '--despike', action='store_true', default=False, help='Despike the functional scans during head motion correction ' 'preprocessing') g_afni.add_argument( '--start-idx', action='store', type=int, help='Initial volume in functional timeseries that should be ' 'considered for preprocessing') g_afni.add_argument( '--stop-idx', action='store', type=int, help='Final volume in functional timeseries that should be ' 'considered for preprocessing') g_afni.add_argument('--correct-slice-timing', action='store_true', default=False, help='Perform slice timing correction') opts = parser.parse_args() # Build settings dict bids_dir = op.abspath(opts.bids_dir) # Number of processes n_procs = 0 if opts.nthreads is not None: MRIQC_LOG.warn('Option --nthreads has been deprecated in mriqc 0.8.8. ' 'Please use --n_procs instead.') n_procs = opts.nthreads if opts.n_procs is not None: n_procs = opts.n_procs # Check physical memory total_memory = opts.mem_gb if total_memory < 0: try: from psutil import virtual_memory total_memory = virtual_memory().total // (1024**3) + 1 except ImportError: MRIQC_LOG.warn( 'Total physical memory could not be estimated, using %d' 'GB as default', DEFAULT_MEM_GB) total_memory = DEFAULT_MEM_GB if total_memory > 0: av_procs = total_memory // 4 if av_procs < 1: MRIQC_LOG.warn( 'Total physical memory is less than 4GB, memory allocation' ' problems are likely to occur.') n_procs = 1 elif n_procs > av_procs: n_procs = av_procs settings = { 'bids_dir': bids_dir, 'write_graph': opts.write_graph, 'testing': opts.testing, 'hmc_afni': opts.hmc_afni, 'hmc_fsl': opts.hmc_fsl, 'fft_spikes_detector': opts.fft_spikes_detector, 'n_procs': n_procs, 'ants_nthreads': opts.ants_nthreads, 'output_dir': op.abspath(opts.output_dir), 'work_dir': op.abspath(opts.work_dir), 'verbose_reports': opts.verbose_reports or opts.testing, 'float32': opts.float32 } if opts.hmc_afni: settings['deoblique'] = opts.deoblique settings['despike'] = opts.despike settings['correct_slice_timing'] = opts.correct_slice_timing if opts.start_idx: settings['start_idx'] = opts.start_idx if opts.stop_idx: settings['stop_idx'] = opts.stop_idx if opts.ants_settings: settings['ants_settings'] = opts.ants_settings log_dir = op.join(settings['output_dir'], 'logs') analysis_levels = opts.analysis_level if opts.participant_label is None: analysis_levels.append('group') analysis_levels = list(set(analysis_levels)) if len(analysis_levels) > 2: raise RuntimeError('Error parsing analysis levels, got "%s"' % ', '.join(analysis_levels)) settings['report_dir'] = opts.report_dir if not settings['report_dir']: settings['report_dir'] = op.join(settings['output_dir'], 'reports') check_folder(settings['output_dir']) if 'participant' in analysis_levels: check_folder(settings['work_dir']) check_folder(log_dir) check_folder(settings['report_dir']) # Set nipype config ncfg.update_config({ 'logging': { 'log_directory': log_dir, 'log_to_file': True }, 'execution': { 'crashdump_dir': log_dir } }) plugin_settings = {'plugin': 'Linear'} if opts.use_plugin is not None: from yaml import load as loadyml with open(opts.use_plugin) as pfile: plugin_settings = loadyml(pfile) else: # Setup multiprocessing if settings['n_procs'] == 0: settings['n_procs'] = 1 max_parallel_ants = cpu_count() // settings['ants_nthreads'] if max_parallel_ants > 1: settings['n_procs'] = max_parallel_ants if settings['n_procs'] > 1: plugin_settings['plugin'] = 'MultiProc' plugin_settings['plugin_args'] = {'n_procs': settings['n_procs']} MRIQC_LOG.info( 'Running MRIQC-%s (analysis_levels=[%s], participant_label=%s)\n\tSettings=%s', __version__, ', '.join(analysis_levels), opts.participant_label, settings) # Process data types modalities = opts.modalities dataset = collect_bids_data(settings['bids_dir'], participant_label=opts.participant_label) # Set up participant level if 'participant' in analysis_levels: workflow = Workflow(name='workflow_enumerator') workflow.base_dir = settings['work_dir'] wf_list = [] for mod in modalities: if not dataset[mod]: MRIQC_LOG.warn('No %s scans were found in %s', mod, settings['bids_dir']) continue wf_list.append(build_workflow(dataset[mod], mod, settings=settings)) if wf_list: workflow.add_nodes(wf_list) if not opts.dry_run: workflow.run(**plugin_settings) else: raise RuntimeError( 'Error reading BIDS directory (%s), or the dataset is not ' 'BIDS-compliant.' % settings['bids_dir']) # Set up group level if 'group' in analysis_levels: from mriqc.reports import group_html from mriqc.utils.misc import generate_csv, generate_pred reports_dir = check_folder(op.join(settings['output_dir'], 'reports')) derivatives_dir = op.join(settings['output_dir'], 'derivatives') n_group_reports = 0 for mod in modalities: dataframe, out_csv = generate_csv(derivatives_dir, settings['output_dir'], mod) # If there are no iqm.json files, nothing to do. if dataframe is None: MRIQC_LOG.warn( 'No IQM-JSON files were found for the %s data type in %s. The group-level ' 'report was not generated.', mod, derivatives_dir) continue MRIQC_LOG.info('Summary CSV table for the %s data generated (%s)', mod, out_csv) out_pred = generate_pred(derivatives_dir, settings['output_dir'], mod) if out_pred is not None: MRIQC_LOG.info( 'Predicted QA CSV table for the %s data generated (%s)', mod, out_pred) out_html = op.join(reports_dir, mod + '_group.html') group_html(out_csv, mod, csv_failed=op.join(settings['output_dir'], 'failed_' + mod + '.csv'), out_file=out_html) MRIQC_LOG.info('Group-%s report generated (%s)', mod, out_html) n_group_reports += 1 if n_group_reports == 0: raise Exception( "No data found. No group level reports were generated.")
def calc_local_metrics( preprocessed_data_dir, subject_id, parcellations_dict, bp_freq_list, fd_thresh, 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 import utils as calc_metrics_utils ##################################### # 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_infosource = Node(util.IdentityInterface(fields=["bp_freqs"]), name="bp_filter_infosource") bp_filter_infosource.iterables = ("bp_freqs", bp_freq_list) selectfiles = Node( nio.SelectFiles( { "parcellation_time_series": "{subject_id}/con_mat/parcellated_time_series/bp_{bp_freqs}/{parcellation}/parcellation_time_series.npy" }, base_directory=preprocessed_data_dir, ), name="selectfiles", ) selectfiles.inputs.subject_id = subject_id wf.connect(parcellation_infosource, "parcellation", selectfiles, "parcellation") wf.connect(bp_filter_infosource, "bp_freqs", selectfiles, "bp_freqs") fd_file = Node( nio.SelectFiles({"fd_p": "{subject_id}/QC/FD_P_ts"}, base_directory=preprocessed_data_dir), name="fd_file" ) fd_file.inputs.subject_id = subject_id ############## ## CON MATS ############## ############## ## extract ts ############## get_good_trs = Node( util.Function( input_names=["fd_file", "fd_thresh"], output_names=["good_trs", "fd_scrubbed_file"], function=calc_metrics_utils.get_good_trs, ), name="get_good_trs", ) wf.connect(fd_file, "fd_p", get_good_trs, "fd_file") get_good_trs.inputs.fd_thresh = fd_thresh parcellated_ts_scrubbed = Node( util.Function( input_names=["parcellation_time_series_file", "good_trs"], output_names=["parcellation_time_series_scrubbed"], function=calc_metrics_utils.parcellation_time_series_scrubbing, ), name="parcellated_ts_scrubbed", ) wf.connect(selectfiles, "parcellation_time_series", parcellated_ts_scrubbed, "parcellation_time_series_file") wf.connect(get_good_trs, "good_trs", parcellated_ts_scrubbed, "good_trs") ############## ## 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_scrubbed, "parcellation_time_series_scrubbed", con_mat, "in_data") ############## ## ds ############## wf.connect(get_good_trs, "fd_scrubbed_file", ds, "QC.@fd_scrubbed_file") fd_str = ("%.1f" % fd_thresh).replace(".", "_") wf.connect(con_mat, "matrix_file", ds, "con_mat.matrix_scrubbed_%s.@mat" % fd_str) # 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})
import nipype.interfaces.fsl as fsl import nipype.algorithms.rapidart as ra from functions import motion_regressors, selectindex, nilearn_denoise, fix_hdr # read in subjects and file names subjects = [['P46', 'XXXX']] sessions = ['d0'] # directories working_dir = '/nobackup/eminem2/schmidt/MMPIRS/preprocessing/working_dir' out_dir = '/nobackup/eminem2/schmidt/MMPIRS/preprocessing/final/' # main workflow preproc_nuisance_regress = Workflow(name='func_preproc_nuisance_regress') preproc_nuisance_regress.base_dir = working_dir preproc_nuisance_regress.config['execution'][ 'crashdump_dir'] = preproc_nuisance_regress.base_dir + "/crash_files" # iterate over subjects subject_infosource = Node(util.IdentityInterface(fields=['subjectlist']), name='subject_infosource') subject_infosource.iterables = [('subjectlist', subjects)] # iterate over sessions session_infosource = Node(util.IdentityInterface(fields=['session']), name='session_infosource') session_infosource.iterables = [('session', sessions)] # select files
def create_structural(subject, working_dir, data_dir, freesurfer_dir, out_dir, standard_brain): # main workflow struct_preproc = Workflow(name='mp2rage_preproc') struct_preproc.base_dir = working_dir struct_preproc.config['execution']['crashdump_dir'] = struct_preproc.base_dir + "/crash_files" # select files templates={'inv2': 'nifti/mp2rage/inv2.nii.gz', 't1map': 'nifti/mp2rage/t1map.nii.gz', 'uni': 'nifti/mp2rage/uni.nii.gz'} selectfiles = Node(nio.SelectFiles(templates, base_directory=data_dir), name="selectfiles") # workflow for mp2rage background masking mp2rage=create_mp2rage_pipeline() # workflow to run freesurfer reconall reconall=create_reconall_pipeline() reconall.inputs.inputnode.fs_subjects_dir=freesurfer_dir reconall.inputs.inputnode.fs_subject_id=subject # workflow to get brain, head and wmseg from freesurfer and convert to nifti mgzconvert=create_mgzconvert_pipeline() # workflow to normalize anatomy to standard space normalize=create_normalize_pipeline() normalize.inputs.inputnode.standard = standard_brain #sink to store files sink = Node(nio.DataSink(base_directory=out_dir, parameterization=False, substitutions=[('outStripped', 'uni_stripped'), ('outMasked2', 'uni_masked'), ('outSignal2', 'background_mask'), ('outOriginal', 'uni_reoriented'), ('outMask', 'skullstrip_mask'), ('transform_Warped', 'T1_brain2mni')]), name='sink') # connections struct_preproc.connect([(selectfiles, mp2rage, [('inv2', 'inputnode.inv2'), ('t1map', 'inputnode.t1map'), ('uni', 'inputnode.uni')]), (mp2rage, reconall, [('outputnode.uni_masked', 'inputnode.anat')]), (reconall, mgzconvert, [('outputnode.fs_subject_id', 'inputnode.fs_subject_id'), ('outputnode.fs_subjects_dir', 'inputnode.fs_subjects_dir')]), (mgzconvert, normalize, [('outputnode.anat_brain', 'inputnode.anat')]), #(mp2rage, sink, [('outputnode.uni_masked', 'preprocessed.mp2rage.background_masking.@uni_masked'), # ('outputnode.background_mask', 'preprocessed.mp2rage.background_masking.@background_mask') # ]), (mgzconvert, sink, [('outputnode.anat_head', 'preprocessed.anat.@head'), ('outputnode.anat_brain', 'preprocessed.anat.@brain'), ('outputnode.func_mask', 'preprocessed.anat.@func_mask'), ('outputnode.wmedge', 'preprocessed.anat.@wmedge'), #('outputnode.wmseg', 'preprocessed.mp2rage.brain_extraction.@wmseg') ]), (normalize, sink, [('outputnode.anat2std', 'preprocessed.anat.@anat2std'), ('outputnode.anat2std_transforms', 'preprocessed.anat.transforms2mni.@anat2std_transforms'), ('outputnode.std2anat_transforms', 'preprocessed.anat.transforms2mni.@std2anat_transforms')]) ]) #struct_preproc.write_graph(dotfilename='struct_preproc.dot', graph2use='colored', format='pdf', simple_form=True) struct_preproc.run()
experiment_dir = '/home/in/aeed/poldrack_gabmling/' # subject_list = [ # 'sub-01', 'sub-02', 'sub-03', 'sub-04', 'sub-05', 'sub-06', 'sub-08', 'sub-09', # 'sub-10', 'sub-11', 'sub-13', 'sub-14', 'sub-15', 'sub-16'] subject_list = ['sub-02'] output_dir = '/home/in/aeed/poldrack_gabmling/output_MGT_poldrack_proc_2nd_level' working_dir = '/home/in/aeed/poldrack_gabmling/workingdir_MGT_poldrack_proc_2nd_level' no_runs = 3 proc_2nd_level = Workflow(name='proc_2nd_level') proc_2nd_level.base_dir = opj(experiment_dir, working_dir) #========================================================================================================================================================== # In[3]: #to prevent nipype from iterating over the anat image with each func run-, you need seperate #nodes to select the files #and this will solve the problem I have for almost 6 months #but notice that in the sessions, you have to iterate also over subject_id to get the {subject_id} var # Infosource - a function free node to iterate over the list of subject names infosource = Node(IdentityInterface(fields=['subject_id']), name="infosource") infosource.iterables = [('subject_id', subject_list)] #========================================================================================================================================================== # In[4]:
# cutoff volumes = 1/(2*TR*cutoff in Hz) # https://www.jiscmail.ac.uk/cgi-bin/webadmin?A2=ind1205&L=FSL&P=R57592&1=FSL&9=A&I=-3&J=on&d=No+Match%3BMatch%3BMatches&z=4 lp = 1.0 / (2 * 1.4 * 0.1) hp = 1.0 / (2 * 1.4 * 0.01) bandpass_filter = Node(fsl.TemporalFilter(lowpass_sigma=lp, highpass_sigma=hp), name="bandpass_filter") bandpass_filter.plugin_args = {"initial_specs": "request_memory = 30000"} preproc.connect(remove_noise, "out_file", bandpass_filter, "in_file") preproc.connect(bandpass_filter, "out_file", outputnode, "filtered_file") ################################################################################################################################### # in and out preproc.base_dir = "/scr/kansas1/huntenburg/" preproc.config["execution"] = {"remove_unnecessary_outputs": "False"} out_dir = "/scr/" data_dir = "/scr/" subjects = ["LEMON006"] # ,'LEMON001','LEMON087','LEMON030','LEMON044','LEMON071'] # infosource to iterate over subjects subject_infosource = Node(util.IdentityInterface(fields=["subject_id"]), name="subject_infosource") subject_infosource.iterables = ("subject_id", subjects) # infosource to iterate over coregistration methods cor_method_infosource = Node(util.IdentityInterface(fields=["cor_method"]), name="cor_method_infosource") cor_method_infosource.iterables = ("cor_method", ["lin_ts"]) # , 'lin_ts', 'nonlin_ts', 'fmap_ts', 'topup_ts'])
subjects=list(subjects['DB']) subjects.remove('KSMT') sessions = ['rest1_1', 'rest1_2', 'rest2_1', 'rest2_2'] # directories working_dir = '/scr/ilz3/myelinconnect/working_dir/' data_dir= '/scr/ilz3/myelinconnect/' final_dir = '/scr/ilz3/myelinconnect/mappings/rest2highres/' # set fsl output type to nii.gz fsl.FSLCommand.set_default_output_type('NIFTI_GZ') # main workflow mapping2struct = Workflow(name='mapping2struct') mapping2struct.base_dir = working_dir mapping2struct.config['execution']['crashdump_dir'] = mapping2struct.base_dir + "/crash_files" # iterate over subjects subject_infosource = Node(util.IdentityInterface(fields=['subject']), name='subject_infosource') subject_infosource.iterables=[('subject', subjects)] # iterate over sessions session_infosource = Node(util.IdentityInterface(fields=['session']), name='session_infosource') session_infosource.iterables=[('session', sessions)] # select files templates={'mapping': 'mappings/rest/fixed_hdr/corr_{subject}_{session}_roi_detrended_median_corrected_mapping_fixed.nii.gz', 'epi2highres_lin_itk' : 'resting/preprocessed/{subject}/{session}/registration/epi2highres_lin.txt',
def create_rsfMRI_preproc_pipeline(working_dir, freesurfer_dir, ds_dir, use_fs_brainmask, name='rsfMRI_preprocessing'): # initiate workflow rsfMRI_preproc_wf = Workflow(name=name) rsfMRI_preproc_wf.base_dir = os.path.join(working_dir, 'LeiCA_resting') ds_dir = os.path.join(ds_dir, name) # set fsl output fsl.FSLCommand.set_default_output_type('NIFTI_GZ') # inputnode inputnode = Node(util.IdentityInterface(fields=['epi', 't1w', 'subject_id', 'TR_ms', 'vols_to_drop', 'lat_ventricle_mask_MNI', 'lp_cutoff_freq', 'hp_cutoff_freq']), name='inputnode') # outputnode outputnode = Node(util.IdentityInterface(fields=['epi_moco', 'rs_preprocessed', 'epi_2_MNI_warp']), name='outputnode') # MOCO moco = create_moco_pipeline(working_dir, ds_dir, 'motion_correction') rsfMRI_preproc_wf.connect(inputnode, 'epi', moco, 'inputnode.epi') rsfMRI_preproc_wf.connect(inputnode, 'vols_to_drop', moco, 'inputnode.vols_to_drop') # STRUCT PREPROCESSING struct_preproc = create_struct_preproc_pipeline(working_dir, freesurfer_dir, ds_dir, use_fs_brainmask, 'struct_preproc') rsfMRI_preproc_wf.connect(inputnode, 't1w', struct_preproc, 'inputnode.t1w') rsfMRI_preproc_wf.connect(inputnode, 'subject_id', struct_preproc, 'inputnode.subject_id') # REGISTRATIONS reg = create_registration_pipeline(working_dir, freesurfer_dir, ds_dir, 'registration') rsfMRI_preproc_wf.connect(moco, 'outputnode.initial_mean_epi_moco', reg, 'inputnode.initial_mean_epi_moco') rsfMRI_preproc_wf.connect(inputnode, 't1w', reg, 'inputnode.t1w') rsfMRI_preproc_wf.connect(struct_preproc, 'outputnode.t1w_brain', reg, 'inputnode.t1w_brain') rsfMRI_preproc_wf.connect(struct_preproc, 'outputnode.wm_mask_4_bbr', reg, 'inputnode.wm_mask_4_bbr') rsfMRI_preproc_wf.connect(struct_preproc, 'outputnode.struct_brain_mask', reg, 'inputnode.struct_brain_mask') rsfMRI_preproc_wf.connect(inputnode, 'subject_id', reg, 'inputnode.subject_id') rsfMRI_preproc_wf.connect(reg, 'outputnode.epi_2_MNI_warp', outputnode, 'epi_2_MNI_warp') # DESKULL EPI deskull = create_deskull_pipeline(working_dir, ds_dir, 'deskull') rsfMRI_preproc_wf.connect(moco, 'outputnode.epi_moco', deskull, 'inputnode.epi_moco') rsfMRI_preproc_wf.connect(struct_preproc, 'outputnode.struct_brain_mask', deskull, 'inputnode.struct_brain_mask') rsfMRI_preproc_wf.connect(reg, 'outputnode.struct_2_epi_mat', deskull, 'inputnode.struct_2_epi_mat') # DENOISE denoise = create_denoise_pipeline(working_dir, ds_dir, 'denoise') rsfMRI_preproc_wf.connect(inputnode, 'TR_ms', denoise, 'inputnode.TR_ms') rsfMRI_preproc_wf.connect(inputnode, 'subject_id', denoise, 'inputnode.subject_id') rsfMRI_preproc_wf.connect(inputnode, 'lat_ventricle_mask_MNI', denoise, 'inputnode.lat_ventricle_mask_MNI') rsfMRI_preproc_wf.connect(moco, 'outputnode.par_moco', denoise, 'inputnode.par_moco') rsfMRI_preproc_wf.connect(deskull, 'outputnode.epi_deskulled', denoise, 'inputnode.epi') rsfMRI_preproc_wf.connect(deskull, 'outputnode.mean_epi', denoise, 'inputnode.mean_epi') rsfMRI_preproc_wf.connect(deskull, 'outputnode.brain_mask_epiSpace', denoise, 'inputnode.brain_mask_epiSpace') rsfMRI_preproc_wf.connect(reg, 'outputnode.struct_2_epi_mat', denoise, 'inputnode.struct_2_epi_mat') rsfMRI_preproc_wf.connect(reg, 'outputnode.MNI_2_epi_warp', denoise, 'inputnode.MNI_2_epi_warp') rsfMRI_preproc_wf.connect(struct_preproc, 'outputnode.wm_mask', denoise, 'inputnode.wm_mask') rsfMRI_preproc_wf.connect(struct_preproc, 'outputnode.csf_mask', denoise, 'inputnode.csf_mask') rsfMRI_preproc_wf.connect(inputnode, 'lp_cutoff_freq', denoise, 'inputnode.lp_cutoff_freq') rsfMRI_preproc_wf.connect(inputnode, 'hp_cutoff_freq', denoise, 'inputnode.hp_cutoff_freq') rsfMRI_preproc_wf.connect(denoise, 'outputnode.rs_preprocessed', outputnode, 'rs_preprocessed') # QC qc = create_qc_pipeline(working_dir, ds_dir, 'qc') rsfMRI_preproc_wf.connect(inputnode, 'subject_id', qc, 'inputnode.subject_id') rsfMRI_preproc_wf.connect(moco, 'outputnode.par_moco', qc, 'inputnode.par_moco') rsfMRI_preproc_wf.connect(deskull, 'outputnode.epi_deskulled', qc, 'inputnode.epi_deskulled') rsfMRI_preproc_wf.connect(deskull, 'outputnode.brain_mask_epiSpace', qc, 'inputnode.brain_mask_epiSpace') rsfMRI_preproc_wf.connect([(struct_preproc, qc, [('outputnode.t1w_brain', 'inputnode.t1w_brain'), ('outputnode.struct_brain_mask', 'inputnode.struct_brain_mask')])]) rsfMRI_preproc_wf.connect([(reg, qc, [('outputnode.mean_epi_structSpace', 'inputnode.mean_epi_structSpace'), ('outputnode.mean_epi_MNIspace', 'inputnode.mean_epi_MNIspace'), ('outputnode.struct_MNIspace', 'inputnode.struct_MNIspace'), ('outputnode.struct_2_MNI_warp', 'inputnode.struct_2_MNI_warp')])]) rsfMRI_preproc_wf.connect(denoise, 'outputnode.outlier_files', qc, 'inputnode.outlier_files') rsfMRI_preproc_wf.connect(denoise, 'outputnode.rs_preprocessed', qc, 'inputnode.rs_preprocessed') rsfMRI_preproc_wf.write_graph(dotfilename=rsfMRI_preproc_wf.name, graph2use='orig', format='pdf') rsfMRI_preproc_wf.write_graph(dotfilename=rsfMRI_preproc_wf.name, graph2use='colored', format='pdf') return rsfMRI_preproc_wf
# field_methodlist=[] # for field in fields: # fieldlist=[] # for subject in subjects: # fieldlist.append(mask_dir+subject+'/fieldcompare/fields/'+field+'_field.nii.gz') # field_methodlist.append(fieldlist) # '''basic workflow ======================= ''' # create workflow group = Workflow(name='group') group.base_dir=working_dir # sink sink = Node(nio.DataSink(base_directory=out_dir, parameterization=False), name='sink') '''groupmeans and sdv ======================= ''' # merge means merger = MapNode(fsl.Merge(dimension='t'), iterfield=['in_files'], name='merger')
relwarp=True, out_file='topup_ts.nii.gz', datatype='float'), name='apply_topup') apply_ts.connect([(inputnode, apply_topup, [('moco_ts', 'in_file'), ('topup_fullwarp', 'field_file')]), (resamp_anat, apply_topup, [('out_file', 'ref_file')]), (apply_topup, outputnode, [('out_file', 'topup_ts')]) ]) apply_topup.plugin_args={'initial_specs': 'request_memory = 8000'} # set up workflow, in- and output apply_ts.base_dir='/scr/kansas1/huntenburg/' data_dir='/scr/jessica2/Schaare/LEMON/' #out_dir = '/scr/kansas1/huntenburg/timeseries/' #applywarp_linear.config['execution']={'remove_unnecessary_outputs': 'False'} apply_ts.config['execution']['crashdump_dir'] = apply_ts.base_dir + "/crash_files" # reading subjects from file #subjects=['LEMON003'] subjects=[] f = open('/scr/jessica2/Schaare/LEMON/done_freesurfer.txt','r') for line in f: subjects.append(line.strip()) subjects.remove('LEMON007') subjects.remove('LEMON027')
def learning_prepare_data_wf(working_dir, ds_dir, template_lookup_dict, behav_file, qc_file, in_data_name_list, data_lookup_dict, use_n_procs, plugin_name): import os from nipype import config from nipype.pipeline.engine import Node, Workflow import nipype.interfaces.utility as util import nipype.interfaces.io as nio from prepare_data_utils import vectorize_and_aggregate from itertools import chain # ensure in_data_name_list is list of lists in_data_name_list = [i if type(i) == list else [i] for i in in_data_name_list] in_data_name_list_unique = list(set(chain.from_iterable(in_data_name_list))) ##################################### # GENERAL SETTINGS ##################################### wf = Workflow(name='learning_prepare_data_wf') wf.base_dir = os.path.join(working_dir) nipype_cfg = dict(logging=dict(workflow_level='DEBUG'), execution={'stop_on_first_crash': False, 'remove_unnecessary_outputs': False, 'job_finished_timeout': 120, 'hash_method': 'timestamp'}) config.update_config(nipype_cfg) wf.config['execution']['crashdump_dir'] = os.path.join(working_dir, 'crash') ds = Node(nio.DataSink(), name='ds') ds.inputs.base_directory = os.path.join(ds_dir, 'group_learning_prepare_data') ds.inputs.regexp_substitutions = [ # ('subject_id_', ''), ('_parcellation_', ''), ('_bp_freqs_', 'bp_'), ('_extraction_method_', ''), ('_subject_id_[A0-9]*/', '') ] ds_X = Node(nio.DataSink(), name='ds_X') ds_X.inputs.base_directory = os.path.join(ds_dir, 'vectorized_aggregated_data') ds_pdf = Node(nio.DataSink(), name='ds_pdf') ds_pdf.inputs.base_directory = os.path.join(ds_dir, 'pdfs') ds_pdf.inputs.parameterization = False ##################################### # SET ITERATORS ##################################### # SUBJECTS ITERATOR in_data_name_infosource = Node(util.IdentityInterface(fields=['in_data_name']), name='in_data_name_infosource') in_data_name_infosource.iterables = ('in_data_name', in_data_name_list_unique) mulitmodal_in_data_name_infosource = Node(util.IdentityInterface(fields=['multimodal_in_data_name']), name='mulitmodal_in_data_name_infosource') mulitmodal_in_data_name_infosource.iterables = ('multimodal_in_data_name', in_data_name_list) ############################################################################################################### # GET SUBJECTS INFO # create subjects list based on selection criteria def create_df_fct(behav_file, qc_file): import pandas as pd import os df = pd.read_pickle(behav_file) qc = pd.read_pickle(qc_file) df_all = qc.join(df, how='inner') assert df_all.index.is_unique, 'duplicates in df index. fix before cont.' df_all_subjects_pickle_file = os.path.abspath('df_all.pkl') df_all.to_pickle(df_all_subjects_pickle_file) full_subjects_list = df_all.index.values return df_all_subjects_pickle_file, full_subjects_list create_df = Node(util.Function(input_names=['behav_file', 'qc_file'], output_names=['df_all_subjects_pickle_file', 'full_subjects_list'], function=create_df_fct), name='create_df') create_df.inputs.behav_file = behav_file create_df.inputs.qc_file = qc_file ############################################################################################################### # CREAE FILE LIST # of files that will be aggregted def create_file_list_fct(subjects_list, in_data_name, data_lookup_dict, template_lookup_dict): file_list = [] for s in subjects_list: file_list.append(data_lookup_dict[in_data_name]['path_str'].format(subject_id=s)) if 'matrix_name' in data_lookup_dict[in_data_name].keys(): matrix_name = data_lookup_dict[in_data_name]['matrix_name'] else: matrix_name = None if 'parcellation_path' in data_lookup_dict[in_data_name].keys(): parcellation_path = data_lookup_dict[in_data_name]['parcellation_path'] else: parcellation_path = None if 'fwhm' in data_lookup_dict[in_data_name].keys(): fwhm = data_lookup_dict[in_data_name]['fwhm'] if fwhm == 0: fwhm = None else: fwhm = None if 'mask_name' in data_lookup_dict[in_data_name].keys(): mask_path = template_lookup_dict[data_lookup_dict[in_data_name]['mask_name']] else: mask_path = None if 'use_diagonal' in data_lookup_dict[in_data_name].keys(): use_diagonal = data_lookup_dict[in_data_name]['use_diagonal'] else: use_diagonal = False if 'use_fishers_z' in data_lookup_dict[in_data_name].keys(): use_fishers_z = data_lookup_dict[in_data_name]['use_fishers_z'] else: use_fishers_z = False if 'df_col_names' in data_lookup_dict[in_data_name].keys(): df_col_names = data_lookup_dict[in_data_name]['df_col_names'] else: df_col_names = None return file_list, matrix_name, parcellation_path, fwhm, mask_path, use_diagonal, use_fishers_z, df_col_names create_file_list = Node(util.Function(input_names=['subjects_list', 'in_data_name', 'data_lookup_dict', 'template_lookup_dict', ], output_names=['file_list', 'matrix_name', 'parcellation_path', 'fwhm', 'mask_path', 'use_diagonal', 'use_fishers_z', 'df_col_names'], function=create_file_list_fct), name='create_file_list') wf.connect(create_df, 'full_subjects_list', create_file_list, 'subjects_list') wf.connect(in_data_name_infosource, 'in_data_name', create_file_list, 'in_data_name') create_file_list.inputs.data_lookup_dict = data_lookup_dict create_file_list.inputs.template_lookup_dict = template_lookup_dict ############################################################################################################### # VECTORIZE AND AGGREGATE SUBJECTS # stack single subject np arrays vertically vectorize_aggregate_subjects = Node(util.Function(input_names=['in_data_file_list', 'mask_file', 'matrix_name', 'parcellation_path', 'fwhm', 'use_diagonal', 'use_fishers_z', 'df_file', 'df_col_names'], output_names=['vectorized_aggregated_file', 'unimodal_backprojection_info_file'], function=vectorize_and_aggregate), name='vectorize_aggregate_subjects') wf.connect(create_file_list, 'file_list', vectorize_aggregate_subjects, 'in_data_file_list') wf.connect(create_file_list, 'mask_path', vectorize_aggregate_subjects, 'mask_file') wf.connect(create_file_list, 'matrix_name', vectorize_aggregate_subjects, 'matrix_name') wf.connect(create_file_list, 'parcellation_path', vectorize_aggregate_subjects, 'parcellation_path') wf.connect(create_file_list, 'fwhm', vectorize_aggregate_subjects, 'fwhm') wf.connect(create_file_list, 'use_diagonal', vectorize_aggregate_subjects, 'use_diagonal') wf.connect(create_file_list, 'use_fishers_z', vectorize_aggregate_subjects, 'use_fishers_z') wf.connect(create_df, 'df_all_subjects_pickle_file', vectorize_aggregate_subjects, 'df_file') wf.connect(create_file_list, 'df_col_names', vectorize_aggregate_subjects, 'df_col_names') wf.connect(create_df, 'df_all_subjects_pickle_file', ds_X, 'df_all_subjects_pickle_file') wf.connect(vectorize_aggregate_subjects, 'vectorized_aggregated_file', ds_X, 'X_file') wf.connect(vectorize_aggregate_subjects, 'unimodal_backprojection_info_file', ds_X, 'unimodal_backprojection_info_file') ##################################### # RUN WF ##################################### 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})
workdir = '/scratch/PSB6351_2017/crash/mattfeld' workingdir = os.path.join(workdir, 'antsreg') #working directory if not os.path.exists(workingdir): os.makedirs(workingdir) fs_skullstrip_wf = create_freesurfer_skullstrip_workflow() fs_skullstrip_wf.inputs.inputspec.subjects_dir = fs_projdir sids = [ 'sub-01', 'sub-02', 'sub-03', 'sub-04', 'sub-05', 'sub-06', 'sub-07', 'sub-09', 'sub-10', 'sub-11', 'sub-12', 'sub-13', 'sub-14', 'sub-15' ] # Set up the FreeSurfer skull stripper work flow antsreg_wf = Workflow(name='antsreg_wf') antsreg_wf.base_dir = workingdir subjID_infosource = Node( IdentityInterface(fields=['subject_id', 'subjects_dir']), name='subjID_infosource') subjID_infosource.iterables = ('subject_id', sids) antsreg_wf.connect(subjID_infosource, 'subject_id', fs_skullstrip_wf, 'inputspec.subject_id') # Use a JoinNode to aggregrate all of the outputs from the fs_skullstrip_wf reg = Node(ants.Registration(), name='antsRegister') reg.inputs.fixed_image = '/scratch/PSB6351_2017/ds008_R2.0.0/template/T1_template/study_template.nii.gz' reg.inputs.output_transform_prefix = "output_" reg.inputs.transforms = ['Rigid', 'Affine', 'SyN'] reg.inputs.transform_parameters = [(0.1, ), (0.1, ), (0.2, 3.0, 0.0)]
def test_mapnode(config, moving_image, fixed_image): import nipype.interfaces.fsl as fsl from nipype.pipeline.engine import Node, Workflow, MapNode from nipype.interfaces.io import DataSink, DataGrabber from nipype.interfaces.utility import IdentityInterface, Function import os moving_mse = get_mseid(moving_image[0]) fixed_mse = get_mseid(fixed_image[0]) print(moving_mse, fixed_mse) seriesNum_moving = get_seriesnum(moving_image) seriesNum_fixed = get_seriesnum(fixed_image) print("seriesNum for moving and fixed are {}, {} respectively".format(seriesNum_moving, seriesNum_fixed)) register = Workflow(name="test_mapnode") register.base_dir = config["working_directory"] inputnode = Node(IdentityInterface(fields=["moving_image", "fixed_image"]), name="inputspec") inputnode.inputs.moving_image = moving_image inputnode.inputs.fixed_image = fixed_image check_len = Node(Function(input_names=["moving_image", "fixed_image"], output_names=["new_moving_image", "new_fixed_image"], function=check_length), name="check_len") register.connect(inputnode, 'moving_image', check_len, 'moving_image') register.connect(inputnode, 'fixed_image', check_len, 'fixed_image') flt_rigid = MapNode(fsl.FLIRT(), iterfield=['in_file', 'reference'], name="FLIRT_RIGID") flt_rigid.inputs.dof = 6 flt_rigid.output_type = 'NIFTI_GZ' register.connect(check_len, 'new_moving_image', flt_rigid, 'in_file') register.connect(check_len, 'new_fixed_image', flt_rigid, 'reference') sinker = Node(DataSink(), name="DataSink") sinker.inputs.base_directory = '/data/henry7/james' sinker.inputs.container = 'test_mapnode' """ def getsubs(moving_image, fixed_image, moving_mse, fixed_mse, seriesNum_moving, seriesNum_fixed): N = len(moving_image) * len(fixed_image) subs = [] print("N is :" ,N) for i in range(N): for j in seriesNum_moving: seri_moving = '' if j != '': seri_moving = '_' + j for k in seriesNum_fixed: seri_fixed = '' if k != '': seri_fixed = '_' + k subs += [('_FLIRT_RIGID%d'%i, moving_mse + seri_moving + '__' + fixed_mse + seri_fixed)] print("subs are: ", subs) return subs """ def getsubs(moving_image, fixed_image, moving_mse, fixed_mse): N = len(moving_image) * len(fixed_image) subs = [('_flirt', '_trans')] if N == 1: subs += [('_FLIRT_RIGID%d'%0, moving_mse + '__' + fixed_mse)] else: for i in range(N): subs += [('_FLIRT_RIGID%d'%i, moving_mse + '__' + fixed_mse + '_' + str(i+1))] return subs get_subs = Node(Function(input_names=["moving_image", "fixed_image", "moving_mse", "fixed_mse"], output_names=["subs"], function=getsubs), name="get_subs") get_subs.inputs.moving_mse = moving_mse get_subs.inputs.fixed_mse = fixed_mse # get_subs.inputs.seriesNum_moving = seriesNum_moving # get_subs.inputs.seriesNum_fixed = seriesNum_fixed register.connect(inputnode, 'moving_image', get_subs, 'moving_image') register.connect(inputnode, 'fixed_image', get_subs, "fixed_image") register.connect(get_subs, 'subs', sinker, 'substitutions') register.connect(flt_rigid, 'out_file', sinker, '@mapnode_out') register.write_graph(graph2use='orig') register.config["Execution"] = {"keep_inputs": True, "remove_unnecessary_outputs": False} return register
# mlab.MatlabCommand.set_default_matlab_cmd("matlab -nodesktop -nosplash") # mlab.MatlabCommand.set_default_paths('/home/amr/Documents/MATLAB/toolbox/spm8') #----------------------------------------------------------------------------------------------------- # In[2]: experiment_dir = '/media/amr/HDD/Work/Stimulation' subject_list = ['003','005','008','011','018','019','020', '059', '060','062','063','066'] session_list = ['run001', 'run002', 'run003'] output_dir = '10Hz_10s_Task_Based_OutputDir' working_dir = '10Hz_10s_Task_Based_WorkingDir' preproc_task = Workflow(name = 'preproc_task') preproc_task.base_dir = opj(experiment_dir, working_dir) #----------------------------------------------------------------------------------------------------- # In[20]: # Infosource - a function free node to iterate over the list of subject names infosource = Node(IdentityInterface(fields=['subject_id','session_id']), name="infosource") infosource.iterables = [('subject_id', subject_list), ('session_id', session_list)] #----------------------------------------------------------------------------------------------------- # In[21]: templates = { 'Anat_Bias' : '/media/amr/HDD/Work/Stimulation/Registration_Stimulation_WorkingDir/Registration_Stimulation/_subject_id_{subject_id}/BiasFieldCorrection/Anat_{subject_id}_bet_corrected.nii.gz',
copes,varcopes, tstats = [[] for i in range(3)] EV_indices = EV_rpe_design_df.index for c,contrast in enumerate(contrasts): if c in EV_indices: copes.append(os.path.join(sub_stats_dir,'%s%i.nii.gz'%('cope',contrast))) varcopes.append(os.path.join(sub_stats_dir,'%s%i.nii.gz'%('varcope',contrast))) tstats.append(os.path.join(sub_stats_dir,'%s%i.nii.gz'%('tstat',contrast))) ###### NIPYPE WORKFLOW 1: RPE as mean-centered covariate ###### Parkflow_rpe = Workflow(name='workflow') Parkflow_rpe.base_dir = sub_rpe_workflow_dir # Create nodes copemerge = Node(interface=fsl.Merge( dimension='t', in_files=copes), name='copemerge') varcopemerge = Node(interface=fsl.Merge( dimension='t', in_files=varcopes), name='varcopemerge') multregmodel = Node(interface=fsl.MultipleRegressDesign( contrasts=[], regressors={}),
""" #test only hippocampus_part from nipype.pipeline.engine import Node, Workflow import nipype.interfaces.utility as util import nipype.interfaces.io as nio import nipype.interfaces.fsl as fsl from hc import create_transform_hc from get_T1_brainmask import create_get_T1_brainmask freesurfer_dir = "/data/pt_nro148/3T/restingstate_and_freesurfer/preprocessing/freesurfer" subject = 'RSV002' working_dir = "/data/pt_nro148/3T/restingstate_and_freesurfer/wd/hipp_connectivity/left/" + subject hc_connec = Workflow(name='hc_connec') hc_connec.base_dir = working_dir get_T1_brainmask = create_get_T1_brainmask() get_T1_brainmask.inputs.inputnode.fs_subjects_dir = freesurfer_dir get_T1_brainmask.inputs.inputnode.fs_subject_id = subject transform_hc = create_transform_hc() transform_hc.inputs.inputnode.fs_subjects_dir = freesurfer_dir transform_hc.inputs.inputnode.fs_subject_id = subject transform_hc.inputs.inputnode.resolution = 2 transform_hc.inputs.inputnode.working_dir = working_dir hc_connec.connect([(get_T1_brainmask, transform_hc, [('outputnode.T1', 'inputnode.anat_head')])]) hc_connec.run()
from nipype.pipeline.engine import Node, Workflow import nipype.interfaces.io as nio import nipype.interfaces.utility as util import nipype.interfaces.fsl as fsl import os epireg = Workflow(name='epireg') epireg.base_dir='/scr/ilz1/nonlinear_registration/lemon/working_dir_epireg/' data_dir = '/scr/ilz1/nonlinear_registration/lemon/results/' output_dir = '/scr/ilz1/nonlinear_registration/lemon/results/' echo_space=0.00067 #in sec te_diff=2.46 #in ms pe_dir='y-' flirt_pe_dir=-2 subjects=['LEMON001'] #subjects=os.listdir(data_dir) # infosource to iterate over subjects infosource = Node(util.IdentityInterface(fields=['subject_id']), name='infosource') infosource.iterables=('subject_id', subjects) # datasource to grab data datasource = Node(nio.DataGrabber(infields=['subject_id'], outfields=['anat_head','anat_brain','epi_mean', 'fmap', 'mag_brain', 'mag_head'], base_directory = os.path.abspath(data_dir), template = '%s/%s/%s/%s', template_args=dict(anat_head=[['subject_id','realignment', 'subject_id', '?']], anat_brain=[['subject_id','realignment', 'subject_id', '?']], epi_mean=[['subject_id','realignment', 'subject_id', 'cmrrmbep2drestings007a001_mcf_mean.nii.gz']], fmap=[['subject_id','fieldmap', 'subject_id', 'grefieldmappings004a2001_fslprepared.nii.gz']],
# In[ ]: if sequence=='mux6': prepreprocflow = Workflow(name='prepreprocflow') prepreprocflow.connect([(infosource,select_pes, [('subject_id','subject_id')]), (infosource,select_func, [('subject_id','subject_id')]), (select_pes,trim_PEs, [('pes','in_file')]), (trim_PEs,sort_pe_list, [('roi_file','pes')]), (sort_pe_list,topup, [('merged_pes','in_file')]), (topup, apply_topup, [('out_fieldcoef','in_topup_fieldcoef'), ('out_movpar','in_topup_movpar')]), (select_func, apply_topup, [('func','in_files')]), (apply_topup, datasink, [('out_corrected','unwarped_funcs')]) ]) prepreprocflow.base_dir = workflow_dir #prepreprocflow.write_graph(graph2use='flat') prepreprocflow.run('MultiProc', plugin_args={'n_procs': proc_cores, 'memory_gb':10}) # ### Basic Preprocessing # In[ ]: if sequence=='spiral': func_template = {'func': raw_data + '/%s/rest*.nii.gz'} select_func = Node(DataGrabber(sort_filelist=True, template = raw_data + '/%s/rest*.nii.gz', field_template = func_template, base_directory=raw_data, infields=['subject_id'],
scans = ['4', '27'] recons = ['mag'] vol_to_remove = 10 motion_norm = 0.75 z_thr = 3 TR = 1 # directories working_dir = '/home/julia/projects/real_data/working_dir/' data_dir = '/home/julia/projects/real_data/mouse_visual/%s/' % dataset out_dir = '/home/julia/projects/real_data/mouse_visual/%s/processed/func/' % dataset # main workflow preproc_func = Workflow(name='preproc_func') preproc_func.base_dir = working_dir preproc_func.config['execution'][ 'crashdump_dir'] = preproc_func.base_dir + "/crash_files" # iterate over scans scan_infosource = Node(util.IdentityInterface(fields=['scan']), name='scan_infosource') scan_infosource.iterables = [('scan', scans)] # iterate over recons recon_infosource = Node(util.IdentityInterface(fields=['recon']), name='recon_infosource') recon_infosource.iterables = [('recon', recons)] # select files templates = {
def create_registration_pipeline(working_dir, freesurfer_dir, ds_dir, name='registration'): """ find transformations between struct, funct, and MNI """ # initiate workflow reg_wf = Workflow(name=name) reg_wf.base_dir = os.path.join(working_dir, 'LeiCA_resting', 'rsfMRI_preprocessing') # set fsl output fsl.FSLCommand.set_default_output_type('NIFTI_GZ') freesurfer.FSCommand.set_default_subjects_dir(freesurfer_dir) # inputnode inputnode = Node(util.IdentityInterface(fields=['initial_mean_epi_moco', 't1w', 't1w_brain', 'subject_id', 'wm_mask_4_bbr', 'struct_brain_mask']), name='inputnode') outputnode = Node(util.IdentityInterface(fields=['struct_2_MNI_warp', 'epi_2_struct_mat', 'struct_2_epi_mat', 'epi_2_MNI_warp', 'MNI_2_epi_warp', 'fs_2_struct_mat', 'mean_epi_structSpace', 'mean_epi_MNIspace', 'struct_MNIspace']), name='outputnode') ds = Node(nio.DataSink(base_directory=ds_dir), name='ds') ds.inputs.substitutions = [('_TR_id_', 'TR_')] ########################################## # TOC REGISTRATION MATS AND WARPS ########################################## # I. STRUCT -> MNI ## 1. STRUCT -> MNI with FLIRT ## 2. CALC. WARP STRUCT -> MNI with FNIRT # II.EPI -> STRUCT ## 3. calc EPI->STRUCT initial registration ## 4. run EPI->STRUCT via bbr ## 5. INVERT to get: STRUCT -> EPI # III. COMBINE I. & II.: EPI -> MNI ## 6. COMBINE MATS: EPI -> MNI ## 7. MNI -> EPI ########################################## # CREATE REGISTRATION MATS AND WARPS ########################################## # I. STRUCT -> MNI ########################################## # 1. REGISTER STRUCT -> MNI with FLIRT struct_2_MNI_mat = Node(fsl.FLIRT(dof=12), name='struct_2_MNI_mat') struct_2_MNI_mat.inputs.reference = fsl.Info.standard_image('MNI152_T1_2mm_brain.nii.gz') reg_wf.connect(inputnode, 't1w_brain', struct_2_MNI_mat, 'in_file') reg_wf.connect(struct_2_MNI_mat, 'out_matrix_file', outputnode, 'struct_2_MNI_mat_flirt') # 2. CALC. WARP STRUCT -> MNI with FNIRT # cf. wrt. 2mm # https://www.jiscmail.ac.uk/cgi-bin/webadmin?A2=ind1311&L=FSL&P=R86108&1=FSL&9=A&J=on&d=No+Match%3BMatch%3BMatches&z=4 struct_2_MNI_warp = Node(fsl.FNIRT(), name='struct_2_MNI_warp') struct_2_MNI_warp.inputs.config_file = 'T1_2_MNI152_2mm' struct_2_MNI_warp.inputs.ref_file = fsl.Info.standard_image('MNI152_T1_2mm.nii.gz') struct_2_MNI_warp.inputs.field_file = 'struct_2_MNI_warp.nii.gz' struct_2_MNI_warp.plugin_args = {'submit_specs': 'request_memory = 4000'} reg_wf.connect(inputnode, 't1w', struct_2_MNI_warp, 'in_file') reg_wf.connect(struct_2_MNI_mat, 'out_matrix_file', struct_2_MNI_warp, 'affine_file') reg_wf.connect(struct_2_MNI_warp, 'field_file', ds, 'registration.struct_2_MNI_warp') reg_wf.connect(struct_2_MNI_warp, 'field_file', outputnode, 'struct_2_MNI_warp') reg_wf.connect(struct_2_MNI_warp, 'warped_file', outputnode, 'struct_MNIspace') reg_wf.connect(struct_2_MNI_warp, 'warped_file', ds, 'registration.struct_MNIspace') # II.EPI -> STRUCT (via bbr) ########################################## # 3. calc EPI->STRUCT initial registration with flirt dof=6 and corratio epi_2_struct_flirt6_mat = Node(fsl.FLIRT(dof=6, cost='corratio'), name='epi_2_struct_flirt6_mat') epi_2_struct_flirt6_mat.inputs.out_file = 'epi_structSpace_flirt6.nii.gz' reg_wf.connect(inputnode, 't1w_brain', epi_2_struct_flirt6_mat, 'reference') reg_wf.connect(inputnode, 'initial_mean_epi_moco', epi_2_struct_flirt6_mat, 'in_file') # 4. run EPI->STRUCT via bbr bbr_shedule = os.path.join(os.getenv('FSLDIR'), 'etc/flirtsch/bbr.sch') epi_2_struct_bbr_mat = Node(interface=fsl.FLIRT(dof=6, cost='bbr'), name='epi_2_struct_bbr_mat') epi_2_struct_bbr_mat.inputs.schedule = bbr_shedule epi_2_struct_bbr_mat.inputs.out_file = 'epi_structSpace.nii.gz' reg_wf.connect(inputnode, 'initial_mean_epi_moco', epi_2_struct_bbr_mat, 'in_file') reg_wf.connect(inputnode, 't1w_brain', epi_2_struct_bbr_mat, 'reference') reg_wf.connect(epi_2_struct_flirt6_mat, 'out_matrix_file', epi_2_struct_bbr_mat, 'in_matrix_file') reg_wf.connect(inputnode, 'wm_mask_4_bbr', epi_2_struct_bbr_mat, 'wm_seg') reg_wf.connect(epi_2_struct_bbr_mat, 'out_matrix_file', ds, 'registration.epi_2_struct_mat') reg_wf.connect(epi_2_struct_bbr_mat, 'out_file', outputnode, 'mean_epi_structSpace') # 5. INVERT to get: STRUCT -> EPI struct_2_epi_mat = Node(fsl.ConvertXFM(invert_xfm=True), name='struct_2_epi_mat') reg_wf.connect(epi_2_struct_bbr_mat, 'out_matrix_file', struct_2_epi_mat, 'in_file') reg_wf.connect(struct_2_epi_mat, 'out_file', outputnode, 'struct_2_epi_mat') # III. COMBINE I. & II.: EPI -> MNI ########################################## # 6. COMBINE MATS: EPI -> MNI epi_2_MNI_warp = Node(fsl.ConvertWarp(), name='epi_2_MNI_warp') epi_2_MNI_warp.inputs.reference = fsl.Info.standard_image('MNI152_T1_2mm.nii.gz') reg_wf.connect(epi_2_struct_bbr_mat, 'out_matrix_file', epi_2_MNI_warp, 'premat') # epi2struct reg_wf.connect(struct_2_MNI_warp, 'field_file', epi_2_MNI_warp, 'warp1') # struct2mni reg_wf.connect(epi_2_MNI_warp, 'out_file', outputnode, 'epi_2_MNI_warp') reg_wf.connect(epi_2_MNI_warp, 'out_file', ds, 'registration.epi_2_MNI_warp') # output: out_file # 7. MNI -> EPI 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') reg_wf.connect(epi_2_MNI_warp, 'out_file', MNI_2_epi_warp, 'warp') reg_wf.connect(inputnode, 'initial_mean_epi_moco', MNI_2_epi_warp, 'reference') reg_wf.connect(MNI_2_epi_warp, 'inverse_warp', outputnode, 'MNI_2_epi_warp') # output: inverse_warp ########################################## # TRANSFORM VOLUMES ########################################## # CREATE STRUCT IN EPI SPACE FOR DEBUGGING struct_epiSpace = Node(fsl.ApplyXfm(), name='struct_epiSpace') struct_epiSpace.inputs.out_file = 'struct_brain_epiSpace.nii.gz' reg_wf.connect(inputnode, 't1w_brain', struct_epiSpace, 'in_file') reg_wf.connect(inputnode, 'initial_mean_epi_moco', struct_epiSpace, 'reference') reg_wf.connect(struct_2_epi_mat, 'out_file', struct_epiSpace, 'in_matrix_file') reg_wf.connect(struct_epiSpace, 'out_file', ds, 'QC.struct_brain_epiSpace') # CREATE EPI IN MNI SPACE mean_epi_MNIspace = Node(fsl.ApplyWarp(), name='mean_epi_MNIspace') mean_epi_MNIspace.inputs.ref_file = fsl.Info.standard_image('MNI152_T1_2mm_brain.nii.gz') mean_epi_MNIspace.inputs.out_file = 'mean_epi_MNIspace.nii.gz' reg_wf.connect(inputnode, 'initial_mean_epi_moco', mean_epi_MNIspace, 'in_file') reg_wf.connect(epi_2_MNI_warp, 'out_file', mean_epi_MNIspace, 'field_file') reg_wf.connect(mean_epi_MNIspace, 'out_file', ds, 'registration.mean_epi_MNIspace') reg_wf.connect(mean_epi_MNIspace, 'out_file', outputnode, 'mean_epi_MNIspace') # CREATE MNI IN EPI SPACE FOR DEBUGGING MNI_epiSpace = Node(fsl.ApplyWarp(), name='MNI_epiSpace') MNI_epiSpace.inputs.in_file = fsl.Info.standard_image('MNI152_T1_2mm_brain.nii.gz') MNI_epiSpace.inputs.out_file = 'MNI_epiSpace.nii.gz' reg_wf.connect(inputnode, 'initial_mean_epi_moco', MNI_epiSpace, 'ref_file') reg_wf.connect(MNI_2_epi_warp, 'inverse_warp', MNI_epiSpace, 'field_file') reg_wf.connect(MNI_epiSpace, 'out_file', ds, 'registration.MNI_epiSpace') reg_wf.write_graph(dotfilename=reg_wf.name, graph2use='flat', format='pdf') return reg_wf
onesamplettestdes = Node(OneSampleTTestDesign(), name="onesampttestdes") # EstimateModel - estimate the parameters of the model level2estimate = Node(EstimateModel(estimation_method={'Classical': 1}), name="level2estimate") # EstimateContrast - estimates simple group contrast level2conestimate = Node(EstimateContrast(group_contrast=True), name="level2conestimate") cont1 = ['Group', 'T', ['mean'], [1]] level2conestimate.inputs.contrasts = [cont1] ### # Specify 2nd-Level Analysis Workflow & Connect Nodes l2analysis = Workflow(name='l2analysis') l2analysis.base_dir = opj(experiment_dir, working_dir) # Connect up the 2nd-level analysis components l2analysis.connect([ (onesamplettestdes, level2estimate, [('spm_mat_file', 'spm_mat_file')]), (level2estimate, level2conestimate, [('spm_mat_file', 'spm_mat_file'), ('beta_images', 'beta_images'), ('residual_image', 'residual_image') ]), ]) ### # Input & Output Stream # Infosource - a function free node to iterate over the list of subject names infosource = Node(IdentityInterface(fields=['contrast_id']), name="infosource")
def downsampel_surfs(subject_id, working_dir, freesurfer_dir, ds_dir, plugin_name, use_n_procs): ''' Workflow resamples e.g. native thickness maps to fsaverage5 space ''' ##################################### # GENERAL SETTINGS ##################################### fsl.FSLCommand.set_default_output_type('NIFTI_GZ') fs.FSCommand.set_default_subjects_dir(freesurfer_dir) wf = Workflow(name='freesurfer_downsample') 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.parameterization = False ##################### # ITERATORS ##################### # PARCELLATION ITERATOR infosource = Node(util.IdentityInterface(fields=['hemi', 'surf_measure', 'fwhm', 'target']), name='infosource') infosource.iterables = [('hemi', ['lh', 'rh']), ('surf_measure', ['thickness', 'area']), ('fwhm', [0, 5, 10, 20]), ('target', ['fsaverage3', 'fsaverage4', 'fsaverage5']), ] downsample = Node(fs.model.MRISPreproc(), name='downsample') downsample.inputs.subjects = [subject_id] wf.connect(infosource, 'target', downsample, 'target') wf.connect(infosource, 'hemi', downsample, 'hemi') wf.connect(infosource, 'surf_measure', downsample, 'surf_measure') wf.connect(infosource, 'fwhm', downsample, 'fwhm_source') rename = Node(util.Rename(format_string='%(hemi)s.%(surf_measure)s.%(target)s.%(fwhm)smm'), name='rename') rename.inputs.keep_ext = True wf.connect(infosource, 'target', rename, 'target') wf.connect(infosource, 'hemi', rename, 'hemi') wf.connect(infosource, 'surf_measure', rename, 'surf_measure') wf.connect(infosource, 'fwhm', rename, 'fwhm') wf.connect(downsample, 'out_file', rename, 'in_file') wf.connect(rename, 'out_file', ds, 'surfs.@surfs') # 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 builder(subject_id, subId, project_dir, data_dir, output_dir, output_final_dir, output_interm_dir, layout, anat=None, funcs=None, fmaps=None, task_name='', session=None, apply_trim=False, apply_dist_corr=False, apply_smooth=False, apply_filter=False, mni_template='2mm', apply_n4=True, ants_threads=8, readable_crash_files=False, write_logs=True): """ Core function that returns a workflow. See wfmaker for more details. Args: subject_id: name of subject folder for final outputted sub-folder name subId: abbreviate name of subject for intermediate outputted sub-folder name project_dir: full path to root of project data_dir: full path to raw data files output_dir: upper level output dir (others will be nested within this) output_final_dir: final preprocessed sub-dir name output_interm_dir: intermediate preprcess sub-dir name layout: BIDS layout instance """ ################## ### PATH SETUP ### ################## if session is not None: session = int(session) if session < 10: session = '0' + str(session) else: session = str(session) # Set MNI template MNItemplate = os.path.join(get_resource_path(), 'MNI152_T1_' + mni_template + '_brain.nii.gz') MNImask = os.path.join(get_resource_path(), 'MNI152_T1_' + mni_template + '_brain_mask.nii.gz') MNItemplatehasskull = os.path.join(get_resource_path(), 'MNI152_T1_' + mni_template + '.nii.gz') # Set ANTs files bet_ants_template = os.path.join(get_resource_path(), 'OASIS_template.nii.gz') bet_ants_prob_mask = os.path.join( get_resource_path(), 'OASIS_BrainCerebellumProbabilityMask.nii.gz') bet_ants_registration_mask = os.path.join( get_resource_path(), 'OASIS_BrainCerebellumRegistrationMask.nii.gz') ################################# ### NIPYPE IMPORTS AND CONFIG ### ################################# # Update nipype global config because workflow.config[] = ..., doesn't seem to work # Can't store nipype config/rc file in container anyway so set them globaly before importing and setting up workflow as suggested here: http://nipype.readthedocs.io/en/latest/users/config_file.html#config-file # Create subject's intermediate directory before configuring nipype and the workflow because that's where we'll save log files in addition to intermediate files if not os.path.exists(os.path.join(output_interm_dir, subId, 'logs')): os.makedirs(os.path.join(output_interm_dir, subId, 'logs')) log_dir = os.path.join(output_interm_dir, subId, 'logs') from nipype import config if readable_crash_files: cfg = dict(execution={'crashfile_format': 'txt'}) config.update_config(cfg) config.update_config({ 'logging': { 'log_directory': log_dir, 'log_to_file': write_logs }, 'execution': { 'crashdump_dir': log_dir } }) from nipype import logging logging.update_logging(config) # Now import everything else from nipype.interfaces.io import DataSink from nipype.interfaces.utility import Merge, IdentityInterface from nipype.pipeline.engine import Node, Workflow from nipype.interfaces.nipy.preprocess import ComputeMask from nipype.algorithms.rapidart import ArtifactDetect from nipype.interfaces.ants.segmentation import BrainExtraction, N4BiasFieldCorrection from nipype.interfaces.ants import Registration, ApplyTransforms from nipype.interfaces.fsl import MCFLIRT, TOPUP, ApplyTOPUP from nipype.interfaces.fsl.maths import MeanImage from nipype.interfaces.fsl import Merge as MERGE from nipype.interfaces.fsl.utils import Smooth from nipype.interfaces.nipy.preprocess import Trim from .interfaces import Plot_Coregistration_Montage, Plot_Quality_Control, Plot_Realignment_Parameters, Create_Covariates, Down_Sample_Precision, Create_Encoding_File, Filter_In_Mask ################## ### INPUT NODE ### ################## # Turn functional file list into interable Node func_scans = Node(IdentityInterface(fields=['scan']), name='func_scans') func_scans.iterables = ('scan', funcs) # Get TR for use in filtering below; we're assuming all BOLD runs have the same TR tr_length = layout.get_metadata(funcs[0])['RepetitionTime'] ##################################### ## TRIM ## ##################################### if apply_trim: trim = Node(Trim(), name='trim') trim.inputs.begin_index = apply_trim ##################################### ## DISTORTION CORRECTION ## ##################################### if apply_dist_corr: # Get fmap file locations fmaps = [ f.filename for f in layout.get( subject=subId, modality='fmap', extensions='.nii.gz') ] if not fmaps: raise IOError( "Distortion Correction requested but field map scans not found..." ) # Get fmap metadata totalReadoutTimes, measurements, fmap_pes = [], [], [] for i, fmap in enumerate(fmaps): # Grab total readout time for each fmap totalReadoutTimes.append( layout.get_metadata(fmap)['TotalReadoutTime']) # Grab measurements (for some reason pyBIDS doesn't grab dcm_meta... fields from side-car json file and json.load, doesn't either; so instead just read the header using nibabel to determine number of scans) measurements.append(nib.load(fmap).header['dim'][4]) # Get phase encoding direction fmap_pe = layout.get_metadata(fmap)["PhaseEncodingDirection"] fmap_pes.append(fmap_pe) encoding_file_writer = Node(interface=Create_Encoding_File(), name='create_encoding') encoding_file_writer.inputs.totalReadoutTimes = totalReadoutTimes encoding_file_writer.inputs.fmaps = fmaps encoding_file_writer.inputs.fmap_pes = fmap_pes encoding_file_writer.inputs.measurements = measurements encoding_file_writer.inputs.file_name = 'encoding_file.txt' merge_to_file_list = Node(interface=Merge(2), infields=['in1', 'in2'], name='merge_to_file_list') merge_to_file_list.inputs.in1 = fmaps[0] merge_to_file_list.inputs.in1 = fmaps[1] # Merge AP and PA distortion correction scans merger = Node(interface=MERGE(dimension='t'), name='merger') merger.inputs.output_type = 'NIFTI_GZ' merger.inputs.in_files = fmaps merger.inputs.merged_file = 'merged_epi.nii.gz' # Create distortion correction map topup = Node(interface=TOPUP(), name='topup') topup.inputs.output_type = 'NIFTI_GZ' # Apply distortion correction to other scans apply_topup = Node(interface=ApplyTOPUP(), name='apply_topup') apply_topup.inputs.output_type = 'NIFTI_GZ' apply_topup.inputs.method = 'jac' apply_topup.inputs.interp = 'spline' ################################### ### REALIGN ### ################################### realign_fsl = Node(MCFLIRT(), name="realign") realign_fsl.inputs.cost = 'mutualinfo' realign_fsl.inputs.mean_vol = True realign_fsl.inputs.output_type = 'NIFTI_GZ' realign_fsl.inputs.save_mats = True realign_fsl.inputs.save_rms = True realign_fsl.inputs.save_plots = True ################################### ### MEAN EPIs ### ################################### # For coregistration after realignment mean_epi = Node(MeanImage(), name='mean_epi') mean_epi.inputs.dimension = 'T' # For after normalization is done to plot checks mean_norm_epi = Node(MeanImage(), name='mean_norm_epi') mean_norm_epi.inputs.dimension = 'T' ################################### ### MASK, ART, COV CREATION ### ################################### compute_mask = Node(ComputeMask(), name='compute_mask') compute_mask.inputs.m = .05 art = Node(ArtifactDetect(), name='art') art.inputs.use_differences = [True, False] art.inputs.use_norm = True art.inputs.norm_threshold = 1 art.inputs.zintensity_threshold = 3 art.inputs.mask_type = 'file' art.inputs.parameter_source = 'FSL' make_cov = Node(Create_Covariates(), name='make_cov') ################################ ### N4 BIAS FIELD CORRECTION ### ################################ if apply_n4: n4_correction = Node(N4BiasFieldCorrection(), name='n4_correction') n4_correction.inputs.copy_header = True n4_correction.inputs.save_bias = False n4_correction.inputs.num_threads = ants_threads n4_correction.inputs.input_image = anat ################################### ### BRAIN EXTRACTION ### ################################### brain_extraction_ants = Node(BrainExtraction(), name='brain_extraction') brain_extraction_ants.inputs.dimension = 3 brain_extraction_ants.inputs.use_floatingpoint_precision = 1 brain_extraction_ants.inputs.num_threads = ants_threads brain_extraction_ants.inputs.brain_probability_mask = bet_ants_prob_mask brain_extraction_ants.inputs.keep_temporary_files = 1 brain_extraction_ants.inputs.brain_template = bet_ants_template brain_extraction_ants.inputs.extraction_registration_mask = bet_ants_registration_mask brain_extraction_ants.inputs.out_prefix = 'bet' ################################### ### COREGISTRATION ### ################################### coregistration = Node(Registration(), name='coregistration') coregistration.inputs.float = False coregistration.inputs.output_transform_prefix = "meanEpi2highres" coregistration.inputs.transforms = ['Rigid'] coregistration.inputs.transform_parameters = [(0.1, ), (0.1, )] coregistration.inputs.number_of_iterations = [[1000, 500, 250, 100]] coregistration.inputs.dimension = 3 coregistration.inputs.num_threads = ants_threads coregistration.inputs.write_composite_transform = True coregistration.inputs.collapse_output_transforms = True coregistration.inputs.metric = ['MI'] coregistration.inputs.metric_weight = [1] coregistration.inputs.radius_or_number_of_bins = [32] coregistration.inputs.sampling_strategy = ['Regular'] coregistration.inputs.sampling_percentage = [0.25] coregistration.inputs.convergence_threshold = [1e-08] coregistration.inputs.convergence_window_size = [10] coregistration.inputs.smoothing_sigmas = [[3, 2, 1, 0]] coregistration.inputs.sigma_units = ['mm'] coregistration.inputs.shrink_factors = [[4, 3, 2, 1]] coregistration.inputs.use_estimate_learning_rate_once = [True] coregistration.inputs.use_histogram_matching = [False] coregistration.inputs.initial_moving_transform_com = True coregistration.inputs.output_warped_image = True coregistration.inputs.winsorize_lower_quantile = 0.01 coregistration.inputs.winsorize_upper_quantile = 0.99 ################################### ### NORMALIZATION ### ################################### # Settings Explanations # Only a few key settings are worth adjusting and most others relate to how ANTs optimizer starts or iterates and won't make a ton of difference # Brian Avants referred to these settings as the last "best tested" when he was aligning fMRI data: https://github.com/ANTsX/ANTsRCore/blob/master/R/antsRegistration.R#L275 # Things that matter the most: # smoothing_sigmas: # how much gaussian smoothing to apply when performing registration, probably want the upper limit of this to match the resolution that the data is collected at e.g. 3mm # Old settings [[3,2,1,0]]*3 # shrink_factors # The coarseness with which to do registration # Old settings [[8,4,2,1]] * 3 # >= 8 may result is some problems causing big chunks of cortex with little fine grain spatial structure to be moved to other parts of cortex # Other settings # transform_parameters: # how much regularization to do for fitting that transformation # for syn this pertains to both the gradient regularization term, and the flow, and elastic terms. Leave the syn settings alone as they seem to be the most well tested across published data sets # radius_or_number_of_bins # This is the bin size for MI metrics and 32 is probably adequate for most use cases. Increasing this might increase precision (e.g. to 64) but takes exponentially longer # use_histogram_matching # Use image intensity distribution to guide registration # Leave it on for within modality registration (e.g. T1 -> MNI), but off for between modality registration (e.g. EPI -> T1) # convergence_threshold # threshold for optimizer # convergence_window_size # how many samples should optimizer average to compute threshold? # sampling_strategy # what strategy should ANTs use to initialize the transform. Regular here refers to approximately random sampling around the center of the image mass normalization = Node(Registration(), name='normalization') normalization.inputs.float = False normalization.inputs.collapse_output_transforms = True normalization.inputs.convergence_threshold = [1e-06] normalization.inputs.convergence_window_size = [10] normalization.inputs.dimension = 3 normalization.inputs.fixed_image = MNItemplate normalization.inputs.initial_moving_transform_com = True normalization.inputs.metric = ['MI', 'MI', 'CC'] normalization.inputs.metric_weight = [1.0] * 3 normalization.inputs.number_of_iterations = [[1000, 500, 250, 100], [1000, 500, 250, 100], [100, 70, 50, 20]] normalization.inputs.num_threads = ants_threads normalization.inputs.output_transform_prefix = 'anat2template' normalization.inputs.output_inverse_warped_image = True normalization.inputs.output_warped_image = True normalization.inputs.radius_or_number_of_bins = [32, 32, 4] normalization.inputs.sampling_percentage = [0.25, 0.25, 1] normalization.inputs.sampling_strategy = ['Regular', 'Regular', 'None'] normalization.inputs.shrink_factors = [[8, 4, 2, 1]] * 3 normalization.inputs.sigma_units = ['vox'] * 3 normalization.inputs.smoothing_sigmas = [[3, 2, 1, 0]] * 3 normalization.inputs.transforms = ['Rigid', 'Affine', 'SyN'] normalization.inputs.transform_parameters = [(0.1, ), (0.1, ), (0.1, 3.0, 0.0)] normalization.inputs.use_histogram_matching = True normalization.inputs.winsorize_lower_quantile = 0.005 normalization.inputs.winsorize_upper_quantile = 0.995 normalization.inputs.write_composite_transform = True # NEW SETTINGS (need to be adjusted; specifically shink_factors and smoothing_sigmas need to be the same length) # normalization = Node(Registration(), name='normalization') # normalization.inputs.float = False # normalization.inputs.collapse_output_transforms = True # normalization.inputs.convergence_threshold = [1e-06, 1e-06, 1e-07] # normalization.inputs.convergence_window_size = [10] # normalization.inputs.dimension = 3 # normalization.inputs.fixed_image = MNItemplate # normalization.inputs.initial_moving_transform_com = True # normalization.inputs.metric = ['MI', 'MI', 'CC'] # normalization.inputs.metric_weight = [1.0]*3 # normalization.inputs.number_of_iterations = [[1000, 500, 250, 100], # [1000, 500, 250, 100], # [100, 70, 50, 20]] # normalization.inputs.num_threads = ants_threads # normalization.inputs.output_transform_prefix = 'anat2template' # normalization.inputs.output_inverse_warped_image = True # normalization.inputs.output_warped_image = True # normalization.inputs.radius_or_number_of_bins = [32, 32, 4] # normalization.inputs.sampling_percentage = [0.25, 0.25, 1] # normalization.inputs.sampling_strategy = ['Regular', # 'Regular', # 'None'] # normalization.inputs.shrink_factors = [[4, 3, 2, 1]]*3 # normalization.inputs.sigma_units = ['vox']*3 # normalization.inputs.smoothing_sigmas = [[2, 1], [2, 1], [3, 2, 1, 0]] # normalization.inputs.transforms = ['Rigid', 'Affine', 'SyN'] # normalization.inputs.transform_parameters = [(0.1,), # (0.1,), # (0.1, 3.0, 0.0)] # normalization.inputs.use_histogram_matching = True # normalization.inputs.winsorize_lower_quantile = 0.005 # normalization.inputs.winsorize_upper_quantile = 0.995 # normalization.inputs.write_composite_transform = True ################################### ### APPLY TRANSFORMS AND SMOOTH ### ################################### merge_transforms = Node(Merge(2), iterfield=['in2'], name='merge_transforms') # Used for epi -> mni, via (coreg + norm) apply_transforms = Node(ApplyTransforms(), iterfield=['input_image'], name='apply_transforms') apply_transforms.inputs.input_image_type = 3 apply_transforms.inputs.float = False apply_transforms.inputs.num_threads = 12 apply_transforms.inputs.environ = {} apply_transforms.inputs.interpolation = 'BSpline' apply_transforms.inputs.invert_transform_flags = [False, False] apply_transforms.inputs.reference_image = MNItemplate # Used for t1 segmented -> mni, via (norm) apply_transform_seg = Node(ApplyTransforms(), name='apply_transform_seg') apply_transform_seg.inputs.input_image_type = 3 apply_transform_seg.inputs.float = False apply_transform_seg.inputs.num_threads = 12 apply_transform_seg.inputs.environ = {} apply_transform_seg.inputs.interpolation = 'MultiLabel' apply_transform_seg.inputs.invert_transform_flags = [False] apply_transform_seg.inputs.reference_image = MNItemplate ################################### ### PLOTS ### ################################### plot_realign = Node(Plot_Realignment_Parameters(), name="plot_realign") plot_qa = Node(Plot_Quality_Control(), name="plot_qa") plot_normalization_check = Node(Plot_Coregistration_Montage(), name="plot_normalization_check") plot_normalization_check.inputs.canonical_img = MNItemplatehasskull ############################################ ### FILTER, SMOOTH, DOWNSAMPLE PRECISION ### ############################################ # Use cosanlab_preproc for down sampling down_samp = Node(Down_Sample_Precision(), name="down_samp") # Use FSL for smoothing if apply_smooth: smooth = Node(Smooth(), name='smooth') if isinstance(apply_smooth, list): smooth.iterables = ("fwhm", apply_smooth) elif isinstance(apply_smooth, int) or isinstance(apply_smooth, float): smooth.inputs.fwhm = apply_smooth else: raise ValueError("apply_smooth must be a list or int/float") # Use cosanlab_preproc for low-pass filtering if apply_filter: lp_filter = Node(Filter_In_Mask(), name='lp_filter') lp_filter.inputs.mask = MNImask lp_filter.inputs.sampling_rate = tr_length lp_filter.inputs.high_pass_cutoff = 0 if isinstance(apply_filter, list): lp_filter.iterables = ("low_pass_cutoff", apply_filter) elif isinstance(apply_filter, int) or isinstance(apply_filter, float): lp_filter.inputs.low_pass_cutoff = apply_filter else: raise ValueError("apply_filter must be a list or int/float") ################### ### OUTPUT NODE ### ################### # Collect all final outputs in the output dir and get rid of file name additions datasink = Node(DataSink(), name='datasink') if session: datasink.inputs.base_directory = os.path.join(output_final_dir, subject_id) datasink.inputs.container = 'ses-' + session else: datasink.inputs.base_directory = output_final_dir datasink.inputs.container = subject_id # Remove substitutions data_dir_parts = data_dir.split('/')[1:] if session: prefix = ['_scan_'] + data_dir_parts + [subject_id] + [ 'ses-' + session ] + ['func'] else: prefix = ['_scan_'] + data_dir_parts + [subject_id] + ['func'] func_scan_names = [os.path.split(elem)[-1] for elem in funcs] to_replace = [] for elem in func_scan_names: bold_name = elem.split(subject_id + '_')[-1] bold_name = bold_name.split('.nii.gz')[0] to_replace.append(('..'.join(prefix + [elem]), bold_name)) datasink.inputs.substitutions = to_replace ##################### ### INIT WORKFLOW ### ##################### # If we have sessions provide the full path to the subject's intermediate directory # and only rely on workflow init to create the session container *within* that directory # Otherwise just point to the intermediate directory and let the workflow init create the subject container within the intermediate directory if session: workflow = Workflow(name='ses_' + session) workflow.base_dir = os.path.join(output_interm_dir, subId) else: workflow = Workflow(name=subId) workflow.base_dir = output_interm_dir ############################ ######### PART (1a) ######### # func -> discorr -> trim -> realign # OR # func -> trim -> realign # OR # func -> discorr -> realign # OR # func -> realign ############################ if apply_dist_corr: workflow.connect([(encoding_file_writer, topup, [('encoding_file', 'encoding_file')]), (encoding_file_writer, apply_topup, [('encoding_file', 'encoding_file')]), (merger, topup, [('merged_file', 'in_file')]), (func_scans, apply_topup, [('scan', 'in_files')]), (topup, apply_topup, [('out_fieldcoef', 'in_topup_fieldcoef'), ('out_movpar', 'in_topup_movpar')])]) if apply_trim: # Dist Corr + Trim workflow.connect([(apply_topup, trim, [('out_corrected', 'in_file') ]), (trim, realign_fsl, [('out_file', 'in_file')])]) else: # Dist Corr + No Trim workflow.connect([(apply_topup, realign_fsl, [('out_corrected', 'in_file')])]) else: if apply_trim: # No Dist Corr + Trim workflow.connect([(func_scans, trim, [('scan', 'in_file')]), (trim, realign_fsl, [('out_file', 'in_file')])]) else: # No Dist Corr + No Trim workflow.connect([ (func_scans, realign_fsl, [('scan', 'in_file')]), ]) ############################ ######### PART (1n) ######### # anat -> N4 -> bet # OR # anat -> bet ############################ if apply_n4: workflow.connect([(n4_correction, brain_extraction_ants, [('output_image', 'anatomical_image')])]) else: brain_extraction_ants.inputs.anatomical_image = anat ########################################## ############### PART (2) ################# # realign -> coreg -> mni (via t1) # t1 -> mni # covariate creation # plot creation ########################################### workflow.connect([ (realign_fsl, plot_realign, [('par_file', 'realignment_parameters')]), (realign_fsl, plot_qa, [('out_file', 'dat_img')]), (realign_fsl, art, [('out_file', 'realigned_files'), ('par_file', 'realignment_parameters')]), (realign_fsl, mean_epi, [('out_file', 'in_file')]), (realign_fsl, make_cov, [('par_file', 'realignment_parameters')]), (mean_epi, compute_mask, [('out_file', 'mean_volume')]), (compute_mask, art, [('brain_mask', 'mask_file')]), (art, make_cov, [('outlier_files', 'spike_id')]), (art, plot_realign, [('outlier_files', 'outliers')]), (plot_qa, make_cov, [('fd_outliers', 'fd_outliers')]), (brain_extraction_ants, coregistration, [('BrainExtractionBrain', 'fixed_image')]), (mean_epi, coregistration, [('out_file', 'moving_image')]), (brain_extraction_ants, normalization, [('BrainExtractionBrain', 'moving_image')]), (coregistration, merge_transforms, [('composite_transform', 'in2')]), (normalization, merge_transforms, [('composite_transform', 'in1')]), (merge_transforms, apply_transforms, [('out', 'transforms')]), (realign_fsl, apply_transforms, [('out_file', 'input_image')]), (apply_transforms, mean_norm_epi, [('output_image', 'in_file')]), (normalization, apply_transform_seg, [('composite_transform', 'transforms')]), (brain_extraction_ants, apply_transform_seg, [('BrainExtractionSegmentation', 'input_image')]), (mean_norm_epi, plot_normalization_check, [('out_file', 'wra_img')]) ]) ################################################## ################### PART (3) ##################### # epi (in mni) -> filter -> smooth -> down sample # OR # epi (in mni) -> filter -> down sample # OR # epi (in mni) -> smooth -> down sample # OR # epi (in mni) -> down sample ################################################### if apply_filter: workflow.connect([(apply_transforms, lp_filter, [('output_image', 'in_file')])]) if apply_smooth: # Filtering + Smoothing workflow.connect([(lp_filter, smooth, [('out_file', 'in_file')]), (smooth, down_samp, [('smoothed_file', 'in_file') ])]) else: # Filtering + No Smoothing workflow.connect([(lp_filter, down_samp, [('out_file', 'in_file')]) ]) else: if apply_smooth: # No Filtering + Smoothing workflow.connect([ (apply_transforms, smooth, [('output_image', 'in_file')]), (smooth, down_samp, [('smoothed_file', 'in_file')]) ]) else: # No Filtering + No Smoothing workflow.connect([(apply_transforms, down_samp, [('output_image', 'in_file')])]) ########################################## ############### PART (4) ################# # down sample -> save # plots -> save # covs -> save # t1 (in mni) -> save # t1 segmented masks (in mni) -> save # realignment parms -> save ########################################## workflow.connect([ (down_samp, datasink, [('out_file', 'functional.@down_samp')]), (plot_realign, datasink, [('plot', 'functional.@plot_realign')]), (plot_qa, datasink, [('plot', 'functional.@plot_qa')]), (plot_normalization_check, datasink, [('plot', 'functional.@plot_normalization')]), (make_cov, datasink, [('covariates', 'functional.@covariates')]), (normalization, datasink, [('warped_image', 'structural.@normanat')]), (apply_transform_seg, datasink, [('output_image', 'structural.@normanatseg')]), (realign_fsl, datasink, [('par_file', 'functional.@motionparams')]) ]) if not os.path.exists(os.path.join(output_dir, 'pipeline.png')): workflow.write_graph(dotfilename=os.path.join(output_dir, 'pipeline'), format='png') print(f"Creating workflow for subject: {subject_id}") if ants_threads != 8: print( f"ANTs will utilize the user-requested {ants_threads} threads for parallel processing." ) return workflow
subject_list = [ '229', '230', '232', '233', '234', '235', '237', '242', '243', '244', '245', '252', '253', '255', '261', '262', '263', '264', '273', '274', '281', '282', '286', '287', '362', '363', '364', '365', '366', '236', '271', '272' ] # subject_list = ['229', '230', '365', '274'] # subject_list = ['230', '365'] output_dir = 'Plus_Maze_output' working_dir = 'Plus_Maze_workingdir' Plus_Maze_workflow = Workflow(name='Plus_Maze_workflow') Plus_Maze_workflow.base_dir = opj(experiment_dir, working_dir) # ----------------------------------------------------------------------------------------------------- # In[3]: # Infosource - a function free node to iterate over the list of subject names infosource = Node(IdentityInterface(fields=['subject_id']), name="infosource") infosource.iterables = [('subject_id', subject_list)] # ----------------------------------------------------------------------------------------------------- # In[4]: templates = {'plus_maze': 'Data/{subject_id}/plus_maze_{subject_id}.avi'} selectfiles = Node(SelectFiles(templates, base_directory=experiment_dir), name="selectfiles")
# session_list = ['run001', 'run002', 'run003'] session_list = [ 'run001', 'run002', 'run003', 'run004', 'run005', 'run006', 'run007', 'run008' ] # session_list = ['run001', 'run002'] frequency_list = ['05Hz', '10Hz', '20Hz', '40Hz'] # frequency_list = ['40Hz'] output_dir = 'Stimulation_Preproc_OutputDir_CA3' working_dir = 'Stimulation_Preproc_WorkingDir_CA3' stimulation_preproc = Workflow(name='stimulation_preproc_CA3') stimulation_preproc.base_dir = opj(experiment_dir, working_dir) # ===================================================================================================== # In[3]: # to prevent nipype from iterating over the anat image with each func run, you need seperate # nodes to select the files # and this will solve the problem I have for almost 6 months # but notice that in the sessions, you have to iterate also over subject_id to get the {subject_id} var # Infosource - a function free node to iterate over the list of subject names infosource_anat = Node(IdentityInterface(fields=['subject_id']), name="infosource_anat") infosource_anat.iterables = [('subject_id', subject_list)] infosource_func = Node( IdentityInterface(fields=['subject_id', 'session_id', 'frequency_id']),
def preprocessing_pipeline(cfg): import os from nipype import config from nipype.pipeline.engine import Node, Workflow import nipype.interfaces.utility as util import nipype.interfaces.io as nio import nipype.interfaces.fsl as fsl import nipype.interfaces.freesurfer as freesurfer # LeiCA modules from utils import zip_and_save_running_scripts from preprocessing.rsfMRI_preprocessing import create_rsfMRI_preproc_pipeline from preprocessing.converter import create_converter_structural_pipeline, create_converter_functional_pipeline, \ create_converter_diffusion_pipeline # INPUT PARAMETERS dicom_dir = cfg['dicom_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'] 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_resting') 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') ##################################### # 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) ##################################### # FETCH MRI DATA ##################################### # GET LATERAL VENTRICLE MASK templates_atlases = { 'lat_ventricle_mask_MNI': 'cpac_image_resources/HarvardOxford-lateral-ventricles-thr25-2mm.nii.gz' } selectfiles_templates = Node(nio.SelectFiles(templates_atlases, base_directory=template_dir), name="selectfiles_templates") if not True: # releases 1-6 with 01... format subject_id # GET FUNCTIONAL DATA templates_funct = { 'funct_dicom': '{subject_id}/session_1/RfMRI_*_{TR_id}' } selectfiles_funct = Node(nio.SelectFiles(templates_funct, base_directory=dicom_dir), name="selectfiles_funct") selectfiles_funct.inputs.subject_id = subject_id wf.connect(scan_infosource, 'TR_id', selectfiles_funct, 'TR_id') # GET STRUCTURAL DATA templates_struct = { 't1w_dicom': '{subject_id}/anat', 'dMRI_dicom': '{subject_id}/session_1/DTI_mx_137/*.dcm' } # *.dcm for dMRI as Dcm2nii requires this selectfiles_struct = Node(nio.SelectFiles(templates_struct, base_directory=dicom_dir), name="selectfiles_struct") selectfiles_struct.inputs.subject_id = subject_id else: #startin with release 6 new folder structure templates_funct = { 'funct_dicom': '*/{subject_id}/*_V2/REST_{TR_id}*/*.dcm' } selectfiles_funct = Node(nio.SelectFiles(templates_funct, base_directory=dicom_dir), name="selectfiles_funct") selectfiles_funct.inputs.subject_id = subject_id wf.connect(scan_infosource, 'TR_id', selectfiles_funct, 'TR_id') # GET STRUCTURAL DATA templates_struct = { 't1w_dicom': '*/{subject_id}/*_V2/MPRAGE_SIEMENS_DEFACED*/*.dcm', 'dMRI_dicom': '*/{subject_id}/*_V2/DIFF_137_AP*/*.dcm' } # *.dcm for dMRI as Dcm2nii requires this selectfiles_struct = Node(nio.SelectFiles(templates_struct, base_directory=dicom_dir), name="selectfiles_struct") selectfiles_struct.inputs.subject_id = subject_id ##################################### # COPY RUNNING SCRIPTS ##################################### copy_scripts = Node(util.Function(input_names=['subject_id', 'script_dir'], output_names=['zip_file'], function=zip_and_save_running_scripts), name='copy_scripts') copy_scripts.inputs.script_dir = script_dir copy_scripts.inputs.subject_id = subject_id wf.connect(copy_scripts, 'zip_file', ds, 'scripts') ##################################### # CONVERT DICOMs ##################################### # CONVERT STRUCT 2 NIFTI converter_struct = create_converter_structural_pipeline( working_dir, ds_dir, 'converter_struct') wf.connect(selectfiles_struct, 't1w_dicom', converter_struct, 'inputnode.t1w_dicom') # CONVERT dMRI 2 NIFTI converter_dMRI = create_converter_diffusion_pipeline( working_dir, ds_dir, 'converter_dMRI') wf.connect(selectfiles_struct, 'dMRI_dicom', converter_dMRI, 'inputnode.dMRI_dicom') # CONVERT FUNCT 2 NIFTI converter_funct = create_converter_functional_pipeline( working_dir, ds_dir, 'converter_funct') wf.connect(selectfiles_funct, 'funct_dicom', converter_funct, 'inputnode.epi_dicom') wf.connect(scan_infosource, 'TR_id', converter_funct, 'inputnode.out_format') ##################################### # START RSFMRI PREPROCESSING ANALYSIS ##################################### # rsfMRI PREPROCESSING rsfMRI_preproc = create_rsfMRI_preproc_pipeline(working_dir, freesurfer_dir, ds_dir, use_fs_brainmask, 'rsfMRI_preprocessing') rsfMRI_preproc.inputs.inputnode.vols_to_drop = vols_to_drop rsfMRI_preproc.inputs.inputnode.lp_cutoff_freq = lp_cutoff_freq rsfMRI_preproc.inputs.inputnode.hp_cutoff_freq = hp_cutoff_freq rsfMRI_preproc.inputs.inputnode.subject_id = subject_id wf.connect(converter_struct, 'outputnode.t1w', rsfMRI_preproc, 'inputnode.t1w') wf.connect(converter_funct, 'outputnode.epi', rsfMRI_preproc, 'inputnode.epi') wf.connect(converter_funct, 'outputnode.TR_ms', rsfMRI_preproc, 'inputnode.TR_ms') wf.connect(selectfiles_templates, 'lat_ventricle_mask_MNI', rsfMRI_preproc, 'inputnode.lat_ventricle_mask_MNI') ##################################### # RUN WF ##################################### 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})
map_list = [ 'CHARMED_AD', 'CHARMED_FA', 'CHARMED_FR', 'CHARMED_IAD', 'CHARMED_MD', 'CHARMED_RD', 'Diffusion_20_AD', 'Diffusion_20_FA', 'Diffusion_20_MD', 'Diffusion_20_RD', 'Kurtosis_AD', 'Kurtosis_AWF', 'Kurtosis_MD', 'Kurtosis_RD', 'Kurtosis_TORT', 'Kurtosis_AK', 'Kurtosis_FA', 'Kurtosis_MK', 'Kurtosis_RK', 'NODDI_FICVF', 'NODDI_ODI' ] # map_list = ['229', '230', '365', '274'] output_dir = 'DTI_TBSS_Wax' working_dir = 'DTI_TBSS_workingdir_Wax_Template' DTI_TBSS_Wax = Workflow(name='DTI_TBSS_Wax') DTI_TBSS_Wax.base_dir = opj(experiment_dir, working_dir) #----------------------------------------------------------------------------------------------------- #----------------------------------------------------------------------------------------------------- #----------------------------------------------------------------------------------------------------- #----------------------------------------------------------------------------------------------------- # In[3]: # Infosource - a function free node to iterate over the list of subject names infosource = Node(IdentityInterface(fields=['map_id']), name="infosource") infosource.iterables = [('map_id', map_list)] #----------------------------------------------------------------------------------------------------- # In[4]: templates = {
# apply warp to timeseries # applytransform_ts = Node(ants.WarpTimeSeriesImageMultiTransform(dimension=4), # name='applytransform_ts') # # # applywarp_linear.connect([(inputnode, applytransform_ts, [('epi_moco_ts','input_image')]), # (transformlist, applytransform_ts, [('transformlist', 'transformation_series')]), # (inputnode, applytransform_ts, [('mni', 'reference_image')]), # (applytransform_ts, outputnode, [('output_image','lin_ts_fullwarped')]) # ]) # set up workflow, in- and output applywarp_linear.base_dir='/scr/kansas1/huntenburg/lemon_missing/working_dir/' data_dir='/scr/jessica2/Schaare/LEMON/' out_dir = '/scr/jessica2/Schaare/LEMON/preprocessed/' #applywarp_linear.config['execution']={'remove_unnecessary_outputs': 'False'} applywarp_linear.config['execution']['crashdump_dir'] = applywarp_linear.base_dir + "/crash_files" # reading subjects from file subjects=[] f = open('/scr/jessica2/Schaare/LEMON/missing_subjects.txt','r') for line in f: subjects.append(line.strip()) # create inforsource to iterate over subjects infosource = Node(util.IdentityInterface(fields=['subject_id']), name='infosource')
terminal_output='file'), name='apply2con', iterfield=['input_image']) # Apply Transformation - applies the normalization matrix to the mean image apply2mean = Node(ApplyTransforms(args='--float', input_image_type=3, interpolation='Linear', invert_transform_flags=[False], num_threads=1, reference_image=template, terminal_output='file'), name='apply2mean') # Initiation of the ANTS normalization workflow normflow = Workflow(name='normflow') normflow.base_dir = opj(experiment_dir, working_dir) # Connect up ANTS normalization components normflow.connect([(antsreg, apply2con, [('composite_transform', 'transforms')]), (antsreg, apply2mean, [('composite_transform', 'transforms')]) ]) # Infosource - a function free node to iterate over the list of subject names infosource = Node(IdentityInterface(fields=['subject_id']), name="infosource") infosource.iterables = [('subject_id', subject_list)] # SelectFiles - to grab the data (alternativ to DataGrabber) anat_file = opj('freesurfer', '{subject_id}', 'mri/brain.mgz') func_file = opj(input_dir_1st, 'contrasts', '{subject_id}',
def calc_centrality_metrics(cfg): import os from nipype import config from nipype.pipeline.engine import Node, Workflow 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.network_centrality.resting_state_centrality as cpac_centrality import CPAC.network_centrality.z_score as cpac_centrality_z_score # 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'] subjects_list = cfg['subjects_list'] TR_list = cfg['TR_list'] 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': False, '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(), name='ds') ds.inputs.substitutions = [('_TR_id_', 'TR_')] ds.inputs.regexp_substitutions = [('_subject_id_[A0-9]*/', ''), ( '_z_score[0-9]*/', '')] # , #('dc/_TR_id_[0-9]*/', ''), ('evc/_TR_id_[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) subjects_infosource = Node(util.IdentityInterface(fields=['subject_id']), name='subjects_infosource') subjects_infosource.iterables = ('subject_id', subjects_list) def add_subject_id_to_ds_dir_fct(subject_id, ds_path): import os out_path = os.path.join(ds_path, subject_id) return out_path add_subject_id_to_ds_dir = Node(util.Function(input_names=['subject_id', 'ds_path'], output_names=['out_path'], function=add_subject_id_to_ds_dir_fct), name='add_subject_id_to_ds_dir') wf.connect(subjects_infosource, 'subject_id', add_subject_id_to_ds_dir, 'subject_id') add_subject_id_to_ds_dir.inputs.ds_path = ds_dir wf.connect(add_subject_id_to_ds_dir, 'out_path', ds, 'base_directory') # 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', 'epi_bp_tNorm_MNIspace_3mm': '{subject_id}/rsfMRI_preprocessing/epis_MNI_3mm/03_denoised_BP_tNorm/TR_645/residual_filt_norm_warp.nii.gz' } selectfiles = Node(nio.SelectFiles(selectfiles_templates, base_directory=preprocessed_data_dir), name="selectfiles") wf.connect(scan_infosource, 'TR_id', selectfiles, 'TR_id') wf.connect(subjects_infosource, 'subject_id', selectfiles, 'subject_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') ##################### # CALCULATE METRICS ##################### # DEGREE # fixme # a_mem = 5 # fixme a_mem = 20 dc = cpac_centrality.create_resting_state_graphs(allocated_memory=a_mem, wf_name='dc') # allocated_memory = a_mem, wf_name = 'dc') # dc.plugin_args = {'submit_specs': 'request_memory = 6000'} # fixme dc.plugin_args = {'submit_specs': 'request_memory = 20000'} dc.inputs.inputspec.method_option = 0 # 0 for degree centrality, 1 for eigenvector centrality, 2 for lFCD dc.inputs.inputspec.threshold_option = 0 # 0 for probability p_value, 1 for sparsity threshold, any other for threshold value dc.inputs.inputspec.threshold = 0.0001 dc.inputs.inputspec.weight_options = [True, True] # list of two booleans for binarize and weighted options respectively wf.connect(selectfiles, 'epi_bp_tNorm_MNIspace_3mm', dc, 'inputspec.subject') wf.connect(selectfiles_anat_templates, 'GM_mask_MNI_3mm', dc, 'inputspec.template') wf.connect(dc, 'outputspec.centrality_outputs', ds, 'metrics.centrality.dc.@centrality_outputs') wf.connect(dc, 'outputspec.correlation_matrix', ds, 'metrics.centrality.dc.@correlation_matrix') wf.connect(dc, 'outputspec.graph_outputs', ds, 'metrics.centrality.dc.@graph_outputs') # DC Z-SCORE dc_Z = cpac_centrality_z_score.get_cent_zscore(wf_name='dc_Z') wf.connect(dc, 'outputspec.centrality_outputs', dc_Z, 'inputspec.input_file') wf.connect(selectfiles_anat_templates, 'GM_mask_MNI_3mm', dc_Z, 'inputspec.mask_file') wf.connect(dc_Z, 'outputspec.z_score_img', ds, 'metrics.centrality.dc_z.@output') a_mem = 20 evc = cpac_centrality.create_resting_state_graphs(allocated_memory=a_mem, wf_name='evc') evc.plugin_args = {'submit_specs': 'request_memory = 20000'} evc.inputs.inputspec.method_option = 1 # 0 for degree centrality, 1 for eigenvector centrality, 2 for lFCD evc.inputs.inputspec.threshold_option = 0 # 0 for probability p_value, 1 for sparsity threshold, any other for threshold value evc.inputs.inputspec.threshold = 0.0001 evc.inputs.inputspec.weight_options = [True, True] # list of two booleans for binarize and weighted options respectively wf.connect(selectfiles, 'epi_bp_tNorm_MNIspace_3mm', evc, 'inputspec.subject') wf.connect(selectfiles_anat_templates, 'GM_mask_MNI_3mm', evc, 'inputspec.template') wf.connect(evc, 'outputspec.centrality_outputs', ds, 'metrics.centrality.evc.@centrality_outputs') wf.connect(evc, 'outputspec.correlation_matrix', ds, 'metrics.centrality.evc.@correlation_matrix') wf.connect(evc, 'outputspec.graph_outputs', ds, 'metrics.centrality.evc.@graph_outputs') # EVC Z-SCORE evc_Z = cpac_centrality_z_score.get_cent_zscore(wf_name='evc_Z') wf.connect(evc, 'outputspec.centrality_outputs', evc_Z, 'inputspec.input_file') wf.connect(selectfiles_anat_templates, 'GM_mask_MNI_3mm', evc_Z, 'inputspec.mask_file') wf.connect(evc_Z, 'outputspec.z_score_img', ds, 'metrics.centrality.evc_z.@output') 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})
subjects_db=list(df['DB']) # sessions to loop over sessions=['rest1_1'] # ,'rest1_2', 'rest2_1', 'rest2_2'] # directories working_dir = '/scr/ilz3/myelinconnect/working_dir/' data_dir= '/scr/ilz3/myelinconnect/' out_dir = '/scr/ilz3/myelinconnect/final_struct_space/rest1_1_trans' # set fsl output type to nii.gz fsl.FSLCommand.set_default_output_type('NIFTI_GZ') # main workflow smooth = Workflow(name='smooth') smooth.base_dir = working_dir smooth.config['execution']['crashdump_dir'] = smooth.base_dir + "/crash_files" # iterate over subjects subject_infosource = Node(util.IdentityInterface(fields=['subject']), name='subject_infosource') subject_infosource.iterables=[('subject', subjects_db)] # iterate over sessions session_infosource = Node(util.IdentityInterface(fields=['session']), name='session_infosource') session_infosource.iterables=[('session', sessions)] # select files templates={'rest': 'final_struct_space/rest1_1_trans/{subject}_{session}_denoised_trans.nii.gz' }
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})
# -*- coding: utf-8 -*- """ Created on Tue Aug 25 11:39:05 2015 @author: craigmoodie """ from nipype.pipeline.engine import Workflow, Node, MapNode from variables import data_dir, work_dir, subject_list, plugin, plugin_args surface_workflow = Workflow(name="qc_workflow") surface_workflow.base_dir = work_dir from nipype import SelectFiles templates = dict(T1="*_{subject_id}_*/T1w_MPR_BIC_v1/*00001.nii*") file_list = Node(SelectFiles(templates), name = "EPI_and_T1_File_Selection") file_list.inputs.base_directory = data_dir file_list.iterables = [("subject_id", subject_list)] from nipype.interfaces.freesurfer import ReconAll reconall = Node(ReconAll(), name = "Recon_All") reconall.inputs.subject_id = "subject_id" reconall.inputs.directive = 'all' reconall.inputs.subjects_dir = data_dir #reconall.inputs.T1_files = "T1" #reconall.run()
self.inputs.output_prefix + '1InverseWarp.nii.gz') return outputs if __name__=='main': #### from nipype.pipeline.engine import Node, Workflow import nipype.interfaces.io as nio #from nipype.interfaces.ants.registration import RegistrationSynQuick import os os.chdir('/Users/franzliem/Desktop/antstest') wf = Workflow(name='normalize') wf.base_dir = os.path.join('/Users/franzliem/Desktop/antstest/wf') ds = Node(nio.DataSink(), name='ds') ds.inputs.base_directory = '/Users/franzliem/Desktop/antstest/ds' s = Node(RegistrationSynQuick(), name='s_rigid') s.base_dir = '/Users/franzliem/Desktop/antstest/node_test' s.inputs.fixed_image = '/Applications/FSL/data/standard/FMRIB58_FA_1mm.nii.gz' s.inputs.moving_image = '/Users/franzliem/Desktop/antstest/dtifit__FA_ero.nii.gz' s.inputs.output_prefix = 'ants_mni' s.inputs.num_threads=4 # s.inputs.use_histogram_matching = True # s.inputs.transform_type = 'r' # s.inputs.histogram_bins = 44 # s.inputs.spline_distance = 15 # s.inputs.precision_type = 'double'
('t1map', 'inQuantitative'), ('uni', 'inT1weighted')]), (background, strip, [('outMasked2','inInput')]), (background, outputnode, [('outMasked2','uni_masked'), ('outMasked','t1map_masked'), ('outSignal2','background_mask')]), (strip, outputnode, [('outStripped','uni_stripped'), ('outMask', 'skullstrip_mask'), ('outOriginal','uni_reoriented')]) ]) #### in and out #################################################################################### #mp2rage.base_dir='/scr/ilz1/nonlinear_registration/lemon/testing/dicom_start/' mp2rage.base_dir='/scr/kansas1/huntenburg/' data_dir='/scr/litauen1/lsd/pilot_140521/dicoms/DL1T/' #data_dir='/scr/ilz1/nonlinear_registration/lemon/testing/dicom_start/' #data_dir = '/scr/jessica2/Schaare/LEMON/raw/' #out_dir = '/scr/jessica2/Schaare/LEMON/preprocessed/' #mp2rage.config['execution']={'remove_unnecessary_outputs': 'False'} subjects=['LEMON064', 'LEMON065', 'LEMON096'] # subjects=os.listdir(data_dir) # subjects.remove('LEMON025') # subjects.remove('LEMON065') #infosource to iterate over subjects infosource = Node(util.IdentityInterface(fields=['subject_id']), name='infosource') infosource.iterables=('subject_id', subjects)
def learning_predict_data_2samp_wf(working_dir, ds_dir, in_data_name_list, subjects_selection_crit_dict, subjects_selection_crit_names_list, aggregated_subjects_dir, target_list, use_n_procs, plugin_name, confound_regression=[False, True], run_cv=False, n_jobs_cv=1, run_tuning=False, run_2sample_training=False, aggregated_subjects_dir_nki=None, subjects_selection_crit_dict_nki=None, subjects_selection_crit_name_nki=None, reverse_split=False, random_state_nki=666, run_learning_curve=False, life_test_size=0.5): import os from nipype import config from nipype.pipeline.engine import Node, Workflow import nipype.interfaces.utility as util import nipype.interfaces.io as nio from itertools import chain from learning_utils import aggregate_multimodal_metrics_fct, run_prediction_split_fct, \ backproject_and_split_weights_fct, select_subjects_fct, select_multimodal_X_fct, learning_curve_plot import pandas as pd ############################################################################################################### # GENERAL SETTINGS wf = Workflow(name='learning_predict_data_2samp_wf') wf.base_dir = os.path.join(working_dir) nipype_cfg = dict(logging=dict(workflow_level='DEBUG'), execution={'stop_on_first_crash': False, 'remove_unnecessary_outputs': False, 'job_finished_timeout': 120}) config.update_config(nipype_cfg) wf.config['execution']['crashdump_dir'] = os.path.join(working_dir, 'crash') ds = Node(nio.DataSink(), name='ds') ds.inputs.base_directory = os.path.join(ds_dir, 'group_learning_prepare_data') ds.inputs.regexp_substitutions = [ # ('subject_id_', ''), ('_parcellation_', ''), ('_bp_freqs_', 'bp_'), ('_extraction_method_', ''), ('_subject_id_[A0-9]*/', '') ] ds_pdf = Node(nio.DataSink(), name='ds_pdf') ds_pdf.inputs.base_directory = os.path.join(ds_dir, 'pdfs') ds_pdf.inputs.parameterization = False ############################################################################################################### # ensure in_data_name_list is list of lists in_data_name_list = [i if type(i) == list else [i] for i in in_data_name_list] in_data_name_list_unique = list(set(chain.from_iterable(in_data_name_list))) ############################################################################################################### # SET ITERATORS in_data_name_infosource = Node(util.IdentityInterface(fields=['in_data_name']), name='in_data_name_infosource') in_data_name_infosource.iterables = ('in_data_name', in_data_name_list_unique) multimodal_in_data_name_infosource = Node(util.IdentityInterface(fields=['multimodal_in_data_name']), name='multimodal_in_data_name_infosource') multimodal_in_data_name_infosource.iterables = ('multimodal_in_data_name', in_data_name_list) subject_selection_infosource = Node(util.IdentityInterface(fields=['selection_criterium']), name='subject_selection_infosource') subject_selection_infosource.iterables = ('selection_criterium', subjects_selection_crit_names_list) target_infosource = Node(util.IdentityInterface(fields=['target_name']), name='target_infosource') target_infosource.iterables = ('target_name', target_list) ############################################################################################################### # COMPILE LIFE DATA ############################################################################################################### ############################################################################################################### # GET INFO AND SELECT FILES df_all_subjects_pickle_file = os.path.join(aggregated_subjects_dir, 'df_all_subjects_pickle_file/df_all.pkl') df = pd.read_pickle(df_all_subjects_pickle_file) # build lookup dict for unimodal data X_file_template = 'X_file/_in_data_name_{in_data_name}/vectorized_aggregated_data.npy' info_file_template = 'unimodal_backprojection_info_file/_in_data_name_{in_data_name}/unimodal_backprojection_info.pkl' unimodal_lookup_dict = {} for k in in_data_name_list_unique: unimodal_lookup_dict[k] = {'X_file': os.path.join(aggregated_subjects_dir, X_file_template.format( in_data_name=k)), 'unimodal_backprojection_info_file': os.path.join(aggregated_subjects_dir, info_file_template.format( in_data_name=k)) } ############################################################################################################### # AGGREGATE MULTIMODAL METRICS # stack single modality arrays horizontally aggregate_multimodal_metrics = Node(util.Function(input_names=['multimodal_list', 'unimodal_lookup_dict'], output_names=['X_multimodal_file', 'multimodal_backprojection_info', 'multimodal_name'], function=aggregate_multimodal_metrics_fct), name='aggregate_multimodal_metrics') wf.connect(multimodal_in_data_name_infosource, 'multimodal_in_data_name', aggregate_multimodal_metrics, 'multimodal_list') aggregate_multimodal_metrics.inputs.unimodal_lookup_dict = unimodal_lookup_dict ############################################################################################################### # GET INDEXER FOR SUBJECTS OF INTEREST (as defined by selection criterium) select_subjects = Node(util.Function(input_names=['df_all_subjects_pickle_file', 'subjects_selection_crit_dict', 'selection_criterium'], output_names=['df_use_file', 'df_use_pickle_file', 'subjects_selection_index'], function=select_subjects_fct), name='select_subjects') select_subjects.inputs.df_all_subjects_pickle_file = df_all_subjects_pickle_file select_subjects.inputs.subjects_selection_crit_dict = subjects_selection_crit_dict wf.connect(subject_selection_infosource, 'selection_criterium', select_subjects, 'selection_criterium') ############################################################################################################### # SELECT MULITMODAL X # select subjects (rows) from multimodal X according indexer select_multimodal_X = Node(util.Function(input_names=['X_multimodal_file', 'subjects_selection_index', 'selection_criterium'], output_names=['X_multimodal_selected_file'], function=select_multimodal_X_fct), name='select_multimodal_X') wf.connect(aggregate_multimodal_metrics, 'X_multimodal_file', select_multimodal_X, 'X_multimodal_file') wf.connect(select_subjects, 'subjects_selection_index', select_multimodal_X, 'subjects_selection_index') ############################################################################################################### # COMPILE NKI DATA ############################################################################################################### if run_2sample_training: ############################################################################################################### # GET INFO AND SELECT FILES df_all_subjects_pickle_file_nki = os.path.join(aggregated_subjects_dir_nki, 'df_all_subjects_pickle_file/df_all.pkl') df_nki = pd.read_pickle(df_all_subjects_pickle_file_nki) # build lookup dict for unimodal data X_file_template = 'X_file/_in_data_name_{in_data_name}/vectorized_aggregated_data.npy' info_file_template = 'unimodal_backprojection_info_file/_in_data_name_{in_data_name}/unimodal_backprojection_info.pkl' unimodal_lookup_dict_nki = {} for k in in_data_name_list_unique: unimodal_lookup_dict_nki[k] = {'X_file': os.path.join(aggregated_subjects_dir_nki, X_file_template.format( in_data_name=k)), 'unimodal_backprojection_info_file': os.path.join( aggregated_subjects_dir_nki, info_file_template.format( in_data_name=k)) } ############################################################################################################### # AGGREGATE MULTIMODAL METRICS # stack single modality arrays horizontally aggregate_multimodal_metrics_nki = Node(util.Function(input_names=['multimodal_list', 'unimodal_lookup_dict'], output_names=['X_multimodal_file', 'multimodal_backprojection_info', 'multimodal_name'], function=aggregate_multimodal_metrics_fct), name='aggregate_multimodal_metrics_nki') wf.connect(multimodal_in_data_name_infosource, 'multimodal_in_data_name', aggregate_multimodal_metrics_nki, 'multimodal_list') aggregate_multimodal_metrics_nki.inputs.unimodal_lookup_dict = unimodal_lookup_dict_nki ############################################################################################################### # GET INDEXER FOR SUBJECTS OF INTEREST (as defined by selection criterium) select_subjects_nki = Node(util.Function(input_names=['df_all_subjects_pickle_file', 'subjects_selection_crit_dict', 'selection_criterium'], output_names=['df_use_file', 'df_use_pickle_file', 'subjects_selection_index'], function=select_subjects_fct), name='select_subjects_nki') select_subjects_nki.inputs.df_all_subjects_pickle_file = df_all_subjects_pickle_file_nki select_subjects_nki.inputs.subjects_selection_crit_dict = subjects_selection_crit_dict_nki select_subjects_nki.inputs.selection_criterium = subjects_selection_crit_name_nki ############################################################################################################### # SELECT MULITMODAL X # select subjects (rows) from multimodal X according indexer select_multimodal_X_nki = Node(util.Function(input_names=['X_multimodal_file', 'subjects_selection_index', 'selection_criterium'], output_names=['X_multimodal_selected_file'], function=select_multimodal_X_fct), name='select_multimodal_X_nki') wf.connect(aggregate_multimodal_metrics_nki, 'X_multimodal_file', select_multimodal_X_nki, 'X_multimodal_file') wf.connect(select_subjects_nki, 'subjects_selection_index', select_multimodal_X_nki, 'subjects_selection_index') ############################################################################################################### # RUN PREDICTION # prediction_node_dict = {} backprojection_node_dict = {} prediction_split = Node(util.Function(input_names=['X_file', 'target_name', 'selection_criterium', 'df_file', 'data_str', 'regress_confounds', 'run_cv', 'n_jobs_cv', 'run_tuning', 'X_file_nki', 'df_file_nki', 'reverse_split', 'random_state_nki', 'run_learning_curve', 'life_test_size'], output_names=['scatter_file', 'brain_age_scatter_file', 'df_life_out_file', 'df_nki_out_file', 'df_big_out_file', 'model_out_file', 'df_res_out_file', 'tuning_curve_file', 'scatter_file_cv', 'learning_curve_plot_file', 'learning_curve_df_file'], function=run_prediction_split_fct), name='prediction_split') backproject_and_split_weights = Node(util.Function(input_names=['trained_model_file', 'multimodal_backprojection_info', 'data_str', 'target_name'], output_names=['out_file_list', 'out_file_render_list'], function=backproject_and_split_weights_fct), name='backproject_and_split_weights') i = 0 for reg in confound_regression: the_out_node_str = 'single_source_model_reg_%s_' % (reg) prediction_node_dict[i] = prediction_split.clone(the_out_node_str) the_in_node = prediction_node_dict[i] the_in_node.inputs.regress_confounds = reg the_in_node.inputs.run_cv = run_cv the_in_node.inputs.n_jobs_cv = n_jobs_cv the_in_node.inputs.run_tuning = run_tuning the_in_node.inputs.reverse_split = reverse_split the_in_node.inputs.random_state_nki = random_state_nki the_in_node.inputs.run_learning_curve = run_learning_curve the_in_node.inputs.life_test_size = life_test_size wf.connect(select_multimodal_X, 'X_multimodal_selected_file', the_in_node, 'X_file') wf.connect(target_infosource, 'target_name', the_in_node, 'target_name') wf.connect(subject_selection_infosource, 'selection_criterium', the_in_node, 'selection_criterium') wf.connect(select_subjects, 'df_use_pickle_file', the_in_node, 'df_file') wf.connect(aggregate_multimodal_metrics, 'multimodal_name', the_in_node, 'data_str') wf.connect(the_in_node, 'model_out_file', ds, the_out_node_str + 'trained_model') wf.connect(the_in_node, 'scatter_file', ds_pdf, the_out_node_str + 'scatter') wf.connect(the_in_node, 'brain_age_scatter_file', ds_pdf, the_out_node_str + 'brain_age_scatter') wf.connect(the_in_node, 'df_life_out_file', ds_pdf, the_out_node_str + 'predicted_life') wf.connect(the_in_node, 'df_nki_out_file', ds_pdf, the_out_node_str + 'predicted_nki') wf.connect(the_in_node, 'df_big_out_file', ds_pdf, the_out_node_str + 'predicted') wf.connect(the_in_node, 'df_res_out_file', ds_pdf, the_out_node_str + 'results_error') wf.connect(the_in_node, 'tuning_curve_file', ds_pdf, the_out_node_str + 'tuning_curve') wf.connect(the_in_node, 'scatter_file_cv', ds_pdf, the_out_node_str + 'scatter_cv') wf.connect(the_in_node, 'learning_curve_plot_file', ds_pdf, the_out_node_str + 'learning_curve_plot_file.@plot') wf.connect(the_in_node, 'learning_curve_df_file', ds_pdf, the_out_node_str + 'learning_curve_df_file.@df') # NKI if run_2sample_training: wf.connect(select_multimodal_X_nki, 'X_multimodal_selected_file', the_in_node, 'X_file_nki') wf.connect(select_subjects_nki, 'df_use_pickle_file', the_in_node, 'df_file_nki') else: the_in_node.inputs.df_file_nki = None the_in_node.inputs.X_file_nki = None # BACKPROJECT PREDICTION WEIGHTS # map weights back to single modality original format (e.g., nifti or matrix) the_out_node_str = 'backprojection_single_source_model_reg_%s_' % (reg) backprojection_node_dict[i] = backproject_and_split_weights.clone(the_out_node_str) the_from_node = prediction_node_dict[i] the_in_node = backprojection_node_dict[i] wf.connect(the_from_node, 'model_out_file', the_in_node, 'trained_model_file') wf.connect(aggregate_multimodal_metrics, 'multimodal_backprojection_info', the_in_node, 'multimodal_backprojection_info') wf.connect(aggregate_multimodal_metrics, 'multimodal_name', the_in_node, 'data_str') wf.connect(target_infosource, 'target_name', the_in_node, 'target_name') wf.connect(the_in_node, 'out_file_list', ds_pdf, the_out_node_str + '.@weights') wf.connect(the_in_node, 'out_file_render_list', ds_pdf, the_out_node_str + 'renders.@renders') i += 1 ############################################################################################################### # # RUN WF 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 create_lemon_resting(subject, working_dir, data_dir, freesurfer_dir, out_dir, vol_to_remove, TR, epi_resolution, highpass, lowpass, echo_space, te_diff, pe_dir, standard_brain, standard_brain_resampled, standard_brain_mask, standard_brain_mask_resampled, fwhm_smoothing): # set fsl output type to nii.gz fsl.FSLCommand.set_default_output_type('NIFTI_GZ') # main workflow func_preproc = Workflow(name='lemon_resting') func_preproc.base_dir = working_dir func_preproc.config['execution'][ 'crashdump_dir'] = func_preproc.base_dir + "/crash_files" # select files templates = { 'func': 'func/EPI_t2.nii', 'fmap_phase': 'unwarp/B0_ph.nii', 'fmap_mag': 'unwarp/B0_mag.nii', 'anat_head': 'preprocessed/mod/anat/T1.nii.gz', #either with mod or without 'anat_brain': 'preprocessed/mod/anat/brain.nii.gz', #new version with brain_extraction from freesurfer #T1_brain_brain.nii.gz', 'brain_mask': 'preprocessed/mod/anat/T1_brain_mask.nii.gz', #T1_brain_brain_mask.nii.gz', 'ants_affine': 'preprocessed/mod/anat/transforms2mni/transform0GenericAffine.mat', 'ants_warp': 'preprocessed/mod/anat/transforms2mni/transform1Warp.nii.gz' } selectfiles = Node(nio.SelectFiles(templates, base_directory=data_dir), name="selectfiles") # node to remove first volumes remove_vol = Node(util.Function(input_names=['in_file', 't_min'], output_names=["out_file"], function=strip_rois_func), name='remove_vol') remove_vol.inputs.t_min = vol_to_remove # workflow for motion correction moco = create_moco_pipeline() # workflow for fieldmap correction and coregistration fmap_coreg = create_fmap_coreg_pipeline() fmap_coreg.inputs.inputnode.fs_subjects_dir = freesurfer_dir fmap_coreg.inputs.inputnode.fs_subject_id = subject fmap_coreg.inputs.inputnode.echo_space = echo_space fmap_coreg.inputs.inputnode.te_diff = te_diff fmap_coreg.inputs.inputnode.pe_dir = pe_dir # workflow for applying transformations to timeseries transform_ts = create_transform_pipeline() transform_ts.inputs.inputnode.resolution = epi_resolution #workflow to convert signal into percent signal change normalize = create_normalize_pipeline() normalize.inputs.inputnode.tr = TR #workflow to transform timeseries to MNI ants_registration = create_ants_registration_pipeline() ants_registration.inputs.inputnode.ref = standard_brain_resampled #workflow to smooth smoothing = create_smoothing_pipeline() smoothing.inputs.inputnode.fwhm = fwhm_smoothing #workflow to correct slice timing slicetiming = create_slice_timing_pipeline() #visualize registration results visualize = create_visualize_pipeline() visualize.inputs.inputnode.mni_template = standard_brain_resampled #sink to store files sink = Node(nio.DataSink( parameterization=False, base_directory=out_dir, substitutions=[ ('fmap_phase_fslprepared', 'fieldmap'), ('fieldmap_fslprepared_fieldmap_unmasked_vsm', 'shiftmap'), ('plot.rest_coregistered', 'outlier_plot'), ('filter_motion_comp_norm_compcor_art_dmotion', 'nuissance_matrix'), ('rest_realigned.nii.gz_abs.rms', 'rest_realigned_abs.rms'), ('rest_realigned.nii.gz.par', 'rest_realigned.par'), ('rest_realigned.nii.gz_rel.rms', 'rest_realigned_rel.rms'), ('rest_realigned.nii.gz_abs_disp', 'abs_displacement_plot'), ('rest_realigned.nii.gz_rel_disp', 'rel_displacment_plot'), ('art.rest_coregistered_outliers', 'outliers'), ('global_intensity.rest_coregistered', 'global_intensity'), ('norm.rest_coregistered', 'composite_norm'), ('stats.rest_coregistered', 'stats'), ('rest_denoised_bandpassed_norm.nii.gz', 'rest_preprocessed.nii.gz'), ('rest_denoised_bandpassed_norm_trans.nii.gz', 'rest_mni.nii.gz'), ('rest2anat_masked_st_norm_trans_smooth.nii', 'rest_mni_smoothed.nii') ]), name='sink') # connections func_preproc.connect([ #remove the first volumes (selectfiles, remove_vol, [('func', 'in_file')]), #align volumes and motion correction (remove_vol, moco, [('out_file', 'inputnode.epi')]), #prepare field map (selectfiles, fmap_coreg, [('fmap_phase', 'inputnode.phase'), ('fmap_mag', 'inputnode.mag'), ('anat_head', 'inputnode.anat_head'), ('anat_brain', 'inputnode.anat_brain')]), (moco, fmap_coreg, [('outputnode.epi_mean', 'inputnode.epi_mean')]), (remove_vol, transform_ts, [('out_file', 'inputnode.orig_ts')]), (selectfiles, transform_ts, [('anat_head', 'inputnode.anat_head')]), (selectfiles, transform_ts, [('brain_mask', 'inputnode.brain_mask')]), (moco, transform_ts, [('outputnode.mat_moco', 'inputnode.mat_moco')]), (fmap_coreg, transform_ts, [('outputnode.fmap_fullwarp', 'inputnode.fullwarp')]), ##add slice time correction after applying motion realignement + unwarping (transform_ts, slicetiming, [('outputnode.trans_ts_masked', 'inputnode.ts')]), (slicetiming, normalize, [('outputnode.ts_slicetcorrected', 'inputnode.epi_coreg')]), (normalize, ants_registration, [('outputnode.normalized_file', 'inputnode.denoised_ts')]), #registration to MNI space (selectfiles, ants_registration, [('ants_affine', 'inputnode.ants_affine')]), (selectfiles, ants_registration, [('ants_warp', 'inputnode.ants_warp') ]), (ants_registration, smoothing, [('outputnode.ants_reg_ts', 'inputnode.ts_transformed')]), (smoothing, visualize, [('outputnode.ts_smoothed', 'inputnode.ts_transformed')]), ##all the output ( moco, sink, [ #('outputnode.epi_moco', 'realign.@realigned_ts'), ('outputnode.par_moco', 'realign.@par'), ('outputnode.rms_moco', 'realign.@rms'), ('outputnode.mat_moco', 'realign.MAT.@mat'), ('outputnode.epi_mean', 'realign.@mean'), ('outputnode.rotplot', 'realign.plots.@rotplot'), ('outputnode.transplot', 'realign.plots.@transplot'), ('outputnode.dispplots', 'realign.plots.@dispplots'), ('outputnode.tsnr_file', 'realign.@tsnr') ]), ( fmap_coreg, sink, [ ('outputnode.fmap', 'coregister.transforms2anat.@fmap'), #('outputnode.unwarpfield_epi2fmap', 'coregister.@unwarpfield_epi2fmap'), ('outputnode.unwarped_mean_epi2fmap', 'coregister.@unwarped_mean_epi2fmap'), ('outputnode.epi2fmap', 'coregister.@epi2fmap'), #('outputnode.shiftmap', 'coregister.@shiftmap'), ('outputnode.fmap_fullwarp', 'coregister.transforms2anat.@fmap_fullwarp'), ('outputnode.epi2anat', 'coregister.@epi2anat'), ('outputnode.epi2anat_mat', 'coregister.transforms2anat.@epi2anat_mat'), ('outputnode.epi2anat_dat', 'coregister.transforms2anat.@epi2anat_dat'), ('outputnode.epi2anat_mincost', 'coregister.@epi2anat_mincost') ]), ( transform_ts, sink, [ #('outputnode.trans_ts', 'coregister.@full_transform_ts'), ('outputnode.trans_ts_mean', 'coregister.@full_transform_mean'), ('outputnode.resamp_brain', 'coregister.@resamp_brain') ]), (ants_registration, sink, [('outputnode.ants_reg_ts', 'ants.@antsnormalized')]), (smoothing, sink, [('outputnode.ts_smoothed', '@smoothed.FWHM6')]), ]) #func_preproc.write_graph(dotfilename='func_preproc.dot', graph2use='colored', format='pdf', simple_form=True) func_preproc.run()
'26723', '26724', '26728', '26753', '26782', '26789', '26793', '26801', '26802', '26803', '26804', '26805', '26806', '26820', '26839', '26841', '26842', '26843', '26844', '26856', '26857', '26858', '26926', '27696', '27834', '27954'] ###################### # WF ###################### wd_dir = '/scr/kansas1/data/lsd-lemon/lemon_wd_meanDist_%s' % distype ds_dir = '/scr/kansas1/data/lsd-lemon/lemon_results_meanDist_%s' % distype wf = Workflow(name='distconnect_meanDist_%s' % distype) wf.base_dir = os.path.join(wd_dir) nipype_cfg = dict(logging=dict(workflow_level='DEBUG'), execution={'stop_on_first_crash': False, 'remove_unnecessary_outputs': False, 'job_finished_timeout': 120}) config.update_config(nipype_cfg) wf.config['execution']['crashdump_dir'] = os.path.join(wd_dir, 'crash') ds = Node(nio.DataSink(base_directory=ds_dir), name='ds') ###################### # GET DATA ###################### # SUBJECTS ITERATOR subjects_infosource = Node(util.IdentityInterface(fields=['subject_id']), name='subjects_infosource')