From fbefadb6de2e515ccb2c52461311e244b58aa7ea Mon Sep 17 00:00:00 2001 From: Vyacheslav Yarkin Date: Sun, 19 Sep 2021 22:25:35 +0300 Subject: [PATCH] inital --- .../Introduction-checkpoint.ipynb | 533 ++++++ .../preprocessing-checkpoint.ipynb | 1488 +++++++++++++++ seminar4/Introduction.ipynb | 267 ++- seminar4/__pycache__/utils.cpython-36.pyc | Bin 540 -> 540 bytes seminar4/hello/graph1.json | 8 +- seminar4/preprocessing.ipynb | 1614 +++-------------- 6 files changed, 2455 insertions(+), 1455 deletions(-) create mode 100644 seminar4/.ipynb_checkpoints/Introduction-checkpoint.ipynb create mode 100644 seminar4/.ipynb_checkpoints/preprocessing-checkpoint.ipynb diff --git a/seminar4/.ipynb_checkpoints/Introduction-checkpoint.ipynb b/seminar4/.ipynb_checkpoints/Introduction-checkpoint.ipynb new file mode 100644 index 0000000..7234760 --- /dev/null +++ b/seminar4/.ipynb_checkpoints/Introduction-checkpoint.ipynb @@ -0,0 +1,533 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# fMRI data preprocessing - Introduction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/adasegroup/NEUROML2020/blob/seminar4/seminar-4/Introduction.ipynb)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "fMRI scans are saved in dicom format. For scientific analysis of brain images the nifty format (.nii files) are often used.\n", + "The conversion from dicom to nifty can be done with [dcm2niix](https://www.nitrc.org/plugins/mwiki/index.php/dcm2nii:MainPage#Introduction) \n", + "\n", + "Many file are generated during fMRI sessions. These can arranged in many ways, thus a standard is needed how to arrange them. \n", + "Commonly used standard is [Brain Imaging Data Structure (BIDS)](https://bids.neuroimaging.io/).\n", + "\n", + "You can use [HeuDiConv](https://heudiconv.readthedocs.io/en/latest/) or [Dcm2Bids](https://cbedetti.github.io/Dcm2Bids/tutorial/) to automate the conversion from dicom to BIDS.\n", + "\n", + "![DICOM TO BIDS](https://www.incf.org/sites/default/files/articles/bids_standard-2.jpg)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Let's download the data we will be working with. We will download data through DataLad. It's destibuted data managements system, its provide data storage and version control.\n", + "\n", + "http://www.datalad.org/ \n", + "\n", + "about the data, that we working with:\n", + "https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3641991/" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "get(ok): derivatives/fmriprep/sub-06/anat/sub-06_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-01/anat/sub-01_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-02/anat/sub-02_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from origin...]\n", + "get(ok): derivatives/fmriprep/sub-09/anat/sub-09_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-05/anat/sub-05_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-03/anat/sub-03_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from origin...]\n", + "get(ok): derivatives/fmriprep/sub-08/anat/sub-08_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-10/anat/sub-10_t1w_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-04/anat/sub-04_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-01/anat/sub-01_t1w_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-06/anat/sub-06_t1w_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-10/anat/sub-10_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from origin...]\n", + "get(ok): derivatives/fmriprep/sub-07/anat/sub-07_t1w_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-04/anat/sub-04_t1w_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-05/anat/sub-05_t1w_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-07/anat/sub-07_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-03/anat/sub-03_t1w_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-08/anat/sub-08_t1w_preproc.nii.gz (file) [from origin...]\n", + "get(ok): derivatives/fmriprep/sub-09/anat/sub-09_t1w_preproc.nii.gz (file) [from origin...]\n", + "get(ok): derivatives/fmriprep/sub-02/anat/sub-02_t1w_preproc.nii.gz (file) [from origin...]\n", + "get(ok): sub-06/ses-test/func/sub-06_ses-test_task-fingerfootlips_bold.nii.gz (file) [from web...]\n", + "get(ok): sub-07/ses-test/func/sub-07_ses-test_task-fingerfootlips_bold.nii.gz (file) [from web...]\n", + "get(ok): sub-03/ses-test/func/sub-03_ses-test_task-fingerfootlips_bold.nii.gz (file) [from origin...]\n", + "get(ok): sub-08/ses-test/func/sub-08_ses-test_task-fingerfootlips_bold.nii.gz (file) [from origin...]\n", + "get(ok): sub-10/ses-test/func/sub-10_ses-test_task-fingerfootlips_bold.nii.gz (file) [from web...]\n", + "get(ok): sub-09/ses-test/func/sub-09_ses-test_task-fingerfootlips_bold.nii.gz (file) [from origin...]\n", + "get(ok): sub-02/ses-test/func/sub-02_ses-test_task-fingerfootlips_bold.nii.gz (file) [from web...]\n", + "get(ok): sub-04/ses-test/func/sub-04_ses-test_task-fingerfootlips_bold.nii.gz (file) [from origin...]\n", + "get(ok): sub-05/ses-test/func/sub-05_ses-test_task-fingerfootlips_bold.nii.gz (file) [from origin...]\n", + "action summary:\n", + " get (notneeded: 2, ok: 29)\n" + ] + } + ], + "source": [ + "%%bash\n", + "datalad get -J 4 -d /data/ds000114 \\\n", + " /data/ds000114/derivatives/fmriprep/sub-*/anat/*preproc.nii.gz \\\n", + " /data/ds000114/sub-*/ses-test/func/*fingerfootlips*" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ses-retest/\n", + " dwi/\n", + " sub-01_ses-retest_dwi.nii.gz\n", + " func/\n", + " sub-01_ses-retest_task-linebisection_events.tsv\n", + " sub-01_ses-retest_task-covertverbgeneration_bold.nii.gz\n", + " sub-01_ses-retest_task-linebisection_bold.nii.gz\n", + " sub-01_ses-retest_task-fingerfootlips_bold.nii.gz\n", + " sub-01_ses-retest_task-overtwordrepetition_bold.nii.gz\n", + " sub-01_ses-retest_task-overtverbgeneration_bold.nii.gz\n", + " anat/\n", + " sub-01_ses-retest_T1w.nii.gz\n" + ] + } + ], + "source": [ + "from utils import list_files\n", + "# The data is already in BIDS format\n", + "# The subjects peformed 5 tasks. We will focus on fingerfootlips task\n", + "list_files('/data/ds000114/sub-01/ses-retest')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "With nibabel we can load a file and inspect its properties." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Anatomical dimensionality is 3 and fmri is 4\n", + "Anatomical voxelization: (256, 156, 256)\n", + "fMRI voxelization: (64, 64, 30, 184)\n", + "\n", + "Anatomical volume affine:\n", + "[[ 9.99182463e-01 -5.10393567e-02 9.58159845e-03 -1.27317017e+02]\n", + " [ 3.95217389e-02 1.29798853e+00 -2.68560350e-02 -8.03349991e+01]\n", + " [-8.51583015e-03 3.53622437e-02 9.99593377e-01 -1.38213226e+02]\n", + " [ 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00]]\n", + "fMRI affine:\n", + "[[-3.99471426e+00 -2.04233140e-01 2.29353290e-02 1.30641693e+02]\n", + " [-2.05448717e-01 3.98260689e+00 -3.10890853e-01 -9.74732285e+01]\n", + " [ 6.95819734e-03 3.11659902e-01 3.98780894e+00 -8.06465759e+01]\n", + " [ 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00]]\n" + ] + } + ], + "source": [ + "import nibabel\n", + "from nilearn import plotting\n", + "import numpy as np\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "anat = nibabel.load('/data/ds000114/derivatives/fmriprep/sub-01/anat/sub-01_t1w_preproc.nii.gz')\n", + "fmri = nibabel.load('/data/ds000114/sub-01/ses-test/func/sub-01_ses-test_task-fingerfootlips_bold.nii.gz')\n", + "\n", + "print(f'Anatomical dimensionality is {anat.ndim} and fmri is {fmri.ndim}')\n", + "#The anatomical image have higher resolution then the fmri\n", + "print(f'Anatomical voxelization: {anat.shape}\\nfMRI voxelization: {fmri.shape}')\n", + "#the data can be accessed as\n", + "print(f'\\nAnatomical volume affine:\\n{anat.affine}\\nfMRI affine:\\n{fmri.affine}')\n", + "data = np.array(anat.dataobj)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "Lets stop on SliceTiming key, unlike a photograph, in which the entire picture is taken in a single moment, an fMRI volume is acquired in slices. Each of these slices takes time to acquire - from tens to hundreds of milliseconds." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "The two most commonly used methods for creating volumes are sequential and interleaved slice acquisition. Sequential slice acquisition acquires each adjacent slice consecutively, either bottom-to-top or top-to-bottom. Interleaved slice acquisition acquires every other slice, and then fills in the gaps on the second pass. Both of these methods are illustrated in the video below.\n", + "\n", + "https://www.brainvoyager.com/bv/doc/UsersGuide/Preprocessing/SliceScanTimeCorrection.html" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "![SliceTiming](https://andysbrainbook.readthedocs.io/en/latest/_images/SliceTimingCorrection_Demo.gif \"slicetiming\")" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'EchoTime': 0.05,\n", + " 'FlipAngle': 90,\n", + " 'RepetitionTime': 2.5,\n", + " 'SliceTiming': [0.0,\n", + " 1.2499999999999998,\n", + " 0.08333333333333333,\n", + " 1.333333333333333,\n", + " 0.16666666666666666,\n", + " 1.4166666666666663,\n", + " 0.25,\n", + " 1.4999999999999996,\n", + " 0.3333333333333333,\n", + " 1.5833333333333328,\n", + " 0.41666666666666663,\n", + " 1.666666666666666,\n", + " 0.5,\n", + " 1.7499999999999993,\n", + " 0.5833333333333333,\n", + " 1.8333333333333326,\n", + " 0.6666666666666666,\n", + " 1.9166666666666659,\n", + " 0.75,\n", + " 1.9999999999999991,\n", + " 0.8333333333333333,\n", + " 2.083333333333332,\n", + " 0.9166666666666666,\n", + " 2.1666666666666656,\n", + " 1.0,\n", + " 2.249999999999999,\n", + " 1.0833333333333333,\n", + " 2.333333333333332,\n", + " 1.1666666666666665,\n", + " 2.416666666666665],\n", + " 'TaskName': 'finger_foot_lips'}" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import json\n", + "\n", + "#metadata is located in json files\n", + "with open('/data/ds000114/task-fingerfootlips_bold.json', 'rt') as fp:\n", + " task_info = json.load(fp)\n", + "task_info" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "30" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(task_info['SliceTiming'])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# Introduction Nipype" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "**Why nipype?**\n", + "\n", + "Nipype allows to build preprocessing pipelines from different softwares, and it is computationally efficient. There are some helpful ready to use pipleines written with Nipype like [fmriprep](https://fmriprep.org/en/stable/index.html). To use fmriprep the data have to be in valid BIDS format. The user have to supply only the path to the data setup the [parametars](https://fmriprep.org/en/stable/usage.html#command-line-arguments). \n", + "\n", + "In Nipype, interfaces are python modules that allow you to use various external packages (e.g. FSL, SPM or FreeSurfer), even if they themselves are written in another programming language than python. Such an interface knows what sort of options an external program has and how to execute it.\n", + "\n", + "![Nipype architecture](https://raw.github.com/satra/intro2nipype/master/images/arch.png)\n", + "\n", + "In Nipype, a node is an object that executes a certain function. This function can be anything from a Nipype interface to a user-specified function or an external script. Each node consists of a name, an interface category and at least one input field, and at least one output field.\n", + "\n", + "\n", + "Once you connect multiple nodes to each other, you create a directed graph. In Nipype we call such graphs either workflows or pipelines. Directed connections can only be established from an output field of a node to an input field of another node." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "210919-18:16:51,65 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"a_x_b\" in \"/tmp/tmpqiswn1p2/a_x_b\".\n", + "210919-18:16:51,71 nipype.workflow INFO:\n", + "\t [Node] Running \"a_x_b\" (\"nipype.interfaces.utility.wrappers.Function\")\n", + "210919-18:16:51,76 nipype.workflow INFO:\n", + "\t [Node] Finished \"a_x_b\".\n" + ] + }, + { + "data": { + "text/plain": [ + "\n", + "multiply_result = 6" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from nipype import Node, Function, Workflow\n", + "from IPython.display import Image, clear_output\n", + "\n", + "\n", + "def multiply(a, b):\n", + " return a * b\n", + "\n", + "#Create a Node that multiplies 2 numbers\n", + "mul = Node(Function(input_names=['a', 'b'],\n", + " output_names=['multiply_result'],\n", + " function=multiply), \n", + " name='a_x_b')\n", + "\n", + "mul.inputs.a = 2\n", + "mul.inputs.b = 3\n", + "\n", + "result = mul.run()\n", + "result.outputs" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Create a Node that adds 2 numbers\n", + "def add(a, b):\n", + " return a + b\n", + "\n", + "\n", + "\n", + "adder = Node(Function(input_names=['a', 'b'],\n", + " output_names=['add'],\n", + " function=add), \n", + " name='a_plus_b')\n", + "adder.inputs.b = 10\n", + "\n", + "#Create a workflow \n", + "wf = Workflow('hello')\n", + "# connect the nodes \n", + "wf.connect(mul, 'multiply_result', adder, 'a')\n", + "#visualize the graph\n", + "wf.write_graph(graph2use='flat', format='png', simple_form=True)\n", + "clear_output()\n", + "Image(filename='graph_detailed.png')" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[\n", + " multiply_result = 6,\n", + " \n", + " add = 16]" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#run the graph\n", + "eg = wf.run()\n", + "clear_output()#don't print the pipeline steps during exection\n", + "#check the results\n", + "eg = list(eg.nodes())\n", + "nodes_outputs = [node.result.outputs for node in eg]\n", + "nodes_outputs" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "**Dataset:**\n", + "[A test-retest fMRI dataset for motor, language and spatial attention functions](https://openneuro.org/datasets/ds000114/versions/1.0.1)\n", + "\n", + "**About nipype**\n", + "https://www.frontiersin.org/articles/10.3389/fninf.2011.00013/full\n", + "\n", + "**Thanks to Michael Notter for the wonderful [nipype tutorial](https://miykael.github.io/nipype_tutorial/)**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "anaconda-cloud": {}, + "celltoolbar": "Slideshow", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/seminar4/.ipynb_checkpoints/preprocessing-checkpoint.ipynb b/seminar4/.ipynb_checkpoints/preprocessing-checkpoint.ipynb new file mode 100644 index 0000000..f563112 --- /dev/null +++ b/seminar4/.ipynb_checkpoints/preprocessing-checkpoint.ipynb @@ -0,0 +1,1488 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "# fMRI data preprocessing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/adasegroup/NEUROML2020/blob/seminar4/seminar-4/preprocessing.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'commit_hash': '640080d',\n", + " 'commit_source': 'installation',\n", + " 'default_encoding': 'UTF-8',\n", + " 'ipython_path': '/opt/miniconda-latest/envs/neuro/lib/python3.6/site-packages/IPython',\n", + " 'ipython_version': '7.14.0',\n", + " 'os_name': 'posix',\n", + " 'platform': 'Linux-4.19.76-linuxkit-x86_64-with-debian-9.12',\n", + " 'sys_executable': '/opt/miniconda-latest/envs/neuro/bin/python',\n", + " 'sys_platform': 'linux',\n", + " 'sys_version': '3.6.10 | packaged by conda-forge | (default, Apr 24 2020, '\n", + " '16:44:11) \\n'\n", + " '[GCC 7.3.0]'}\n" + ] + } + ], + "source": [ + "import nibabel\n", + "from nilearn import plotting\n", + "import matplotlib\n", + "import numpy as np\n", + "import warnings\n", + "\n", + "\n", + "anat = nibabel.load('/data/ds000114/derivatives/fmriprep/sub-01/anat/sub-01_t1w_preproc.nii.gz')\n", + "fmri = nibabel.load('/data/ds000114/sub-01/ses-test/func/sub-01_ses-test_task-fingerfootlips_bold.nii.gz')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "# Preprocessing\n", + "\n", + "\n", + "In this workflow we will conduct the following steps:\n", + "\n", + "**1. Coregistration of functional images to anatomical images (according to FSL's FEAT pipeline)**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + "Co-registrationis the process of spatial alignment of 2 images. The target image is also called reference volume. The goodness of alignment is evaluated with a cost function.\n", + "\n", + "We have to move the fmri series from fmri native space:" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plotting.view_img(nibabel.nifti1.Nifti1Image(fmri.get_data()[:,:,:,1], affine=fmri.affine), bg_img=anat, threshold=0.1e3, cut_coords=(0,0,0), title='Anat and fmri misalignment')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "source": [ + " To native anatomical space:" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "**2. Motion correction of functional images with FSL's MCFLIRT**\n", + "\n", + " The images are aligned with rigid transformation - rotations, translations, reflections.\n", + " Then spatial interpolation is done, so as there was no movements.\n", + "\n", + "![Rigit transformation](https://www.researchgate.net/profile/Olivier_Serres/publication/43808029/figure/fig4/AS:304436623757316@1449594755197/Rigid-body-transformation-scale-1.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + " **3. Slice Timing correction**\n", + " \n", + " The brain slices are not acquired at the same time. Therefore, interpolation is done between the nearest timepoints\n", + "![Slice Order](https://crnl.readthedocs.io/_images/slice_order_1.jpg)\n", + "\n", + "[Slice timing corretion in python](https://matthew-brett.github.io/teaching/slice_timing.html)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "**4. Smoothing of coregistered functional images with FWHM set to 5/10 mm**\n", + "\n", + "**5. Artifact Detection in functional images (to detect outlier volumes)**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "**So, let's start!**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "source": [ + "## Imports\n", + "\n", + "First, let's import all the modules we later will be needing." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "from nilearn import plotting\n", + "%matplotlib inline\n", + "from os.path import join as opj\n", + "import os\n", + "import json\n", + "from nipype.interfaces.fsl import (BET, ExtractROI, FAST, FLIRT, ImageMaths,\n", + " MCFLIRT, SliceTimer, Threshold)\n", + "from nipype.interfaces.spm import Smooth\n", + "from nipype.interfaces.utility import IdentityInterface\n", + "from nipype.interfaces.io import SelectFiles, DataSink\n", + "from nipype.algorithms.rapidart import ArtifactDetect\n", + "from nipype import Workflow, Node" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Experiment parameters\n", + "\n", + "It's always a good idea to specify all parameters that might change between experiments at the beginning of your script. We will use one functional image for fingerfootlips task for ten subjects." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, + "outputs": [], + "source": [ + "experiment_dir = '/output'\n", + "output_dir = 'datasink'\n", + "working_dir = 'workingdir'\n", + "\n", + "# list of subject identifiers\n", + "#subject_list = ['01', '02', '03', '04', '05', '06', '07', '08', '09', '10']\n", + "\n", + "subject_list = ['01', '02']\n", + "# list of session identifiers\n", + "task_list = ['fingerfootlips']\n", + "\n", + "# Smoothing widths to apply\n", + "fwhm = [5, 10]\n", + "\n", + "# TR of functional images(time from the application of an excitation pulse to the application of the next pulse)\n", + "\n", + "with open('/data/ds000114/task-fingerfootlips_bold.json', 'rt') as fp:\n", + " task_info = json.load(fp)\n", + "TR = task_info['RepetitionTime']\n", + "\n", + "# Isometric resample of functional images to voxel size (in mm)\n", + "iso_size = 4" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Specify Nodes for the main workflow\n", + "\n", + "Initiate all the different interfaces (represented as nodes) that you want to use in your workflow." + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "# ExtractROI - skip dummy scans\n", + "#t_min - Minimum index for t-dimension\n", + "#t_size - Size of ROI in t-dimension\n", + "extract = Node(ExtractROI(t_min=4, t_size=-1, output_type='NIFTI'),\n", + " name=\"extract\")\n", + "\n", + "#MCFLIRT - motion correction\n", + "#https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/MCFLIRT\n", + "#mean_vol- volumes are averaged to create a new template\n", + "#normcorr cost - https://www.fmrib.ox.ac.uk/datasets/techrep/tr02mj1/tr02mj1/node4.html\n", + "#sinc interpolation - https://math.stackexchange.com/questions/1372632/how-does-sinc-interpolation-work\n", + "mcflirt = Node(MCFLIRT(mean_vol=True,\n", + " save_plots=True,\n", + " output_type='NIFTI'),\n", + " name=\"mcflirt\")\n", + "\n", + "#SliceTimer - correct for slice wise acquisition\n", + "#https://poc.vl-e.nl/distribution/manual/fsl-3.2/slicetimer/index.html\n", + "#more on https://matthew-brett.github.io/teaching/slice_timing.html\n", + "#interleaved = -odd\n", + "#top to bottom = --down\n", + "#normcorr loss\n", + "slicetimer = Node(SliceTimer(index_dir=False,\n", + " interleaved=True,\n", + " output_type='NIFTI',\n", + " time_repetition=TR),\n", + " name=\"slicetimer\")\n", + "\n", + "#Smooth - image smoothing\n", + "#spm_smooth for 3D Gaussian smoothing\n", + "smooth = Node(Smooth(), name=\"smooth\")\n", + "smooth.iterables = (\"fwhm\", fwhm)\n", + "\n", + "# Artifact Detection - determines outliers in functional images via intensity and motion paramters\n", + "#http://web.mit.edu/swg/art/art.pdf\n", + "#norm_threshold - Threshold to use to detect motion-related outliers when composite motion is being used\n", + "#zintensity_threshold - Intensity Z-threshold use to detection images that deviate from the mean\n", + "#spm_global like calculation to determine the brain mask\n", + "#parameter_source - Source of movement parameters\n", + "#use_differences - Use differences between successive motion (first element) and\n", + "#intensity parameter (second element) estimates in order to determine outliers.\n", + "\n", + "art = Node(ArtifactDetect(norm_threshold=2,\n", + " zintensity_threshold=3,\n", + " mask_type='spm_global',\n", + " parameter_source='FSL',\n", + " use_differences=[True, False],\n", + " plot_type='svg'),\n", + " name=\"art\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Coregistration Workflow\n", + "\n", + "Initiate a workflow that coregistrates the functional images to the anatomical image (according to FSL's FEAT pipeline)." + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "# BET - Skullstrip anatomical Image\n", + "#https://www.fmrib.ox.ac.uk/datasets/techrep/tr00ss2/tr00ss2.pdf\n", + "\n", + "bet_anat = Node(BET(frac=0.5,\n", + " robust=True,\n", + " output_type='NIFTI_GZ'),\n", + " name=\"bet_anat\")\n", + "\n", + "# FAST - Image Segmentation\n", + "#https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FAST\n", + "#http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.200.3832&rep=rep1&type=pdf\n", + "\n", + "segmentation = Node(FAST(output_type='NIFTI_GZ'),\n", + " name=\"segmentation\", mem_gb=4)\n", + "\n", + "# Select WM segmentation file from segmentation output\n", + "def get_wm(files):\n", + " return files[-1]\n", + "\n", + "# Threshold - Threshold WM probability image\n", + "threshold = Node(Threshold(thresh=0.5,\n", + " args='-bin',\n", + " output_type='NIFTI_GZ'),\n", + " name=\"threshold\")\n", + "\n", + "# FLIRT - pre-alignment of functional images to anatomical images\n", + "#https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FLIRT\n", + "coreg_pre = Node(FLIRT(dof=6, output_type='NIFTI_GZ'),\n", + " name=\"coreg_pre\")\n", + "\n", + "# FLIRT - coregistration of functional images to anatomical images with BBR(uses the segmentation)\n", + "#https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FLIRT_BBR\n", + "coreg_bbr = Node(FLIRT(dof=6,\n", + " cost='bbr',\n", + " schedule=opj(os.getenv('FSLDIR'),\n", + " 'etc/flirtsch/bbr.sch'),\n", + " output_type='NIFTI_GZ'),\n", + " name=\"coreg_bbr\")\n", + "\n", + "# Apply coregistration warp to functional images\n", + "#apply_isoxfm-apply transformation supplied by in_matrix_file\n", + "applywarp = Node(FLIRT(interp='spline',\n", + " apply_isoxfm=iso_size,\n", + " output_type='NIFTI'),\n", + " name=\"applywarp\")\n", + "\n", + "# Apply coregistration wrap to mean file\n", + "applywarp_mean = Node(FLIRT(interp='spline',\n", + " apply_isoxfm=iso_size,\n", + " output_type='NIFTI_GZ'),\n", + " name=\"applywarp_mean\")\n", + "\n", + "# Create a coregistration workflow\n", + "coregwf = Workflow(name='coregwf')\n", + "coregwf.base_dir = opj(experiment_dir, working_dir)\n", + "\n", + "# Connect all components of the coregistration workflow\n", + "coregwf.connect([(bet_anat, segmentation, [('out_file', 'in_files')]),\n", + " (segmentation, threshold, [(('partial_volume_files', get_wm),\n", + " 'in_file')]),\n", + " (bet_anat, coreg_pre, [('out_file', 'reference')]),\n", + " (threshold, coreg_bbr, [('out_file', 'wm_seg')]),\n", + " (coreg_pre, coreg_bbr, [('out_matrix_file', 'in_matrix_file')]),\n", + " (coreg_bbr, applywarp, [('out_matrix_file', 'in_matrix_file')]),\n", + " (bet_anat, applywarp, [('out_file', 'reference')]),\n", + " (coreg_bbr, applywarp_mean, [('out_matrix_file', 'in_matrix_file')]),\n", + " (bet_anat, applywarp_mean, [('out_file', 'reference')]),\n", + " ])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Specify input & output stream\n", + "\n", + "Specify where the input data can be found & where and how to save the output data." + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "# Infosource - a function free node to iterate over the list of subject names\n", + "infosource = Node(IdentityInterface(fields=['subject_id', 'task_name']),\n", + " name=\"infosource\")\n", + "infosource.iterables = [('subject_id', subject_list),\n", + " ('task_name', task_list)]\n", + "\n", + "# SelectFiles - to grab the data \n", + "anat_file = opj('derivatives', 'fmriprep', 'sub-{subject_id}', 'anat', 'sub-{subject_id}_t1w_preproc.nii.gz')\n", + "func_file = opj('sub-{subject_id}', 'ses-test', 'func',\n", + " 'sub-{subject_id}_ses-test_task-{task_name}_bold.nii.gz')\n", + "\n", + "templates = {'anat': anat_file,\n", + " 'func': func_file}\n", + "selectfiles = Node(SelectFiles(templates,\n", + " base_directory='/data/ds000114'),\n", + " name=\"selectfiles\")\n", + "\n", + "# Datasink - creates output folder for important outputs\n", + "datasink = Node(DataSink(base_directory=experiment_dir,\n", + " container=output_dir),\n", + " name=\"datasink\")\n", + "\n", + "## Use the following DataSink output substitutions\n", + "substitutions = [('_subject_id_', 'sub-'),\n", + " ('_task_name_', '/task-'),\n", + " ('_fwhm_', 'fwhm-'),\n", + " ('_roi', ''),\n", + " ('_mcf', ''),\n", + " ('_st', ''),\n", + " ('_flirt', ''),\n", + " ('.nii_mean_reg', '_mean'),\n", + " ('.nii.par', '.par'),\n", + " ]\n", + "subjFolders = [('fwhm-%s/' % f, 'fwhm-%s_' % f) for f in fwhm]\n", + "substitutions.extend(subjFolders)\n", + "datasink.inputs.substitutions = substitutions" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Specify Workflow\n", + "\n", + "Create a workflow and connect the interface nodes and the I/O stream to each other." + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [], + "source": [ + "# Create a preprocessing workflow\n", + "preproc = Workflow(name='preproc')\n", + "preproc.base_dir = opj(experiment_dir, working_dir)\n", + "\n", + "# Connect all components of the preprocessing workflow\n", + "preproc.connect([(infosource, selectfiles, [('subject_id', 'subject_id'),\n", + " ('task_name', 'task_name')]),\n", + " (selectfiles, extract, [('func', 'in_file')]),\n", + " (extract, mcflirt, [('roi_file', 'in_file')]),\n", + " (mcflirt, slicetimer, [('out_file', 'in_file')]),\n", + "\n", + " (selectfiles, coregwf, [('anat', 'bet_anat.in_file'),\n", + " ('anat', 'coreg_bbr.reference')]),\n", + " (mcflirt, coregwf, [('mean_img', 'coreg_pre.in_file'),\n", + " ('mean_img', 'coreg_bbr.in_file'),\n", + " ('mean_img', 'applywarp_mean.in_file')]),\n", + " (slicetimer, coregwf, [('slice_time_corrected_file', 'applywarp.in_file')]),\n", + " \n", + " (coregwf, smooth, [('applywarp.out_file', 'in_files')]),\n", + "\n", + " (mcflirt, datasink, [('par_file', 'preproc.@par')]),\n", + " (smooth, datasink, [('smoothed_files', 'preproc.@smooth')]),\n", + " (coregwf, datasink, [('applywarp_mean.out_file', 'preproc.@mean')]),\n", + "\n", + " (coregwf, art, [('applywarp.out_file', 'realigned_files')]),\n", + " (mcflirt, art, [('par_file', 'realignment_parameters')]),\n", + "\n", + " (coregwf, datasink, [('coreg_bbr.out_matrix_file', 'preproc.@mat_file'),\n", + " ('bet_anat.out_file', 'preproc.@brain')]),\n", + " (art, datasink, [('outlier_files', 'preproc.@outlier_files'),\n", + " ('plot_files', 'preproc.@plot_files')]),\n", + " ])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Visualize the workflow\n", + "\n", + "It always helps to visualize your workflow." + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "210919-19:11:16,484 nipype.workflow INFO:\n", + "\t Generated workflow graph: /output/workingdir/preproc/graph.png (graph2use=colored, simple_form=True).\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create preproc output graph\n", + "preproc.write_graph(graph2use='colored', format='png', simple_form=True)\n", + "\n", + "# Visualize the graph\n", + "from IPython.display import Image\n", + "Image(filename=opj(preproc.base_dir, 'preproc', 'graph.png'))" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "210919-19:11:17,295 nipype.workflow INFO:\n", + "\t Generated workflow graph: /output/workingdir/preproc/graph.png (graph2use=flat, simple_form=True).\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Visualize the detailed graph\n", + "preproc.write_graph(graph2use='flat', format='png', simple_form=True)\n", + "Image(filename=opj(preproc.base_dir, 'preproc', 'graph_detailed.png'))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "## Run the Workflow\n", + "\n", + "Now that everything is ready, we can run the preprocessing workflow. Change ``n_procs`` to the number of jobs/cores you want to use. **Note** that if you're using a Docker container and FLIRT fails to run without any good reason, you might need to change memory settings in the Docker preferences (6 GB should be enough for this workflow)." + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "210919-19:11:30,865 nipype.workflow INFO:\n", + "\t Workflow preproc settings: ['check', 'execution', 'logging', 'monitoring']\n", + "210919-19:11:30,921 nipype.workflow INFO:\n", + "\t Running in parallel.\n", + "210919-19:11:30,923 nipype.workflow WARNING:\n", + "\t Some nodes exceed the total amount of memory available (1.00GB).\n" + ] + }, + { + "ename": "RuntimeError", + "evalue": "Insufficient resources available for job", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0margs_dict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m'n_procs'\u001b[0m \u001b[0;34m:\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'memory_gb'\u001b[0m \u001b[0;34m:\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mpreproc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'MultiProc'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mplugin_args\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0margs_dict\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/opt/miniconda-latest/envs/neuro/lib/python3.6/site-packages/nipype/pipeline/engine/workflows.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, plugin, plugin_args, updatehash)\u001b[0m\n\u001b[1;32m 630\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mstr2bool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"execution\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"create_report\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 631\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_write_report_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbase_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexecgraph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 632\u001b[0;31m \u001b[0mrunner\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexecgraph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mupdatehash\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mupdatehash\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconfig\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 633\u001b[0m \u001b[0mdatestr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdatetime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutcnow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstrftime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"%Y%m%dT%H%M%S\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 634\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mstr2bool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"execution\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"write_provenance\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/opt/miniconda-latest/envs/neuro/lib/python3.6/site-packages/nipype/pipeline/plugins/base.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, graph, config, updatehash)\u001b[0m\n\u001b[1;32m 117\u001b[0m \u001b[0mpoll_sleep_secs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"execution\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"poll_sleep_duration\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 118\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 119\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_prerun_check\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgraph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 120\u001b[0m \u001b[0;31m# Generate appropriate structures for worker-manager model\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 121\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_generate_dependency_list\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgraph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/opt/miniconda-latest/envs/neuro/lib/python3.6/site-packages/nipype/pipeline/plugins/multiproc.py\u001b[0m in \u001b[0;36m_prerun_check\u001b[0;34m(self, graph)\u001b[0m\n\u001b[1;32m 196\u001b[0m )\n\u001b[1;32m 197\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mraise_insufficient\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 198\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mRuntimeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Insufficient resources available for job\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 199\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 200\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0many\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtasks_num_th\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocessors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mRuntimeError\u001b[0m: Insufficient resources available for job" + ] + } + ], + "source": [ + "args_dict = {'n_procs' : 1, 'memory_gb' : 1}\n", + "preproc.run('MultiProc', plugin_args=args_dict)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + }, + "solution2": "hidden", + "solution2_first": true + }, + "source": [ + "## Inspect output\n", + "\n", + "Let's check the structure of the output folder, to see if we have everything we wanted to save." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/output/datasink/preproc/sub-01/task-fingerfootlips\r\n", + "├── art.sub-01_ses-test_task-fingerfootlips_bold_outliers.txt\r\n", + "├── fwhm-10_ssub-01_ses-test_task-fingerfootlips_bold.nii\r\n", + "├── fwhm-5_ssub-01_ses-test_task-fingerfootlips_bold.nii\r\n", + "├── plot.sub-01_ses-test_task-fingerfootlips_bold.svg\r\n", + "├── sub-01_ses-test_task-fingerfootlips_bold_mean.mat\r\n", + "├── sub-01_ses-test_task-fingerfootlips_bold_mean.nii.gz\r\n", + "├── sub-01_ses-test_task-fingerfootlips_bold.par\r\n", + "└── sub-01_t1w_preproc_brain.nii.gz\r\n", + "\r\n", + "0 directories, 8 files\r\n" + ] + } + ], + "source": [ + "!tree /output/datasink/preproc/sub-01/task-fingerfootlips" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize results\n", + "\n", + "Let's check the effect of the different smoothing kernels." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "from nilearn import image, plotting\n", + "out_path = '/output/datasink/preproc/sub-01/task-fingerfootlips'" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAADJCAYAAAAHFcoVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO2de6xU5fn910FBRRQFURFRBG+gIiLVIveaSqs1aaReG6MmNk2T/tE0NU3amib1j/bfNtX6l9jU+I2tTVONaI0V5aCIWm+AV/CCIngHLfVCy/794W/tWXPOOjNzbpw9h/VJThje2fvd7977mf3Os+Z5nrcDQIEQQgghVI4RQz2AEEIIIXgySYcQQggVJZN0CCGEUFH2bfTm1q1bceSRR+6psYQBZtu2bZg4ceJQDyOEEEIf6UCDwLGiSExZu9PR0THUQwghhNBHIneHEEIIFSWTdAghhFBRMkmHEEIIFaXPk/SvfvUrTJo0CSNGjMDVV1/d6/0feughdHR0YP369X0dwpDy97//Haeddhr2339/zJgxA3fcccdQDymEEMIwo0+T9JNPPolf/vKX+OEPf4hHHnkE119//UCPq9KsXr0ay5Ytw5IlS3DvvffiggsuwOWXX477779/qIcWQghhGNGn6O7bbrsNV155JXbs2IGDDz64Twd+6KGHsGTJEqxbtw6nnnpqn/oYKpYuXYpdu3bhwQcfLNvOP/98fPzxx1i9evUQjqw7ie4OIYT2pdee9NVXX40rr7wSADB27Fh0dHTglltuQUdHBx599NFyu8svvxwdHR147rnnyrYLL7wQ3/3ud+v6e//993HxxRdjzJgxmDp1Km666aZux5szZw7uuecezJgxA6NHj8YFF1yADz/8EBs3bsSSJUtw4IEHYs6cOXXHGiw+//xzrFy5Epdcckld+2WXXYY1a9Zgx44dAIBbb70VHR0deOqpp7B48WKMHj0as2bNwlNPPYWdO3fimmuuwdixYzF16lT83//9X11fixcvxne+8x0sX74cxx13HMaMGYMrr7wSn3/+OR5//HGcddZZGDNmDBYvXozNmzcP+jmHEEIYOoqe/hwbN24sfvGLXxQAigcffLBYs2ZNsWPHjmLSpEnFb37zm3K7SZMmFfvvv3/x+9//viiKoti9e3dx6KGHFn/4wx+KoiiKlStXFgCK448/vrjhhhuK+++/v7jmmmsKAMXatWvLfq666qpiwoQJxezZs4u//vWvxZ/+9KfikEMOKZYtW1aceeaZxc0331ysWLGiOP3004vp06cXu3fvtuMmu3btavrXqI8NGzYUAIqVK1fWtT/++OMFgOLxxx8viqIoli9fXgAoTj311HKMM2fOLI477rji0ksvLX72s58V999/f3HZZZcV++67b/Hmm2+WfS1atKiYNGlSsWjRouLuu+8ubrzxxmLUqFHF9773vWLmzJnFbbfdVvztb38rJk+eXCxdurTh+Ta6v/nLX/7yl7/K//X8Zk9wAvrkk0/Ktssuu6y44IILiqIoik2bNhUjRowofvCDHxSXXnppURRF8eyzzxYAivXr1xdFUZukr7/++rKPL774ojjssMOKn/70p2XbVVddVeyzzz7Fxo0by7brrruuAFD88Y9/LNvuueeeAkDx/PPP93vSWr58eY/7r169ugBQPP3003Xtr7zySgGg+Mc//lF3jW699dZuY7zmmmvKtu3btxf77rtvcdNNN5VtixYtKsaOHVts3769bLv44osLAMXDDz9ctt14440FgGLnzp39Ot/85S9/+ctfNf8algXtDQsWLMDPf/5z7N69G6tWrcLMmTNx4YUX4tprrwUArFq1CuPGjcOMGTPq9jvvvPPK1yNHjsQJJ5yAt956q26bKVOmYNq0aeX/jz/+eADA1772tW5tW7ZswfTp03sc5xNPPNH0XI477rim23T9rbf4/7/fd20/99xzu41Rxz127FhMmDABW7Zsqdtvzpw5GDt2bN2+o0aNwvz587v19/bbb5evQwghDB8GbJJeuHAhtm/fjvXr16OzsxMLFizAvHnzsG3bNrz66qvo7OzE/Pnzu01ihxxySN3/R40ahc8++6zpNl3b2dZ1367MmjWr6bnss88+Pb536KGHAgC2b99e187/dx2rG2Nfz/mggw7CiBEj6tqA5uccQgihPRmwSfqUU07BuHHj0NnZiVWrVuHXv/41Dj74YMycOROdnZ3o7OzEj3/844E6XJ8ZOXJk022WL1/eY+73tGnTMHLkSLz44otYtGhR2f7iiy9ixIgROPHEEwdqqAPCAQccMNRDCGHI+fTTT4d6CCH0iQGbpDs6OjBv3jz8+c9/xsaNG7Fw4UIAX3rYt9xyC7Zu3YoFCxYM1OH6TH/l7v322w9LlizBX/7yF3z/+98v2++44w7MnTu3TqIOIYQQ+sOATdLAlxPyddddh5NOOgmHH344gC9/q/7d736H0aNHY/bs2QN5uD4xZ86cfvdx/fXXY/HixfjRj36Eb3/721ixYgVWrFiB++67bwBGGEIIIXzJgNbupqdML1rbzj777Jak5nZg/vz5uPPOO/HAAw9g6dKluOuuu3D77bfXBcGFEEII/SXrSQ9zRo8ePdRDCGHIyW/SoV3JKlghhBBCRckkHUIIIVSUTNIhhBBCRckkHUIIIVSUTNIhhBBCRckkHUIIIVSUhpP0tm3b9tQ4wiCQ+xdCCO1Nwzzp1H0OIQwHkicd2pXI3SGEEEJFGdDa3SGEUEWiCoaq05PaE086hBBCqCiZpEMIIYSKkkk6hBBCqCiZpEMIIYSKksCxEEIIoZfss88+LW3HJZ93797dp+PEkw4hhBAqSibpEEIIoaJE7g4hhNAyI0eOLF93dHT0uJ2+97///Q9ATfpttm9v0D6rSH/PM550CCGEUFHiSYcQQi9pNWhooGjkjaknOWJEze/iPs7T1O30daO+GfjkvGE3BtevC56quic81MSTDiGEECpKJukQQgihokTuDiHslaiE3EjyHSqaBRy597WtkdytsnOrcnOjfpws7saibXuLzN3f86yeZYYQQggBQDzpMAxp9s11oFI/wvCBNlNV23Dj4+ueVIBG59TM8x0I9BiNxt/TPq32PdyJJx1CCCFUlEzSIYQQQkWJ3B2GHa1KantCMquqfBraCxd41fW9ntqbBYn11kb78rlpFDjWLNhtb5K2HfGkQwghhIoSTxp73qMajscbLPriibpqUNqPSxvpz7icl8Bj/Pe//7X7DMRxB4KBugZhcHFBYs5TdmllrQZotZry1SwgzB2jkZ01Uwf6ki42nIgnHUIIIVSUTNIhhBBCRem13O1y8tpd9upL5SEn8zSr7NOVZsXwGwVbOAmo3aUgN/6BOqdm19XRqGKT7jtq1CgA9Uv4ff755y0do9FxFXffufyfQptqdUnAvlS1Gip7a/fnTH9oZIuKy39277ufYWjHAHDAAQd064Ov3TNy165d3bbTsThbdeNsJOv3dE5VJ0tVhhBCCMOUXnvSg7Fo92DjlmVr9o2s2XJsZL/99itf77vvl5fzP//5T9k2duxYAMDo0aPLtvfffx9A/bdP593x22ez60wPbv/99y/b9Jw//fRTAMAXX3zRsJ+hxp1nf4NGWvVAHG4f3mO9vhyj3k937/iafWg/zt50O95jtbdDDjkEQL297dy5s9t2HIt6Mzyejvmzzz4D4L2sZufr6E9qj7tv7jPbLs+gwcBVCnPBWnrf+RyaPXt22Uav+bXXXivbtm/fDqA+CHPMmDEA6u2SY/j3v/9dttF+1AZ5DB3Ljh07APjnUk/P51af38OJeNIhhBBCRckkHUIIIVSUYZ0nTWnEyYsu0EFxshElGwA4+eSTAQAzZ87s1vcrr7xStlFeOuyww8q2LVu2AKiXfjhGSkAAsHnzZgDAhx9+WLY5WdzJjgcddFD5muNWGXNvkouAvuWKNgqo0WvOnxP0ftIWdF9K1mpHfF+3o6yo95B2dPDBB5dtRx55ZLfzYMCa/vRBGXvbtm1lG+XMjz76qFubSpfcVyVJnqdK4LTfvuSjN3q/2T0aznbcl0pc2kab4s8iQO0+6XaUtGl3QO3eqq3yvqt98Pqr/fK1PndpvyqBk/fee6/bMXoKHNsbf96IJx1CCCFUlGHtSYcQQrvh1LJGAZAuuAuo94IJ1TSqJtrnhAkTyrbJkycDAMaPH1+2UdH7+OOPyzYGLTIYFqgFLzqVQ73riRMndmt79913AdQrN3p+ropaq+mw7cqwm6SdYaux0Eh7klN4czUamwZ7xhlnlG0LFiwAABx66KFlGw1szpw5ZRvlRI3APfvss+vGosdVmXLDhg0AgPvuu69sc1K5i3j85JNPur2vxr63rNvaqGxhMwmc100lOu5DWRmoXVeV/Hgf1Y4oVetPH5MmTQIAHHHEEWUbZXHXn9obx8WHIgAceOCB3bYj+iDlzyq0WaBmU5S4AeDtt98GAGzdurVse+uttwDU/wzDfdQGXXlW4j5zzWyt1RoGIQwnYvUhhBBCRekA0OPXVyeXNFtYYKhwY2kkjeg3fq0URS/nrLPOKtsWL14MoD6Qh16werT0VHQ7ehMaEEavSCUd7kNPCKgFVNCbAYCXXnoJAPDMM8+UbfSGmuUWKoNZ3Wsg6UuedCMPTnF263LqXV6o3jt6vE4u1PtJ22LQIVDzpNXjZt96DL5WpYWetF4jfmY1wIzn4WzQqUzqwTMojv8CNTVn/fr1Zdu6desA1IId9XjumirOk271XjeqZNWMqj/LnB07pUdth3UZgNq1UdWHcjilZgA45phj6v4FakGJGnTG55uqdC4okc8ttS2Oyyktam/PPvssAGDjxo1lm8vbdypk1eXuZraqnzElnnQIIYRQUYbdb9IhhDAccNXWtI2qiSp3qqDQa1ZFlG2HH3542XbSSScBAI466qhu22nfVIo0bY9BZKoYTZ06FUC9t0slSJUUl5JIz1xjIDT2gfuoykAPtYreM9D/cbX1JO2Cv1S65o3UQBhesHHjxpVtZ555Zvl61qxZAOoDeWj4Kj/SOJ287vJH3eILmmtLCUmjLmnkHBNQk+EppwLAmjVrANQCeoB6adPRqqxXVcNvRKvnph903h8nmalMxYel3s8pU6YAABYuXFi2HXvssQDqpUg+5DQQjfdYH2h8rWNRyb3r+FUm476ay8rtXK6zyqOufCwf1rodPzt8GAPAOeecA6AmVwLAypUrAQBvvPFG2dZoDWT93FT9wRvCniJydwghhFBR2tqTbuZpuEpcDI74+te/XrbNmzevfM3UFZV0mD6l3hO9IfXSGQCh3hPRfV3VH45VPQwew3ly6l3Tq2bwDgB0dnaWrxnU4QJ4mi1q0Z/AnKGi2SIwznPjPdFzd/eErxlYAwBLliwBUEvLA2rqi0p5LoCLHq9eZ/WqiZMGuZ3aoAsI4/VQSdKlW/EYOhaOT7fjtVI7ZwCcppfxs3bXXXeVbS+//HK3Y7hlPVtdJnS40Gp1Mc1bnjFjBoD64C4XqKjpeLQPtSMGkakEzn1cXrOmk1JRZDAhUJOn9fPF8Wu6oEtxPP744wHUq4L/+te/ytduucxWK9u1K/GkQwghhIrS1p50CCEMB9QLpKLh1BB6mgAwf/58APUpTOphMujL1fHX7ejJanpfoxTNZsWhdDzE1YBnf7ov1ZeLLrqobFNv/oknngDgY4HaJa20t7TlJO3yB12OMCU1lXG++c1vAqjPg9bAG7ceLw1C5XOX48cPgLZpAA+h0bkKYNrGMbg1f12eNyVHoF7C5zqxmzZtKtsYqOaC74aDYTfC5VXSVtzCK3qtGQGrP5fQltTOKHfrvh988AGAermQY9GHl8uj52u1LY7VPRQdKllzfPoA5DH0oU77UAme8rRWKyNORv3qV79atjGHVvNqXe6r+zlmOMrcITQjcncIIYRQUdrGk3apMRqM5dJl6C1oihW/3auH6ypKqdfRqHKZejEu+Iiv9RhuuTYer1lNbhfIxTbt97TTTitfT58+HQDw8MMPl21r164FUO+9cH89T77fl2pQQ0WzOt1UK1RFYJuTGDV/9Fvf+hYAYNmyZWUbU6s0IEyrMnU9hgt4VKnRpSk5+ya6L4/hKlO5gDTNq3UBOOxPFR560voZ4edJ64NzO03fOvHEEwHUpxo6VYfo58bJrcMR97zhs27atGllG6Vhvf+uEpc+o1xlNd4nzUdmmp32x/f1njDAVhfdoK04W9WxuPRDqkOaIjt37tzyNSsuqvrJ8ahC1erStHuC/ipA8aRDCCGEitI2nnQIIQw3XDogvWaNSWBVMFXImALXU81qerJOuVEFhd6rpp1S3VB1juNRD5lqinq+TAnTNQdc6lQjxcjFTwDA0UcfDQB45ZVXyjamnWmNchfQ1ogqq4NtM0m7ABKXh6cGdMoppwCoRUECNQNS2UXzCLm/yuHO2Nmmkjv71BtOKcrJ3RpkQ/nPVY/Sc3LF93lczVF1hey5RCZQk2aff/75bn27nxHaNXfaBYm5QEBnU6wkxmBDfa2LafD661q+vJ/64HByMo/nZGcX1KU0CqDUHGa+dj9ZuChfZ+d6Hnxf83P5WoPO3nnnnW79LVq0CED9+XIpVpUree7NJi9XCyGE4UTk7hBCCKGitI0n7ZbjU2+BHqh6M6zIo7mF7Ee/3btv4+pNNgpEUs+BHpVbWs3JKeop8Vxcqovigo94PVSaalRtDQBOP/10APWVfej9qYffjsE6ruKYCw7Ua0jvTK8hveYrrriibKPcpteNtqeerbtPfO2CZ/R+Oc+cx3Dnpraqr7ui50YP2UmNzlbVa3a154mO2Z0blaVzzz23bGOKoC6/6uyuypJkX3H2SflWz/0rX/kKgPogRqaLqo3p9eezSW3CqTS8t2q/DBJTdcOlKfJ4qixxXFpdzFU6c0oh29x2QK0m/quvvtqtb50PXOprI6oUaNaVeNIhhBBCRWkbTzqEENqZRt6aqiv0aDXGhCuOORVGU7A03Y3eqHqqTJXSdCvuo8dj35pW6BRMeuuq+nGZSfXCqeKoB899NMaA59eTKnjyyScDqF9tje/rdWCbUyOHykN29cZbofKTdCO5WG8KbwbzoIGaYWtgGLdzucxAzbA0upC4QB0N9KJhaI6sC1yiDKT98VycNKVG3Ehq1OvhZEfthwtEaAAP5W79IPE4LsiqHeC56MIDvMf68OK9OO+888q2b3zjGwDqpV7u64KX9N7xHusx3Fq4buEBvnYVuPTeuMhV9u3yrtWm3ZKbXcep/bg2HR/lRc1/dgt78KGv58GfYbSCGR/0bsGTqsiQIewJIneHEEIIFaXynjRxBdVVyqBHe8IJJ5RtTMFSr4LbuX2Bmkeg3+BdJTGXDsJ9tT/KN+r10ANR74nj6alYftc29WLo3WmbBl7Qk2HQk47f5Uuq18Q+XQpOVT0aF1TnvFcXkHLttdeWbVwOlKlEQO2eqbLg0qOceuHup8vndPs2CkRTO6In26xCnFMYeK3UJtimfbiqfHzfBafp54G5s+6auhrk7jwGSslptqTpQNCsX3fdaFuqCh5xxBEA6uvD83Pvqukpbqlb1pHXfTTXmUqc2rmrFU8b0EAtSuruGaUKCl+7RTfUtlQVZBCwqlsMPNTtXBDvUKXr9fc5GU86hBBCqCht40mHEEK74bwop6hoMBZ/t1cFkF6ubudULldoyMVP6Lhc0Rl69uqZu1RDjqGnGB9Cz1hVOp6Li4HRc3e1yVUB4rhUPeQ+qjKRniq0VZW2nKRpJE7KYPQfUFtYQ28UDdYF0QC1D1AjaRKoySkq/bBvt0CFwvdV4qLxNtuXxqfjcx9MVwpQoSSlEZiOdjDirui580Ggkivvtz5sTj31VAD1y30SldFYOlGvqatS564rx6APTdqh2iMfuu5h4hZQUBnPBac1yp3W68Ix6GIJjPjV4Ev2pw9Kl3fNAEqNEN6wYQMAYPPmzWUbz5fBYtqPq37mJN0QhiuRu0MIIYSKUnlP2gVe0JtwHqJ+G2cuoMogDIrRftUDcilH9CzU26E3pFIMPQv1Pl3lG3rB6oW7QDTnObBvbaO36JbN1H62bdtWtq1btw5A/dKCLs2nHb0WV9Pd2ZEG0rGmtMv3VImR/ai3yevlgsnU86V3qMfgPuptcjtVWnhv9d6wTT1l3i9tc/mybmlOVy+byoEqAwza0Qp2vC76+Xv99dcB1NeH58IILtCo1TS/dqp+53BLger9on3o/ec1bxaAqrggU5dayvc1fY75zy7lT8fPfZutdcDt9PiuVryzQacUqe2xUp1eB/csblfiSYcQQggVpfKedAghDAdc6iLVEFWs6DmqN8n3NQ6A22lcgVNp3PvNloekx6oevlv5j56vi59xy2aqV+xSR+ldu/MAavEhGnu0atUqAMB7771XtjVKX20377ptJmlnsHpzaQRvvPFG2fbcc88BqM//c+Xu3BJ5KjW5POlGlcncggdO4tL+2I8aJyVTPXe3HKaT/VXadItHUD5TKZfSZrNo0arjokHVVnju8+bNK9vOOOMMAPUydqOfVVRa4/t6Tygxq32wb/2JgQ9QXTjBSb0uN/nNN98EUG/LbqEZBsXpYjC0S72/tA8XOas/lfA8mLurY1i/fn3Z9sgjjwCo5bECNUnVBX26Wggul7nd5e4QekPk7hBCCKGiVN6TbpR6ot+o6WGOHz++bHNF3V0lGpfj57xc9Tr42lWU0uOxso9KNkxrccXm9bhueUJ6SOpd06vrKS3LLYc3bdo0AMDChQvLtvvuuw9AvTfpKl3tSfoiTaknzYAWtYsLL7wQAHD22WeXbS4Ih+euATVs03HRPlwqn46F11/7e+GFFwAAmzZtKtsY0KYLHjCdSe8rgyBdRT31uKkusapa1/ETesPqNW/ZsqWuX6C2IAODwICaavXkk0+WbQwcU2WGn0mXAtks4M9JmI3k1qqi50HFRW2H56zPFqpcbglHVcPcfXV9OylarzVtSoNR2Y+rJOZysd2907HwuG4Z2Z7Gz3Fr5TWqUFr73dWmd0tjksHMne5vhcZ40iGEEEJFqbwnHUIIwwn1pOmxOm/SpWiqoqGxCK5vpzgSF7PiCtFoHAvVD1UFqZKo+uZSCOlNaoCc284plG55Tm2jQsRCOYAPfOM5NVMFGy0pOhRUapJuVVLljdYbScnjnHPOKdsocaphN5KpgdqHRt/nzdU2vlZj5/E0aOexxx4DUL9+69KlSwHUfzAZmagfAMpYel34QXHyTE/LGPJ66XVg8NTcuXPLNkqVlNa0Tyc1VjVKUsfF6zl9+vSyjddfH0oMwnL9qJzMB4p++Cn5aa4or5suW0pb0TV/J0+eDKCWt67bqW1RduYSo0BtsQG1S47VlXN0Ub4aTEapX3Od+fDVY3CRDJW7mQutQXFuuU5eF5dDq/br5G62VdXuQhgMIneHEEIIFaVSnrT7huy8a+dN8rUGUTCwRr0efrvXtCv1OugxqOfrlhN0gV7cTvtmf+qdsm/1qFzAGs9Jj+uCN+i5q1fULFjOeWtMvVHPsR3RABJem5kzZ5ZtVBG0EhalQ71GvO5Tp07t1p96yK4KXNf3gNq1VnmPy2FqzXDalqtwp3ZJr1VTpmh7rna3fg7Yt9oqX2sbryW9Z6Cm+ug14D4uYNHV31Y7d8F4xC2R2e6etKsGqNec6o+mjvK17svrr3biglubPVfd9XcBYcQt2avPKAZGupQ/VxVRbZWvdbtmy5U6dcZJ6Y5GQV2DFUDWW+JJhxBCCBWlUp50CCEMV5zXxtfqSXM7VVdcrEwj9U37bJZyRPXIpUw59UXh++o1czvniTqlRT1ptqknrfA6aBqjq11ONcIFrzVLSRss+nqMyk/SjeQNZ0AaAMSlKnU7Bndpm5aTYz8q31AeVWOi7KnyqJNdli1b1m1fftBUQqQ0r3mQxH149APDD6PK1G7NVx0r87dfeumlso0yq5NPe3oQVJ3Zs2cDqJesaQO6wIaTUvkB1wcj5V/N/SX6AOL90SUeaTN673g/aWNA7QGj15xlEDWKlss9aqAXA8vUjlx/vP86Fm6ndsmcaZXZGSCn18BFEtMG1RbdzyyNommrFmkbwp4mcncIIYRQUSrvSYcQQrvhZFS2qaLF1y6XuVnwJ5WZnpaTpdLh1gNwi3yoEtcoeNRVNlT1je+75SsVt7CHq9rY07KVPfWnx3MSfU/7DDZ9rTlfqUm6kYyqN4oGoTeMMp9Kk8zjVAOhQeoF0983nGTNPl0Epm7XaDEN3U6P1xXNZXWSH6PX9YNJKVJ/m9FzdtIsx0rZE6iXUkk7SdsOZxcbN24EUG8/tAv3MHFrgisuZ5729c4775RtlMrd74puURa99m5NaG7nysvqvXRSNG1Gz81Fd/NhrQuAcHLQfWl7ar+NorFdZobi8vLdQ67d7TOEZlRqkg4hhD1FFSZ4fqlyS1VqbABh7ArgY030C6D7Qs/39QuqSyHkl1bnhSv8MqUBWgwi0+vLL3RuLO7LqKvXrfu4L3F6TtxfYzPcSnKN0v+qQqUm6VaDReiJqmHQUFnoH6gZuUYKch89hho+b5rmNTvDdiXy6NGoZ+MWAHAF7WlAzmBVemJutRo7vSY1PvXW6S3rB86dp1tGsB2XqlSeeeYZAMCcOXPKNuacasAg76MqCzx3tQ/eE1UtnITIZRy1P1d+kffMreWr94s50VoK0uX8OyWI/bh76QIQXe60e2i6amAu/7bZvo2kYaUKk2oIe5oEjoUQQggVpVKedAghDAdarWDllunU+ARCdUvfa5TipmjfrhY/1TlV7DhWlbjdcqDsp5mqwuO6a+DOycX1aLtb+leD11Qh7MpQKTJ9XQ5zyCfpVi+YOyk1Ghqay39Ww6V8pyUNNRF/ypQpAOpvOBcy0DKeNBItQUkpVOV1Gr6On+N2kYoqcXLcKnEy4EfbXnvtNQB+gQegZuQuJ1alzVbLCLYTvJ8qWTO4ya0p7n4z03vC66WBWQyq0t+/aIda2tFFnGp+NHGLZPDeamAWf5546623yjbaha4IRJtxa7K7srBqO7zvLijOFeXQh7+LXG518mr3n1lCGCiGfJIOIYS9Cf3Swi8j6nT1XygAAAzzSURBVFzwi45+6WObyzDpqdAQv+TpFx62uWwCV7vbrUOg/XEfdUxctTAew43VXQ/3pVDHoMyYMQNAfS1+ruinzowLOqtywBgZ8km61YvkpAINHNu0aRMAn3Pn8ux6qnjEimUM/AFqHvmJJ55YtnEN08MPP7xsa2QELlBGPyhsUw/eec0MhtPIT1ac0g+UjoHXyQWE6QfA5Sg6j6av+X5DAdOtVq9eXbbRK1Ulg/dYlxklbolSXcjFBUhRbtP77tQL3htXac55qurV8zxef/31so32qwFr7mHOMaudsD+XB+vuuYuwdeMf6Aeh9tdsDCG0O7HwEEIIoaIMuScdQgh7K1RSmhWkcTIw4xNUXXExLU6edusB6L6M2XExKwrbXK62Kp0uzsKpM1R9XPyEjluVpwkTJgCoX5CEqbjtIGc3oy0naV74Zotb0OjcmrRO+gNqxqn70MDUMHhsGghQM1i3/rOTLrWNxqn5t5Qs3RrC/BeofZB6Mmy3aIgbl6uO5vprJ8N/4403ANRX/nrhhRe6bUepV3++4OIY+jMHX+vPEgzg0ocqr6+2ud8DuZ1K77xPKrPTLvW+8ze4V199tWyjrbgHs+KCFnncVoO2mq3z2ypun1Z/UmknWwyhL7TlJB1CCO1Gq1kT3E6/fDHu5IQTTui2nRYu0uh/F3/DL4oa3MUvRM4Lb5b+RG9Zv1S5KmouDof9uBQxRfvh/pou5orh0HHR2BH27YLPqkzbTNIuhUm9TremKIOAnPH1BI1g8uTJZRtTsJjOA9SM3HkkLu/PRSu6Mnb6oXVBRS7Nq1nFplZrIw9WoM9QwnNXG3j66afr3gNq10MD8iZOnAig/sFIT1tlQKIPE752EbqN8mABX1/erdvLNuc1O9VE4futVhJzNKsQ1mjfZh53qxXH2imIMYS+kMCxEEIIoaK0jScdQgjtjFvIwq0LQFnWKW2qwnA7VWtUMeI+KoG7NEsnY/O1ysXcV1NCWYxHVRPGT6jy4eRnV63MqYcuJVSVRMZ9qArm0g7dmgntoBq29STd7AJrVTHCG6Q3SuVCBllpgA4NRnOnXYk8GpN+UGiIzaoquRxaVjPTPFgaYqtrtQK9lyKHE+5+uyIKfK33lQ9T/c2P+fj6oOVDUB9yfJhqhKsLWnTwpxu9r87e+IDUqma0C1cHoFnwX39solF/7mcFfchSwtcxcyLQNvdZ6m2wWwjtRltP0iGE0G60Gi/ivEANeuIXMu3DlbrV+AT3RYf7uHre+mWK22nBKDokWjKZ49F9Gy0xqWNx3q561XxfnZS1a9cCANavX99tH/dF3HnSVa5C1q9Jukr1nJ234GgWHEUD3Lx5c9nGtBZNhWLFsWnTppVtTNlRI6aX5Yrgu5QuVsgCaqlC6sm5ZRGb3YeqGV1P9OacWoX9qEfrHnhEP9SsQqbVyqjO6NKXrqKbS4Wi0uIiZnV8bqlKl7fqUuv4YFSJ06XbDdZnt9XPn47ZSaY8NxcQ2izXNoThRALHQgghhIoSuTuEEPYg6v0zjkGDo6iqaCDUunXrANQWkwC8eqj9UFVx6Z8u91hXinNj5T4qbVMR0f54XG1jwJhTS5yy5OJ6tG9VrV5++WUA9QWLxo8fD8DniDeL16ga/Zqk+1NlaKAZqIvMc3G/46gR0OicjO0WaVDDcHmwDJRRCdat/dpo/daerkFvl54c6KCzVqMpB8OO+CDQvhsFcOn4KFnrzw2MJGUAGVC7TxpsOHfuXAC1HHs9nka48gHp5GkXLKbw5xJd7pKyuFttqNlyk729/s1+W21kl/oQ5mTkonjdb4XtWv0uhL4QTzqEsNezJx0OV0DGfdnQteq59OLll19eth1zzDEA6r8cur4160C/HBGXicAvSa5oz5FHHlm+5vVSZ4XHc9fSfVHUtDJ+8XRfZLVPHRcdHFfAR8fgKo41yr4ZaPqa+tXrSXpv+RarXoyrKkYvSw2DhupK27k0FHc8l3bjIjaroF60A7zWGszXW/SeMKBQSzY66NE+8cQTZZuzIxfE5u67W8iAba1+DlsN6upPNbBm9eGdV+/yat1npNUUthCGEwkcCyGEECpK5O4QQhhinNqgbY899hgA4J///GfZdskllwCoj5lQBYIysVvoQtUIKn+qAPK1Kh5Ue1yNeqceumJNijuuW4lPY3x4TTRVdcOGDQDq69q76m7tujZBJukecAn2igvqadUIGgVyuWCcVAyrTj8M+tNVeJxMvGXLFgC1pTKbjavZfe9tW19o1ab44NMJwa1d3OqxGn1u8rNO2NvJJB1CCEOMy+DQil380nfzzTeXbUcddRQA4JRTTinbtK62C+qit6nrnLuCP/RutY1VvpwXrmOlB69VwZxny+OqJ90oFgGoBYw988wzZRsD57Q8rktta9dYhkzSPdCX4JlW923E3uIhtyutBi/xoaUPuUYMVPBXf2jVbnnug1kvu1G5xnxGwt5EAsdCCCGEihJPOoQQhgi3CAbVFw22ojLz7LPPlm233347AOCGG24o27QaGPfXwCsXEMb4GlWHXF34Aw88sO49oCY/ay6zq0LmUkfZn8I8blWgdAwMEmMgnfajcULMt9bj8XpUeTENRybpAWSg5bgEzVSP3krCg8lQ28dgHr+3OdFDfS1CGCwySYcQwh6kWbaGC6jilxWtGPboo48CANasWVO2nXvuueVrBoepx0oPWut0M8CrWQCXlq7t2p9DMyDoVWvRHlYV0+NyzOr9a4rZihUrANRXWWNZXB0zj61ePz1pl5ZVZTJJDyD5Nh9IbKF/5PqF8CUJHAshhBAqSjzpEELYAzSqee4CuTT3mJK0Bmixfvytt95atumqaxMnTgRQLxezTxcQpnI2JWFXXUwXt3C52JSQP/roo7LN5V3zXFQW57j0ejzwwAPl67Vr1wKol8O5jy7K4RYI2ZOLaQwk8aRDCCGEihJPOoSwV9KftbT7e7yuaPoQg6vU66QHrN41Vw978MEHy7bf/va35euf/OQnAOq9Tu6j/fB99V7pGR999NHd9n3vvfe6jZUpT4BfDpPesnrcbllKri64atWqsu3OO+8sX9PbV+/b3Ttup9kBPHY86RBCCCEMCJmkQwghhIoSuTuEEIYYlWxdBTAGd2lOMSVfzT1WaZjy9RVXXFG2MbBM86TZpx5v586dAGoSN1ALwlKpnMFYKnFr1bOux1BZn7nOuuwkc747OzvLtq1bt5av+ROAyuYMQNOcaF6TKlUX6+tPKvGkQwghhIrSAaDHrxcaDBBCCMMVejmu0tZQoZ4fPUgNmHJreKtHy31OOumksu2iiy4CAJx//vll27HHHtvt2PReXQrTBx98ULbdfffdAIB33323bKPnPn78+LKN+6xfv75su/feewEAzz//fNnGVDM9d1UPXCoXvWZNIRtqr7kZrlKbq+gGxJMOIYQQKksm6RBCCKGiRO4OIez1VFHuVijfqtzN/GKXYw3UJFV9f9y4cQCAY445pmybNm0aAGDWrFll21FHHdVtXwaTPffcc2XbU0891e24J598MgBg6tSpZduLL74IAHjkkUfKNlYk02vulrlUuZsytx5PJXnC+1lV2TtydwghhDAMiCcdQtjrqaIn7VJ2dHx8PqvX6Tw0Ta1impJuR09Vl7Rk3+q5E1YFA2qetgZy0XtVb5cBbc2W5NT0rq7b6fF68jqrCM9ZzyOedAghhDAMyCQdQgghVJTI3SGEvZ4qyt1KI+lbl6/U8VMGd1W3du3aVbZRQnYSrLseLhhL25y86/pzfVPu1n0195vjrmpAmCNydwghhDBMSe3uEEKoIM08UaJesdtfA7PodTuV1HnXLhVKA9FcQBiPoR4+93EBa9ofvUnnabpz63rs4Ug86RBCCKGiZJIOIYQQKkrk7hBCqDitVtBy72vVMLcMJmVpzVFmmwtEc1K0Surcp1nOtpO23T5O9q+SxN1Mmu8v8aRDCCGEihJPOoQQKkQjz9G959p62qdRupVu1+g4LmhL06TCwBJPOoQQQqgomaRDCCGEihK5O4QQ+sFgBw6FvZt40iGEEEJFiScdQtjrYQBUvOJQNeJJhxBCCBUlk3QIIYRQUSJ3hxCGPT0tAxhC1YknHUIIIVSUTNIhhBBCRckkHUIIIVSUTNIhhBBCRckkHUIIIVSUTNIhhBBCRckkHUIIIVSUTNIhhBBCRckkHUIIIVSUTNIhhBBCRckkHUIIIVSUTNIhhBBCRckkHUIIIVSUDgDFUA8ihBBCCN2JJx1CCCFUlEzSIYQQQkXJJB1CCCFUlEzSIYQQQkXJJB1CCCFUlEzSIYQQQkXJJB1CCCFUlEzSIYQQQkXJJB1CCCFUlEzSIYQQQkXJJB1CCCFUlEzSIYQQQkXJJB1CCCFUlEzSIYQQQkXJJB1CCCFUlEzSIYQQQkXJJB1CCCFUlP8Hpf4p/72PsCIAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plotting.plot_epi(opj(out_path, 'sub-01_ses-test_task-fingerfootlips_bold_mean.nii.gz'),\n", + " title=\"fwhm = 0mm\", display_mode='ortho', annotate=False, draw_cross=False, cmap='gray');" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plotting.plot_epi(image.mean_img(opj(out_path, 'fwhm-5_ssub-01_ses-test_task-fingerfootlips_bold.nii')),\n", + " title=\"fwhm = 5mm\", display_mode='ortho', annotate=False, draw_cross=False, cmap='gray');" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plotting.plot_epi(image.mean_img(opj(out_path, 'fwhm-10_ssub-01_ses-test_task-fingerfootlips_bold.nii')),\n", + " title=\"fwhm = 10mm\", display_mode='ortho', annotate=False, draw_cross=False, cmap='gray');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's investigate the motion parameters. How much did the subject move and turn in the scanner?" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "par = np.loadtxt('/output/datasink/preproc/sub-01/task-fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold.par')\n", + "fig, axes = plt.subplots(2, 1, figsize=(15, 5))\n", + "axes[0].set_ylabel('rotation (radians)')\n", + "axes[0].plot(par[0:, :3])\n", + "axes[1].plot(par[0:, 3:])\n", + "axes[1].set_xlabel('time (TR)')\n", + "axes[1].set_ylabel('translation (mm)');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There seems to be a rather drastic motion around volume 102. Let's check if the outliers detection algorithm was able to pick this up." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Outliers were detected at volumes: [ 59. 102.]\n" + ] + }, + { + "data": { + "image/svg+xml": [ + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "outlier_ids = np.loadtxt('/output/datasink/preproc/sub-01/task-fingerfootlips/art.sub-01_ses-test_task-fingerfootlips_bold_outliers.txt')\n", + "print('Outliers were detected at volumes: %s' % outlier_ids)\n", + "\n", + "from IPython.display import SVG\n", + "SVG(filename='/output/datasink/preproc/sub-01/task-fingerfootlips/plot.sub-01_ses-test_task-fingerfootlips_bold.svg')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternative for motion artifacts detection [ICA-based Automatic Removal Of Motion Artifact](https://nipype.readthedocs.io/en/0.13.1/interfaces/generated/interfaces.fsl/ICA_AROMA.html)\n", + "\n", + "\n", + "**Dataset:**\n", + "[A test-retest fMRI dataset for motor, language and spatial attention functions](https://openneuro.org/datasets/ds000114/versions/1.0.1)\n", + "\n", + "**Special thanks to Michael Notter for the wonderful [nipype tutorial](https://miykael.github.io/nipype_tutorial/)**" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "celltoolbar": "Slideshow", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/seminar4/Introduction.ipynb b/seminar4/Introduction.ipynb index 1672ec4..7234760 100644 --- a/seminar4/Introduction.ipynb +++ b/seminar4/Introduction.ipynb @@ -2,7 +2,11 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "# fMRI data preprocessing - Introduction" ] @@ -16,7 +20,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, "source": [ "fMRI scans are saved in dicom format. For scientific analysis of brain images the nifty format (.nii files) are often used.\n", "The conversion from dicom to nifty can be done with [dcm2niix](https://www.nitrc.org/plugins/mwiki/index.php/dcm2nii:MainPage#Introduction) \n", @@ -31,22 +39,64 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ - "Let's download the data we will be working with." + "Let's download the data we will be working with. We will download data through DataLad. It's destibuted data managements system, its provide data storage and version control.\n", + "\n", + "http://www.datalad.org/ \n", + "\n", + "about the data, that we working with:\n", + "https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3641991/" ] }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, + "execution_count": 2, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "get(ok): derivatives/fmriprep/sub-06/anat/sub-06_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-01/anat/sub-01_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-02/anat/sub-02_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from origin...]\n", + "get(ok): derivatives/fmriprep/sub-09/anat/sub-09_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-05/anat/sub-05_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-03/anat/sub-03_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from origin...]\n", + "get(ok): derivatives/fmriprep/sub-08/anat/sub-08_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-10/anat/sub-10_t1w_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-04/anat/sub-04_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-01/anat/sub-01_t1w_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-06/anat/sub-06_t1w_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-10/anat/sub-10_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from origin...]\n", + "get(ok): derivatives/fmriprep/sub-07/anat/sub-07_t1w_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-04/anat/sub-04_t1w_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-05/anat/sub-05_t1w_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-07/anat/sub-07_t1w_space-mni152nlin2009casym_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-03/anat/sub-03_t1w_preproc.nii.gz (file) [from web...]\n", + "get(ok): derivatives/fmriprep/sub-08/anat/sub-08_t1w_preproc.nii.gz (file) [from origin...]\n", + "get(ok): derivatives/fmriprep/sub-09/anat/sub-09_t1w_preproc.nii.gz (file) [from origin...]\n", + "get(ok): derivatives/fmriprep/sub-02/anat/sub-02_t1w_preproc.nii.gz (file) [from origin...]\n", + "get(ok): sub-06/ses-test/func/sub-06_ses-test_task-fingerfootlips_bold.nii.gz (file) [from web...]\n", + "get(ok): sub-07/ses-test/func/sub-07_ses-test_task-fingerfootlips_bold.nii.gz (file) [from web...]\n", + "get(ok): sub-03/ses-test/func/sub-03_ses-test_task-fingerfootlips_bold.nii.gz (file) [from origin...]\n", + "get(ok): sub-08/ses-test/func/sub-08_ses-test_task-fingerfootlips_bold.nii.gz (file) [from origin...]\n", + "get(ok): sub-10/ses-test/func/sub-10_ses-test_task-fingerfootlips_bold.nii.gz (file) [from web...]\n", + "get(ok): sub-09/ses-test/func/sub-09_ses-test_task-fingerfootlips_bold.nii.gz (file) [from origin...]\n", + "get(ok): sub-02/ses-test/func/sub-02_ses-test_task-fingerfootlips_bold.nii.gz (file) [from web...]\n", + "get(ok): sub-04/ses-test/func/sub-04_ses-test_task-fingerfootlips_bold.nii.gz (file) [from origin...]\n", + "get(ok): sub-05/ses-test/func/sub-05_ses-test_task-fingerfootlips_bold.nii.gz (file) [from origin...]\n", "action summary:\n", - " get (notneeded: 31)\n" + " get (notneeded: 2, ok: 29)\n" ] } ], @@ -59,8 +109,12 @@ }, { "cell_type": "code", - "execution_count": 16, - "metadata": {}, + "execution_count": 4, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, "outputs": [ { "name": "stdout", @@ -69,15 +123,15 @@ "ses-retest/\n", " dwi/\n", " sub-01_ses-retest_dwi.nii.gz\n", - " anat/\n", - " sub-01_ses-retest_T1w.nii.gz\n", " func/\n", - " sub-01_ses-retest_task-overtverbgeneration_bold.nii.gz\n", + " sub-01_ses-retest_task-linebisection_events.tsv\n", " sub-01_ses-retest_task-covertverbgeneration_bold.nii.gz\n", " sub-01_ses-retest_task-linebisection_bold.nii.gz\n", " sub-01_ses-retest_task-fingerfootlips_bold.nii.gz\n", " sub-01_ses-retest_task-overtwordrepetition_bold.nii.gz\n", - " sub-01_ses-retest_task-linebisection_events.tsv\n" + " sub-01_ses-retest_task-overtverbgeneration_bold.nii.gz\n", + " anat/\n", + " sub-01_ses-retest_T1w.nii.gz\n" ] } ], @@ -88,75 +142,103 @@ "list_files('/data/ds000114/sub-01/ses-retest')" ] }, + { + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, + "source": [ + "With nibabel we can load a file and inspect its properties." + ] + }, { "cell_type": "code", - "execution_count": 17, - "metadata": {}, + "execution_count": 27, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "derivatives/fmriprep/sub-01/anat/sub-01_t1w_preproc.nii.gz float32 [256, 156, 256] 1.00x1.30x1.00 sform\n", - "sub-01/ses-test/func/sub-01_ses-test_task-fingerfootlips_bold.nii.gz int16 [ 64, 64, 30, 184] 4.00x4.00x4.00x2.50 sform\n", - "\n" + "Anatomical dimensionality is 3 and fmri is 4\n", + "Anatomical voxelization: (256, 156, 256)\n", + "fMRI voxelization: (64, 64, 30, 184)\n", + "\n", + "Anatomical volume affine:\n", + "[[ 9.99182463e-01 -5.10393567e-02 9.58159845e-03 -1.27317017e+02]\n", + " [ 3.95217389e-02 1.29798853e+00 -2.68560350e-02 -8.03349991e+01]\n", + " [-8.51583015e-03 3.53622437e-02 9.99593377e-01 -1.38213226e+02]\n", + " [ 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00]]\n", + "fMRI affine:\n", + "[[-3.99471426e+00 -2.04233140e-01 2.29353290e-02 1.30641693e+02]\n", + " [-2.05448717e-01 3.98260689e+00 -3.10890853e-01 -9.74732285e+01]\n", + " [ 6.95819734e-03 3.11659902e-01 3.98780894e+00 -8.06465759e+01]\n", + " [ 0.00000000e+00 0.00000000e+00 0.00000000e+00 1.00000000e+00]]\n" ] } ], "source": [ - "%%bash\n", - "cd /data/ds000114/\n", - "nib-ls derivatives/fmriprep/sub-01/*/*t1w_preproc.nii.gz sub-01/ses-test/f*/*fingerfootlips*.nii.gz" + "import nibabel\n", + "from nilearn import plotting\n", + "import numpy as np\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "anat = nibabel.load('/data/ds000114/derivatives/fmriprep/sub-01/anat/sub-01_t1w_preproc.nii.gz')\n", + "fmri = nibabel.load('/data/ds000114/sub-01/ses-test/func/sub-01_ses-test_task-fingerfootlips_bold.nii.gz')\n", + "\n", + "print(f'Anatomical dimensionality is {anat.ndim} and fmri is {fmri.ndim}')\n", + "#The anatomical image have higher resolution then the fmri\n", + "print(f'Anatomical voxelization: {anat.shape}\\nfMRI voxelization: {fmri.shape}')\n", + "#the data can be accessed as\n", + "print(f'\\nAnatomical volume affine:\\n{anat.affine}\\nfMRI affine:\\n{fmri.affine}')\n", + "data = np.array(anat.dataobj)" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ - "With nibabel we can load a file and inspect its properties." + "Lets stop on SliceTiming key, unlike a photograph, in which the entire picture is taken in a single moment, an fMRI volume is acquired in slices. Each of these slices takes time to acquire - from tens to hundreds of milliseconds." ] }, { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, "source": [ - "import nibabel\n", - "from nilearn import plotting\n", - "import numpy as np\n", - "import warnings\n", - "warnings.filterwarnings('ignore')\n", + "The two most commonly used methods for creating volumes are sequential and interleaved slice acquisition. Sequential slice acquisition acquires each adjacent slice consecutively, either bottom-to-top or top-to-bottom. Interleaved slice acquisition acquires every other slice, and then fills in the gaps on the second pass. Both of these methods are illustrated in the video below.\n", "\n", - "anat = nibabel.load('/data/ds000114/derivatives/fmriprep/sub-01/anat/sub-01_t1w_preproc.nii.gz')\n", - "fmri = nibabel.load('/data/ds000114/sub-01/ses-test/func/sub-01_ses-test_task-fingerfootlips_bold.nii.gz')" + "https://www.brainvoyager.com/bv/doc/UsersGuide/Preprocessing/SliceScanTimeCorrection.html" ] }, { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Anatomical dimensionality is 3 and fmri is 4\n", - "Anatomical voxelization:(256, 156, 256) fMRI voxelization:(64, 64, 30, 184)\n" - ] + "cell_type": "markdown", + "metadata": { + "slideshow": { + "slide_type": "subslide" } - ], + }, "source": [ - "print(f'Anatomical dimensionality is {anat.ndim} and fmri is {fmri.ndim}')\n", - "#The anatomical image have higher resolution then the fmri\n", - "print(f'Anatomical voxelization:{anat.shape} fMRI voxelization:{fmri.shape}')\n", - "#the data can be accessed as\n", - "data = np.array(anat.dataobj)" + "![SliceTiming](https://andysbrainbook.readthedocs.io/en/latest/_images/SliceTimingCorrection_Demo.gif \"slicetiming\")" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 40, "metadata": {}, "outputs": [ { @@ -198,7 +280,7 @@ " 'TaskName': 'finger_foot_lips'}" ] }, - "execution_count": 20, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" } @@ -214,8 +296,12 @@ }, { "cell_type": "code", - "execution_count": 21, - "metadata": {}, + "execution_count": 44, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, "outputs": [ { "data": { @@ -223,7 +309,7 @@ "30" ] }, - "execution_count": 21, + "execution_count": 44, "metadata": {}, "output_type": "execute_result" } @@ -234,14 +320,22 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "# Introduction Nipype" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, "source": [ "**Why nipype?**\n", "\n", @@ -259,18 +353,22 @@ }, { "cell_type": "code", - "execution_count": 22, - "metadata": {}, + "execution_count": 49, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "200920-23:36:10,141 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"a_x_b\" in \"/tmp/tmpr129nt7r/a_x_b\".\n", - "200920-23:36:10,144 nipype.workflow INFO:\n", + "210919-18:16:51,65 nipype.workflow INFO:\n", + "\t [Node] Setting-up \"a_x_b\" in \"/tmp/tmpqiswn1p2/a_x_b\".\n", + "210919-18:16:51,71 nipype.workflow INFO:\n", "\t [Node] Running \"a_x_b\" (\"nipype.interfaces.utility.wrappers.Function\")\n", - "200920-23:36:10,152 nipype.workflow INFO:\n", + "210919-18:16:51,76 nipype.workflow INFO:\n", "\t [Node] Finished \"a_x_b\".\n" ] }, @@ -281,7 +379,7 @@ "multiply_result = 6" ] }, - "execution_count": 22, + "execution_count": 49, "metadata": {}, "output_type": "execute_result" } @@ -309,8 +407,12 @@ }, { "cell_type": "code", - "execution_count": 23, - "metadata": {}, + "execution_count": 50, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, "outputs": [ { "data": { @@ -319,7 +421,7 @@ "" ] }, - "execution_count": 23, + "execution_count": 50, "metadata": {}, "output_type": "execute_result" } @@ -349,8 +451,12 @@ }, { "cell_type": "code", - "execution_count": 24, - "metadata": {}, + "execution_count": 63, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, "outputs": [ { "data": { @@ -361,7 +467,7 @@ " add = 16]" ] }, - "execution_count": 24, + "execution_count": 63, "metadata": {}, "output_type": "execute_result" } @@ -370,7 +476,7 @@ "#run the graph\n", "eg = wf.run()\n", "clear_output()#don't print the pipeline steps during exection\n", - "#chek the results\n", + "#check the results\n", "eg = list(eg.nodes())\n", "nodes_outputs = [node.result.outputs for node in eg]\n", "nodes_outputs" @@ -378,17 +484,32 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, "source": [ "**Dataset:**\n", "[A test-retest fMRI dataset for motor, language and spatial attention functions](https://openneuro.org/datasets/ds000114/versions/1.0.1)\n", "\n", + "**About nipype**\n", + "https://www.frontiersin.org/articles/10.3389/fninf.2011.00013/full\n", + "\n", "**Thanks to Michael Notter for the wonderful [nipype tutorial](https://miykael.github.io/nipype_tutorial/)**" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "anaconda-cloud": {}, + "celltoolbar": "Slideshow", "kernelspec": { "display_name": "Python 3", "language": "python", diff --git a/seminar4/__pycache__/utils.cpython-36.pyc b/seminar4/__pycache__/utils.cpython-36.pyc index 2919844c8672804caf5a8f9dcbdba1aeed6df957..bedac325501c7aa6cee4859a597ebb008ee1806e 100644 GIT binary patch delta 17 YcmbQkGKYo3n3tDJYm;=sMh+1s03-GT#sB~S delta 17 YcmbQkGKYo3n3tE!>u7rXMh+1s04F{KL;wH) diff --git a/seminar4/hello/graph1.json b/seminar4/hello/graph1.json index 5abcd16..e75c640 100644 --- a/seminar4/hello/graph1.json +++ b/seminar4/hello/graph1.json @@ -21,14 +21,14 @@ { "group": 1, "name": "0_a_x_b", - "report": "/tmp/tmpwd77m2ma/a_x_b/_report/report.rst", - "result": "/tmp/tmpwd77m2ma/a_x_b/result_a_x_b.pklz" + "report": "/tmp/tmpqiswn1p2/a_x_b/_report/report.rst", + "result": "/tmp/tmpqiswn1p2/a_x_b/result_a_x_b.pklz" }, { "group": 1, "name": "1_a_plus_b", - "report": "/tmp/tmp84s7w8vu/hello/a_plus_b/_report/report.rst", - "result": "/tmp/tmp84s7w8vu/hello/a_plus_b/result_a_plus_b.pklz" + "report": "/tmp/tmp0fyw6mdm/hello/a_plus_b/_report/report.rst", + "result": "/tmp/tmp0fyw6mdm/hello/a_plus_b/result_a_plus_b.pklz" } ] } \ No newline at end of file diff --git a/seminar4/preprocessing.ipynb b/seminar4/preprocessing.ipynb index 66160dd..f563112 100644 --- a/seminar4/preprocessing.ipynb +++ b/seminar4/preprocessing.ipynb @@ -2,7 +2,11 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "# fMRI data preprocessing" ] @@ -14,434 +18,53 @@ "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/adasegroup/NEUROML2020/blob/seminar4/seminar-4/preprocessing.ipynb)" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "fMRI scans are saved in dicom format. For scientific analysis of brain images the nifty format (.nii files) are often used.\n", - "The conversion from dicom to nifty can be done with [dcm2niix](https://www.nitrc.org/plugins/mwiki/index.php/dcm2nii:MainPage#Introduction) \n", - "\n", - "Many file are generated during fMRI sessions. These can arranged in many ways, thus a standard is needed how to arrange them. \n", - "Commonly used standard is [Brain Imaging Data Structure (BIDS)](https://bids.neuroimaging.io/).\n", - "\n", - "You can use [HeuDiConv](https://heudiconv.readthedocs.io/en/latest/) or [Dcm2Bids](https://cbedetti.github.io/Dcm2Bids/tutorial/) to automate the conversion from dicom to BIDS.\n", - "\n", - "![DICOM TO BIDS](https://www.incf.org/sites/default/files/articles/bids_standard-2.jpg)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's download the data we will be working with." - ] - }, { "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "action summary:\n", - " get (notneeded: 31)\n" - ] - } - ], - "source": [ - "%%bash\n", - "datalad get -J 4 -d /data/ds000114 \\\n", - " /data/ds000114/derivatives/fmriprep/sub-*/anat/*preproc.nii.gz \\\n", - " /data/ds000114/sub-*/ses-test/func/*fingerfootlips*" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ses-retest/\n", - " dwi/\n", - " sub-01_ses-retest_dwi.nii.gz\n", - " anat/\n", - " sub-01_ses-retest_T1w.nii.gz\n", - " func/\n", - " sub-01_ses-retest_task-overtverbgeneration_bold.nii.gz\n", - " sub-01_ses-retest_task-covertverbgeneration_bold.nii.gz\n", - " sub-01_ses-retest_task-linebisection_bold.nii.gz\n", - " sub-01_ses-retest_task-fingerfootlips_bold.nii.gz\n", - " sub-01_ses-retest_task-overtwordrepetition_bold.nii.gz\n", - " sub-01_ses-retest_task-linebisection_events.tsv\n" - ] + "execution_count": 17, + "metadata": { + "slideshow": { + "slide_type": "fragment" } - ], - "source": [ - "from utils import list_files\n", - "# The data is already in BIDS format\n", - "# The subjects peformed 5 tasks. We will focus on fingerfootlips task\n", - "list_files('/data/ds000114/sub-01/ses-retest')" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "derivatives/fmriprep/sub-01/anat/sub-01_t1w_preproc.nii.gz float32 [256, 156, 256] 1.00x1.30x1.00 sform\n", - "sub-01/ses-test/func/sub-01_ses-test_task-fingerfootlips_bold.nii.gz int16 [ 64, 64, 30, 184] 4.00x4.00x4.00x2.50 sform\n", - "\n" + "{'commit_hash': '640080d',\n", + " 'commit_source': 'installation',\n", + " 'default_encoding': 'UTF-8',\n", + " 'ipython_path': '/opt/miniconda-latest/envs/neuro/lib/python3.6/site-packages/IPython',\n", + " 'ipython_version': '7.14.0',\n", + " 'os_name': 'posix',\n", + " 'platform': 'Linux-4.19.76-linuxkit-x86_64-with-debian-9.12',\n", + " 'sys_executable': '/opt/miniconda-latest/envs/neuro/bin/python',\n", + " 'sys_platform': 'linux',\n", + " 'sys_version': '3.6.10 | packaged by conda-forge | (default, Apr 24 2020, '\n", + " '16:44:11) \\n'\n", + " '[GCC 7.3.0]'}\n" ] } ], - "source": [ - "%%bash\n", - "cd /data/ds000114/\n", - "nib-ls derivatives/fmriprep/sub-01/*/*t1w_preproc.nii.gz sub-01/ses-test/f*/*fingerfootlips*.nii.gz" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "With nibabel we can load a file and inspect its properties." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], "source": [ "import nibabel\n", "from nilearn import plotting\n", + "import matplotlib\n", "import numpy as np\n", "import warnings\n", - "warnings.filterwarnings('ignore')\n", + "\n", "\n", "anat = nibabel.load('/data/ds000114/derivatives/fmriprep/sub-01/anat/sub-01_t1w_preproc.nii.gz')\n", "fmri = nibabel.load('/data/ds000114/sub-01/ses-test/func/sub-01_ses-test_task-fingerfootlips_bold.nii.gz')" ] }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " object, endian='<'\n", - "sizeof_hdr : 348\n", - "data_type : b''\n", - "db_name : b''\n", - "extents : 0\n", - "session_error : 0\n", - "regular : b'r'\n", - "dim_info : 0\n", - "dim : [ 3 256 156 256 1 1 1 1]\n", - "intent_p1 : 0.0\n", - "intent_p2 : 0.0\n", - "intent_p3 : 0.0\n", - "intent_code : none\n", - "datatype : float32\n", - "bitpix : 32\n", - "slice_start : 0\n", - "pixdim : [1. 1. 1.2994729 1. 0. 0. 0.\n", - " 0. ]\n", - "vox_offset : 0.0\n", - "scl_slope : nan\n", - "scl_inter : nan\n", - "slice_end : 0\n", - "slice_code : unknown\n", - "xyzt_units : 2\n", - "cal_max : 0.0\n", - "cal_min : 0.0\n", - "slice_duration : 0.0\n", - "toffset : 0.0\n", - "glmax : 0\n", - "glmin : 0\n", - "descrip : b''\n", - "aux_file : b''\n", - "qform_code : aligned\n", - "sform_code : scanner\n", - "quatern_b : 0.013521198\n", - "quatern_c : 0.004525696\n", - "quatern_d : 0.019705506\n", - "qoffset_x : -127.31702\n", - "qoffset_y : -80.335\n", - "qoffset_z : -138.21323\n", - "srow_x : [ 9.9918246e-01 -5.1039357e-02 9.5815985e-03 -1.2731702e+02]\n", - "srow_y : [ 3.9521739e-02 1.2979885e+00 -2.6856035e-02 -8.0334999e+01]\n", - "srow_z : [-8.5158302e-03 3.5362244e-02 9.9959338e-01 -1.3821323e+02]\n", - "intent_name : b''\n", - "magic : b'n+1'\n" - ] - } - ], - "source": [ - "print(anat.header)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Anatomical dimensionality is 3 and fmri is 4\n", - "Anatomical voxelization:(256, 156, 256) fMRI voxelization:(64, 64, 30, 184)\n" - ] - } - ], - "source": [ - "print(f'Anatomical dimensionality is {anat.ndim} and fmri is {fmri.ndim}')\n", - "#The anatomical image have higher resolution then the fmri\n", - "print(f'Anatomical voxelization:{anat.shape} fMRI voxelization:{fmri.shape}')\n", - "#the data can be accessed as\n", - "data = np.array(anat.dataobj)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'EchoTime': 0.05,\n", - " 'FlipAngle': 90,\n", - " 'RepetitionTime': 2.5,\n", - " 'SliceTiming': [0.0,\n", - " 1.2499999999999998,\n", - " 0.08333333333333333,\n", - " 1.333333333333333,\n", - " 0.16666666666666666,\n", - " 1.4166666666666663,\n", - " 0.25,\n", - " 1.4999999999999996,\n", - " 0.3333333333333333,\n", - " 1.5833333333333328,\n", - " 0.41666666666666663,\n", - " 1.666666666666666,\n", - " 0.5,\n", - " 1.7499999999999993,\n", - " 0.5833333333333333,\n", - " 1.8333333333333326,\n", - " 0.6666666666666666,\n", - " 1.9166666666666659,\n", - " 0.75,\n", - " 1.9999999999999991,\n", - " 0.8333333333333333,\n", - " 2.083333333333332,\n", - " 0.9166666666666666,\n", - " 2.1666666666666656,\n", - " 1.0,\n", - " 2.249999999999999,\n", - " 1.0833333333333333,\n", - " 2.333333333333332,\n", - " 1.1666666666666665,\n", - " 2.416666666666665],\n", - " 'TaskName': 'finger_foot_lips'}" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import json\n", - "\n", - "#metadata is located in json files\n", - "with open('/data/ds000114/task-fingerfootlips_bold.json', 'rt') as fp:\n", - " task_info = json.load(fp)\n", - "task_info" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "30" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(task_info['SliceTiming'])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Introduction Nipype" - ] - }, { "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Why nipype?**\n", - "\n", - "Nipype allows to build preprocessing pipelines from different softwares, and it is computationally efficient. There are some helpful ready to use pipleines written with Nipype like [fmriprep](https://fmriprep.org/en/stable/index.html). To use fmriprep the data have to be in valid BIDS format. The user have to supply only the path to the data setup the [parametars](https://fmriprep.org/en/stable/usage.html#command-line-arguments). \n", - "\n", - "In Nipype, interfaces are python modules that allow you to use various external packages (e.g. FSL, SPM or FreeSurfer), even if they themselves are written in another programming language than python. Such an interface knows what sort of options an external program has and how to execute it.\n", - "\n", - "![Nipype architecture](https://raw.github.com/satra/intro2nipype/master/images/arch.png)\n", - "\n", - "In Nipype, a node is an object that executes a certain function. This function can be anything from a Nipype interface to a user-specified function or an external script. Each node consists of a name, an interface category and at least one input field, and at least one output field.\n", - "\n", - "\n", - "Once you connect multiple nodes to each other, you create a directed graph. In Nipype we call such graphs either workflows or pipelines. Directed connections can only be established from an output field of a node to an input field of another node." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "200921-08:13:41,623 nipype.utils WARNING:\n", - "\t A newer version (1.5.1) of nipy/nipype is available. You are using 1.5.0-rc1.post-dev\n", - "200921-08:13:41,629 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"a_x_b\" in \"/tmp/tmpwd77m2ma/a_x_b\".\n", - "200921-08:13:41,632 nipype.workflow INFO:\n", - "\t [Node] Running \"a_x_b\" (\"nipype.interfaces.utility.wrappers.Function\")\n", - "200921-08:13:41,638 nipype.workflow INFO:\n", - "\t [Node] Finished \"a_x_b\".\n" - ] - }, - { - "data": { - "text/plain": [ - "\n", - "multiply_result = 6" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from nipype import Node, Function, Workflow\n", - "from IPython.display import Image, clear_output\n", - "\n", - "\n", - "def multiply(a, b):\n", - " return a * b\n", - "\n", - "#Create a Node that multiplies 2 numbers\n", - "mul = Node(Function(input_names=['a', 'b'],\n", - " output_names=['multiply_result'],\n", - " function=multiply), \n", - " name='a_x_b')\n", - "\n", - "mul.inputs.a = 2\n", - "mul.inputs.b = 3\n", - "\n", - "result = mul.run()\n", - "result.outputs" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "#Create a Node that adds 2 numbers\n", - "def add(a, b):\n", - " return a + b\n", - "\n", - "\n", - "\n", - "adder = Node(Function(input_names=['a', 'b'],\n", - " output_names=['add'],\n", - " function=add), \n", - " name='a_plus_b')\n", - "adder.inputs.b = 10\n", - "\n", - "#Create a workflow \n", - "wf = Workflow('hello')\n", - "# connect the nodes \n", - "wf.connect(mul, 'multiply_result', adder, 'a')\n", - "#visualize the graph\n", - "wf.write_graph(graph2use='flat', format='png', simple_form=True)\n", - "clear_output()\n", - "Image(filename='graph_detailed.png')" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[\n", - " multiply_result = 6,\n", - " \n", - " add = 16]" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "slideshow": { + "slide_type": "subslide" } - ], - "source": [ - "#run the graph\n", - "eg = wf.run()\n", - "clear_output()#don't print the pipeline steps during exection\n", - "#chek the results\n", - "eg = list(eg.nodes())\n", - "nodes_outputs = [node.result.outputs for node in eg]\n", - "nodes_outputs" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, + }, "source": [ "# Preprocessing\n", "\n", @@ -453,7 +76,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, "source": [ "Co-registrationis the process of spatial alignment of 2 images. The target image is also called reference volume. The goodness of alignment is evaluated with a cost function.\n", "\n", @@ -462,54 +89,88 @@ }, { "cell_type": "code", - "execution_count": 11, - "metadata": {}, + "execution_count": 36, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, "outputs": [ { "data": { - "image/png": "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\n", + "text/html": [ + "" + ], "text/plain": [ - "
" + "" ] }, + "execution_count": 36, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "_ = plotting.plot_anat(nibabel.nifti1.Nifti1Image(fmri.get_data()[:,:,:,1], affine=fmri.affine), cut_coords=(0,0,0), title='fmri slice')" + "plotting.view_img(nibabel.nifti1.Nifti1Image(fmri.get_data()[:,:,:,1], affine=fmri.affine), bg_img=anat, threshold=0.1e3, cut_coords=(0,0,0), title='Anat and fmri misalignment')" ] }, { "cell_type": "markdown", - "metadata": {}, - "source": [ - " to native anatomical space:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "metadata": { + "slideshow": { + "slide_type": "fragment" } - ], + }, "source": [ - "_ = plotting.plot_anat(anat, cut_coords=(0,0,0), title='Anatomical image')" + " To native anatomical space:" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "**2. Motion correction of functional images with FSL's MCFLIRT**\n", "\n", @@ -521,19 +182,27 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, "source": [ " **3. Slice Timing correction**\n", " \n", " The brain slices are not acquired at the same time. Therefore, interpolation is done between the nearest timepoints\n", - "![Slice Order](https://www.mccauslandcenter.sc.edu/crnl/sites/sc.edu.crnl/files/slice_order_1.jpg)\n", + "![Slice Order](https://crnl.readthedocs.io/_images/slice_order_1.jpg)\n", "\n", "[Slice timing corretion in python](https://matthew-brett.github.io/teaching/slice_timing.html)" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, "source": [ "**4. Smoothing of coregistered functional images with FWHM set to 5/10 mm**\n", "\n", @@ -542,14 +211,22 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, "source": [ "**So, let's start!**" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, "source": [ "## Imports\n", "\n", @@ -558,8 +235,12 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, + "execution_count": 35, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, "outputs": [], "source": [ "from nilearn import plotting\n", @@ -578,7 +259,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "## Experiment parameters\n", "\n", @@ -587,8 +272,12 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, + "execution_count": 54, + "metadata": { + "slideshow": { + "slide_type": "fragment" + } + }, "outputs": [], "source": [ "experiment_dir = '/output'\n", @@ -596,8 +285,9 @@ "working_dir = 'workingdir'\n", "\n", "# list of subject identifiers\n", - "subject_list = ['01', '02', '03', '04', '05', '06', '07', '08', '09', '10']\n", + "#subject_list = ['01', '02', '03', '04', '05', '06', '07', '08', '09', '10']\n", "\n", + "subject_list = ['01', '02']\n", "# list of session identifiers\n", "task_list = ['fingerfootlips']\n", "\n", @@ -616,7 +306,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "## Specify Nodes for the main workflow\n", "\n", @@ -625,8 +319,12 @@ }, { "cell_type": "code", - "execution_count": 15, - "metadata": {}, + "execution_count": 55, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, "outputs": [], "source": [ "# ExtractROI - skip dummy scans\n", @@ -682,7 +380,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "## Coregistration Workflow\n", "\n", @@ -691,8 +393,12 @@ }, { "cell_type": "code", - "execution_count": 16, - "metadata": {}, + "execution_count": 56, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, "outputs": [], "source": [ "# BET - Skullstrip anatomical Image\n", @@ -767,7 +473,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "## Specify input & output stream\n", "\n", @@ -776,8 +486,12 @@ }, { "cell_type": "code", - "execution_count": 17, - "metadata": {}, + "execution_count": 57, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, "outputs": [], "source": [ "# Infosource - a function free node to iterate over the list of subject names\n", @@ -820,7 +534,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "## Specify Workflow\n", "\n", @@ -829,8 +547,12 @@ }, { "cell_type": "code", - "execution_count": 18, - "metadata": {}, + "execution_count": 58, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, "outputs": [], "source": [ "# Create a preprocessing workflow\n", @@ -869,7 +591,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "## Visualize the workflow\n", "\n", @@ -878,14 +604,18 @@ }, { "cell_type": "code", - "execution_count": 19, - "metadata": {}, + "execution_count": 59, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "200921-08:13:47,400 nipype.workflow INFO:\n", + "210919-19:11:16,484 nipype.workflow INFO:\n", "\t Generated workflow graph: /output/workingdir/preproc/graph.png (graph2use=colored, simple_form=True).\n" ] }, @@ -896,7 +626,7 @@ "" ] }, - "execution_count": 19, + "execution_count": 59, "metadata": {}, "output_type": "execute_result" } @@ -912,14 +642,18 @@ }, { "cell_type": "code", - "execution_count": 20, - "metadata": {}, + "execution_count": 60, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "200921-08:13:47,944 nipype.workflow INFO:\n", + "210919-19:11:17,295 nipype.workflow INFO:\n", "\t Generated workflow graph: /output/workingdir/preproc/graph.png (graph2use=flat, simple_form=True).\n" ] }, @@ -930,7 +664,7 @@ "" ] }, - "execution_count": 20, + "execution_count": 60, "metadata": {}, "output_type": "execute_result" } @@ -943,7 +677,11 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + } + }, "source": [ "## Run the Workflow\n", "\n", @@ -952,7 +690,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 62, "metadata": { "scrolled": true }, @@ -961,928 +699,43 @@ "name": "stdout", "output_type": "stream", "text": [ - "200921-08:13:48,38 nipype.workflow INFO:\n", + "210919-19:11:30,865 nipype.workflow INFO:\n", "\t Workflow preproc settings: ['check', 'execution', 'logging', 'monitoring']\n", - "200921-08:13:48,141 nipype.workflow INFO:\n", + "210919-19:11:30,921 nipype.workflow INFO:\n", "\t Running in parallel.\n", - "200921-08:13:48,149 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 10 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:13:48,226 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_10_task_name_fingerfootlips/selectfiles\".200921-08:13:48,227 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_09_task_name_fingerfootlips/selectfiles\".\n", - "200921-08:13:48,228 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_08_task_name_fingerfootlips/selectfiles\".\n", - "\n", - "200921-08:13:48,236 nipype.workflow INFO:\n", - "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", - "200921-08:13:48,238 nipype.workflow INFO:\n", - "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", - "200921-08:13:48,239 nipype.workflow INFO:\n", - "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")200921-08:13:48,241 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.selectfiles\".\n", - "\n", - "200921-08:13:48,243 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.selectfiles\".\n", - "200921-08:13:48,246 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.selectfiles\".\n", - "200921-08:13:48,229 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_07_task_name_fingerfootlips/selectfiles\".\n", - "200921-08:13:48,260 nipype.workflow INFO:\n", - "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", - "200921-08:13:48,267 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.selectfiles\".\n", - "200921-08:13:50,151 nipype.workflow INFO:\n", - "\t [Job 0] Completed (preproc.selectfiles).\n", - "200921-08:13:50,156 nipype.workflow INFO:\n", - "\t [Job 16] Completed (preproc.selectfiles).\n", - "200921-08:13:50,159 nipype.workflow INFO:\n", - "\t [Job 32] Completed (preproc.selectfiles).\n", - "200921-08:13:50,161 nipype.workflow INFO:\n", - "\t [Job 48] Completed (preproc.selectfiles).\n", - "200921-08:13:50,165 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 14 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:13:50,235 nipype.workflow INFO:\n", - "\t [Job 1] Cached (preproc.coregwf.bet_anat).\n", - "200921-08:13:50,239 nipype.workflow INFO:\n", - "\t [Job 4] Cached (preproc.extract).\n", - "200921-08:13:50,242 nipype.workflow INFO:\n", - "\t [Job 17] Cached (preproc.coregwf.bet_anat).\n", - "200921-08:13:50,245 nipype.workflow INFO:\n", - "\t [Job 20] Cached (preproc.extract).\n", - "200921-08:13:52,226 nipype.workflow INFO:\n", - "\t [Job 2] Cached (preproc.coregwf.segmentation).\n", - "200921-08:13:52,230 nipype.workflow INFO:\n", - "\t [Job 5] Cached (preproc.mcflirt).\n", - "200921-08:13:52,234 nipype.workflow INFO:\n", - "\t [Job 18] Cached (preproc.coregwf.segmentation).\n", - "200921-08:13:52,237 nipype.workflow INFO:\n", - "\t [Job 21] Cached (preproc.mcflirt).\n", - "200921-08:13:54,157 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 16 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:13:54,232 nipype.workflow INFO:\n", - "\t [Job 3] Cached (preproc.coregwf.threshold).\n", - "200921-08:13:54,237 nipype.workflow INFO:\n", - "\t [Job 6] Cached (preproc.coregwf.coreg_pre).\n", - "200921-08:13:54,240 nipype.workflow INFO:\n", - "\t [Job 9] Cached (preproc.slicetimer).\n", - "200921-08:13:54,244 nipype.workflow INFO:\n", - "\t [Job 19] Cached (preproc.coregwf.threshold).\n", - "200921-08:13:56,158 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 13 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:13:56,223 nipype.workflow INFO:\n", - "\t [Job 7] Cached (preproc.coregwf.coreg_bbr).\n", - "200921-08:13:56,227 nipype.workflow INFO:\n", - "\t [Job 22] Cached (preproc.coregwf.coreg_pre).\n", - "200921-08:13:56,230 nipype.workflow INFO:\n", - "\t [Job 25] Cached (preproc.slicetimer).\n", - "200921-08:13:56,232 nipype.workflow INFO:\n", - "\t [Job 33] Cached (preproc.coregwf.bet_anat).\n", - "200921-08:13:58,232 nipype.workflow INFO:\n", - "\t [Job 8] Cached (preproc.coregwf.applywarp_mean).\n", - "200921-08:13:58,236 nipype.workflow INFO:\n", - "\t [Job 10] Cached (preproc.coregwf.applywarp).\n", - "200921-08:13:58,241 nipype.workflow INFO:\n", - "\t [Job 23] Cached (preproc.coregwf.coreg_bbr).\n", - "200921-08:13:58,245 nipype.workflow INFO:\n", - "\t [Job 34] Cached (preproc.coregwf.segmentation).\n", - "200921-08:14:00,163 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 15 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:00,235 nipype.workflow INFO:\n", - "\t [Job 11] Cached (preproc.smooth).\n", - "200921-08:14:00,239 nipype.workflow INFO:\n", - "\t [Job 12] Cached (preproc.smooth).\n", - "200921-08:14:00,244 nipype.workflow INFO:\n", - "\t [Job 13] Cached (preproc.art).\n", - "200921-08:14:00,248 nipype.workflow INFO:\n", - "\t [Job 24] Cached (preproc.coregwf.applywarp_mean).\n", - "200921-08:14:02,165 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 13 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:02,245 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_10_task_name_fingerfootlips/_fwhm_10/datasink\".\n", - "200921-08:14:02,253 nipype.workflow INFO:\n", - "\t [Job 26] Cached (preproc.coregwf.applywarp).\n", - "200921-08:14:02,253 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_10_task_name_fingerfootlips/_fwhm_5/datasink\".\n", - "200921-08:14:02,257 nipype.workflow INFO:\n", - "\t [Job 35] Cached (preproc.coregwf.threshold).\n", - "200921-08:14:02,256 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", - "200921-08:14:02,259 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-10/task-fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold.par\n", - "200921-08:14:02,261 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/art.sub-10_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-10/task-fingerfootlips/art.sub-10_ses-test_task-fingerfootlips_bold_outliers.txt200921-08:14:02,261 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", - "\n", - "200921-08:14:02,262 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/plot.sub-10_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-10/task-fingerfootlips/plot.sub-10_ses-test_task-fingerfootlips_bold.svg\n", - "200921-08:14:02,263 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-10/task-fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold.par\n", - "200921-08:14:02,264 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/sub-10_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-10/task-fingerfootlips/sub-10_t1w_preproc_brain.nii.gz\n", - "200921-08:14:02,265 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/art.sub-10_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-10/task-fingerfootlips/art.sub-10_ses-test_task-fingerfootlips_bold_outliers.txt200921-08:14:02,266 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-10/task-fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_mean.mat\n", - "\n", - "200921-08:14:02,268 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/plot.sub-10_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-10/task-fingerfootlips/plot.sub-10_ses-test_task-fingerfootlips_bold.svg200921-08:14:02,268 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-10/task-fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", - "\n", - "200921-08:14:02,270 nipype.interface INFO:\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/_fwhm_10/ssub-10_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-10/task-fingerfootlips/fwhm-10_ssub-10_ses-test_task-fingerfootlips_bold.nii200921-08:14:02,270 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/sub-10_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-10/task-fingerfootlips/sub-10_t1w_preproc_brain.nii.gz\n", - "\n", - "200921-08:14:02,274 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".200921-08:14:02,275 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-10/task-fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_mean.mat\n", - "\n", - "200921-08:14:02,277 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-10/task-fingerfootlips/sub-10_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", - "200921-08:14:02,280 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_10_task_name_fingerfootlips/_fwhm_5/ssub-10_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-10/task-fingerfootlips/fwhm-5_ssub-10_ses-test_task-fingerfootlips_bold.nii\n", - "200921-08:14:02,284 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".\n", - "200921-08:14:04,165 nipype.workflow INFO:\n", - "\t [Job 14] Completed (preproc.datasink).\n", - "200921-08:14:04,169 nipype.workflow INFO:\n", - "\t [Job 15] Completed (preproc.datasink).\n", - "200921-08:14:04,175 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 12 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:04,244 nipype.workflow INFO:\n", - "\t [Job 27] Cached (preproc.smooth).\n", - "200921-08:14:04,248 nipype.workflow INFO:\n", - "\t [Job 28] Cached (preproc.smooth).\n", - "200921-08:14:04,252 nipype.workflow INFO:\n", - "\t [Job 29] Cached (preproc.art).\n", - "200921-08:14:04,255 nipype.workflow INFO:\n", - "\t [Job 36] Cached (preproc.extract).\n", - "200921-08:14:06,170 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 11 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:06,250 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_09_task_name_fingerfootlips/_fwhm_10/datasink\".\n", - "200921-08:14:06,258 nipype.workflow INFO:\n", - "\t [Job 37] Cached (preproc.mcflirt).\n", - "200921-08:14:06,259 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_09_task_name_fingerfootlips/_fwhm_5/datasink\".200921-08:14:06,260 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200921-08:14:06,261 nipype.workflow INFO:\n", - "\t [Job 49] Cached (preproc.coregwf.bet_anat).\n", - "\n", - "\n", - "200921-08:14:06,262 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-09/task-fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold.par\n", - "200921-08:14:06,264 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/art.sub-09_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-09/task-fingerfootlips/art.sub-09_ses-test_task-fingerfootlips_bold_outliers.txt\n", - "200921-08:14:06,265 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/plot.sub-09_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-09/task-fingerfootlips/plot.sub-09_ses-test_task-fingerfootlips_bold.svg\n", - "200921-08:14:06,267 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/sub-09_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-09/task-fingerfootlips/sub-09_t1w_preproc_brain.nii.gz\n", - "200921-08:14:06,268 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-09/task-fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_mean.mat\n", - "200921-08:14:06,270 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200921-08:14:06,270 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-09/task-fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", - "\n", - "200921-08:14:06,272 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/_fwhm_10/ssub-09_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-09/task-fingerfootlips/fwhm-10_ssub-09_ses-test_task-fingerfootlips_bold.nii\n", - "200921-08:14:06,273 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-09/task-fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold.par\n", - "200921-08:14:06,275 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".\n", - "200921-08:14:06,276 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/art.sub-09_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-09/task-fingerfootlips/art.sub-09_ses-test_task-fingerfootlips_bold_outliers.txt\n", - "200921-08:14:06,279 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/plot.sub-09_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-09/task-fingerfootlips/plot.sub-09_ses-test_task-fingerfootlips_bold.svg\n", - "200921-08:14:06,281 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/sub-09_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-09/task-fingerfootlips/sub-09_t1w_preproc_brain.nii.gz\n", - "200921-08:14:06,283 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-09/task-fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_mean.mat\n", - "200921-08:14:06,284 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-09/task-fingerfootlips/sub-09_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", - "200921-08:14:06,286 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_09_task_name_fingerfootlips/_fwhm_5/ssub-09_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-09/task-fingerfootlips/fwhm-5_ssub-09_ses-test_task-fingerfootlips_bold.nii\n", - "200921-08:14:06,290 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".\n", - "200921-08:14:08,168 nipype.workflow INFO:\n", - "\t [Job 30] Completed (preproc.datasink).\n", - "200921-08:14:08,171 nipype.workflow INFO:\n", - "\t [Job 31] Completed (preproc.datasink).\n", - "200921-08:14:08,177 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 10 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:08,247 nipype.workflow INFO:\n", - "\t [Job 38] Cached (preproc.coregwf.coreg_pre).\n", - "200921-08:14:08,251 nipype.workflow INFO:\n", - "\t [Job 41] Cached (preproc.slicetimer).\n", - "200921-08:14:08,254 nipype.workflow INFO:\n", - "\t [Job 50] Cached (preproc.coregwf.segmentation).\n", - "200921-08:14:08,257 nipype.workflow INFO:\n", - "\t [Job 52] Cached (preproc.extract).\n", - "200921-08:14:10,172 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 9 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:10,244 nipype.workflow INFO:\n", - "\t [Job 39] Cached (preproc.coregwf.coreg_bbr).\n", - "200921-08:14:10,248 nipype.workflow INFO:\n", - "\t [Job 51] Cached (preproc.coregwf.threshold).\n", - "200921-08:14:10,251 nipype.workflow INFO:\n", - "\t [Job 53] Cached (preproc.mcflirt).\n", - "200921-08:14:10,255 nipype.workflow INFO:\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_06_task_name_fingerfootlips/selectfiles\".\n", - "200921-08:14:10,259 nipype.workflow INFO:\n", - "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", - "200921-08:14:10,264 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.selectfiles\".\n", - "200921-08:14:12,172 nipype.workflow INFO:\n", - "\t [Job 64] Completed (preproc.selectfiles).\n", - "200921-08:14:12,178 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 11 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:12,255 nipype.workflow INFO:\n", - "\t [Job 40] Cached (preproc.coregwf.applywarp_mean).\n", - "200921-08:14:12,259 nipype.workflow INFO:\n", - "\t [Job 42] Cached (preproc.coregwf.applywarp).\n", - "200921-08:14:12,263 nipype.workflow INFO:\n", - "\t [Job 54] Cached (preproc.coregwf.coreg_pre).\n", - "200921-08:14:12,266 nipype.workflow INFO:\n", - "\t [Job 57] Cached (preproc.slicetimer).\n", - "200921-08:14:14,245 nipype.workflow INFO:\n", - "\t [Job 43] Cached (preproc.smooth).\n", - "200921-08:14:14,249 nipype.workflow INFO:\n", - "\t [Job 44] Cached (preproc.smooth).\n", - "200921-08:14:14,252 nipype.workflow INFO:\n", - "\t [Job 45] Cached (preproc.art).\n", - "200921-08:14:14,257 nipype.workflow INFO:\n", - "\t [Job 55] Cached (preproc.coregwf.coreg_bbr).\n", - "200921-08:14:16,246 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_08_task_name_fingerfootlips/_fwhm_10/datasink\".\n", - "200921-08:14:16,253 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_08_task_name_fingerfootlips/_fwhm_5/datasink\".200921-08:14:16,254 nipype.workflow INFO:\n", - "\t [Job 56] Cached (preproc.coregwf.applywarp_mean).\n", - "200921-08:14:16,254 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", - "\n", - "200921-08:14:16,258 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-08/task-fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold.par\n", - "200921-08:14:16,260 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200921-08:14:16,261 nipype.workflow INFO:\n", - "\t [Job 58] Cached (preproc.coregwf.applywarp).\n", - "\n", - "200921-08:14:16,261 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/art.sub-08_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-08/task-fingerfootlips/art.sub-08_ses-test_task-fingerfootlips_bold_outliers.txt\n", - "200921-08:14:16,264 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/plot.sub-08_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-08/task-fingerfootlips/plot.sub-08_ses-test_task-fingerfootlips_bold.svg200921-08:14:16,264 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-08/task-fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold.par\n", - "\n", - "200921-08:14:16,266 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/sub-08_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-08/task-fingerfootlips/sub-08_t1w_preproc_brain.nii.gz200921-08:14:16,266 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/art.sub-08_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-08/task-fingerfootlips/art.sub-08_ses-test_task-fingerfootlips_bold_outliers.txt\n", - "\n", - "200921-08:14:16,268 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-08/task-fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_mean.mat\n", - "200921-08:14:16,268 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/plot.sub-08_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-08/task-fingerfootlips/plot.sub-08_ses-test_task-fingerfootlips_bold.svg200921-08:14:16,270 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-08/task-fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", - "\n", - "200921-08:14:16,271 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/sub-08_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-08/task-fingerfootlips/sub-08_t1w_preproc_brain.nii.gz\n", - "200921-08:14:16,272 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/_fwhm_10/ssub-08_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-08/task-fingerfootlips/fwhm-10_ssub-08_ses-test_task-fingerfootlips_bold.nii\n", - "200921-08:14:16,274 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-08/task-fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_mean.mat\n", - "200921-08:14:16,275 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-08/task-fingerfootlips/sub-08_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", - "200921-08:14:16,277 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".200921-08:14:16,277 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_08_task_name_fingerfootlips/_fwhm_5/ssub-08_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-08/task-fingerfootlips/fwhm-5_ssub-08_ses-test_task-fingerfootlips_bold.nii\n", - "\n", - "200921-08:14:16,282 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".\n", - "200921-08:14:18,178 nipype.workflow INFO:\n", - "\t [Job 46] Completed (preproc.datasink).\n", - "200921-08:14:18,181 nipype.workflow INFO:\n", - "\t [Job 47] Completed (preproc.datasink).\n", - "200921-08:14:18,188 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 10 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:18,258 nipype.workflow INFO:\n", - "\t [Job 59] Cached (preproc.smooth).\n", - "200921-08:14:18,262 nipype.workflow INFO:\n", - "\t [Job 60] Cached (preproc.smooth).\n", - "200921-08:14:18,266 nipype.workflow INFO:\n", - "\t [Job 61] Cached (preproc.art).\n", - "200921-08:14:18,270 nipype.workflow INFO:\n", - "\t [Job 65] Cached (preproc.coregwf.bet_anat).\n", - "200921-08:14:20,182 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 9 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:20,260 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_07_task_name_fingerfootlips/_fwhm_10/datasink\".\n", - "200921-08:14:20,268 nipype.workflow INFO:\n", - "\t [Job 66] Cached (preproc.coregwf.segmentation).\n", - "200921-08:14:20,269 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_07_task_name_fingerfootlips/_fwhm_5/datasink\".200921-08:14:20,272 nipype.workflow INFO:\n", - "\t [Job 68] Cached (preproc.extract).\n", - "\n", - "200921-08:14:20,273 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", - "200921-08:14:20,276 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-07/task-fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold.par\n", - "200921-08:14:20,278 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/art.sub-07_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-07/task-fingerfootlips/art.sub-07_ses-test_task-fingerfootlips_bold_outliers.txt\n", - "200921-08:14:20,280 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200921-08:14:20,281 nipype.interface INFO:\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/plot.sub-07_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-07/task-fingerfootlips/plot.sub-07_ses-test_task-fingerfootlips_bold.svg\n", - "\n", - "200921-08:14:20,283 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-07/task-fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold.par\n", - "200921-08:14:20,283 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/sub-07_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-07/task-fingerfootlips/sub-07_t1w_preproc_brain.nii.gz200921-08:14:20,284 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/art.sub-07_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-07/task-fingerfootlips/art.sub-07_ses-test_task-fingerfootlips_bold_outliers.txt\n", - "\n", - "200921-08:14:20,286 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/plot.sub-07_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-07/task-fingerfootlips/plot.sub-07_ses-test_task-fingerfootlips_bold.svg200921-08:14:20,286 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-07/task-fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_mean.mat\n", - "\n", - "200921-08:14:20,288 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/sub-07_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-07/task-fingerfootlips/sub-07_t1w_preproc_brain.nii.gz\n", - "200921-08:14:20,290 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-07/task-fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_mean.mat\n", - "200921-08:14:20,291 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-07/task-fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_mean.nii.gz200921-08:14:20,289 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-07/task-fingerfootlips/sub-07_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", - "\n", - "200921-08:14:20,293 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/_fwhm_10/ssub-07_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-07/task-fingerfootlips/fwhm-10_ssub-07_ses-test_task-fingerfootlips_bold.nii200921-08:14:20,294 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_07_task_name_fingerfootlips/_fwhm_5/ssub-07_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-07/task-fingerfootlips/fwhm-5_ssub-07_ses-test_task-fingerfootlips_bold.nii\n", - "\n", - "200921-08:14:20,298 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".200921-08:14:20,298 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".\n", - "\n", - "200921-08:14:22,182 nipype.workflow INFO:\n", - "\t [Job 62] Completed (preproc.datasink).\n", - "200921-08:14:22,185 nipype.workflow INFO:\n", - "\t [Job 63] Completed (preproc.datasink).\n", - "200921-08:14:22,190 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 7 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:22,260 nipype.workflow INFO:\n", - "\t [Job 67] Cached (preproc.coregwf.threshold).\n", - "200921-08:14:22,264 nipype.workflow INFO:\n", - "\t [Job 69] Cached (preproc.mcflirt).\n", - "200921-08:14:22,268 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_05_task_name_fingerfootlips/selectfiles\".200921-08:14:22,270 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_04_task_name_fingerfootlips/selectfiles\".\n", - "\n", - "200921-08:14:22,275 nipype.workflow INFO:\n", - "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")200921-08:14:22,277 nipype.workflow INFO:\n", - "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", - "\n", - "200921-08:14:22,282 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.selectfiles\".\n", - "200921-08:14:22,284 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.selectfiles\".\n", - "200921-08:14:24,184 nipype.workflow INFO:\n", - "\t [Job 80] Completed (preproc.selectfiles).\n", - "200921-08:14:24,187 nipype.workflow INFO:\n", - "\t [Job 96] Completed (preproc.selectfiles).\n", - "200921-08:14:24,192 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 9 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:24,262 nipype.workflow INFO:\n", - "\t [Job 70] Cached (preproc.coregwf.coreg_pre).\n", - "200921-08:14:24,265 nipype.workflow INFO:\n", - "\t [Job 73] Cached (preproc.slicetimer).\n", - "200921-08:14:24,268 nipype.workflow INFO:\n", - "\t [Job 81] Cached (preproc.coregwf.bet_anat).\n", - "200921-08:14:24,271 nipype.workflow INFO:\n", - "\t [Job 84] Cached (preproc.extract).\n", - "200921-08:14:26,186 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 8 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:26,256 nipype.workflow INFO:\n", - "\t [Job 71] Cached (preproc.coregwf.coreg_bbr).\n", - "200921-08:14:26,260 nipype.workflow INFO:\n", - "\t [Job 82] Cached (preproc.coregwf.segmentation).\n", - "200921-08:14:26,262 nipype.workflow INFO:\n", - "\t [Job 85] Cached (preproc.mcflirt).\n", - "200921-08:14:26,264 nipype.workflow INFO:\n", - "\t [Job 97] Cached (preproc.coregwf.bet_anat).\n", - "200921-08:14:28,190 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 10 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:28,265 nipype.workflow INFO:\n", - "\t [Job 72] Cached (preproc.coregwf.applywarp_mean).\n", - "200921-08:14:28,269 nipype.workflow INFO:\n", - "\t [Job 74] Cached (preproc.coregwf.applywarp).\n", - "200921-08:14:28,273 nipype.workflow INFO:\n", - "\t [Job 83] Cached (preproc.coregwf.threshold).\n", - "200921-08:14:28,276 nipype.workflow INFO:\n", - "\t [Job 86] Cached (preproc.coregwf.coreg_pre).\n", - "200921-08:14:30,262 nipype.workflow INFO:\n", - "\t [Job 75] Cached (preproc.smooth).\n", - "200921-08:14:30,265 nipype.workflow INFO:\n", - "\t [Job 76] Cached (preproc.smooth).\n", - "200921-08:14:30,269 nipype.workflow INFO:\n", - "\t [Job 77] Cached (preproc.art).\n", - "200921-08:14:30,274 nipype.workflow INFO:\n", - "\t [Job 87] Cached (preproc.coregwf.coreg_bbr).\n", - "200921-08:14:32,194 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 9 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:32,273 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_06_task_name_fingerfootlips/_fwhm_10/datasink\".\n", - "200921-08:14:32,281 nipype.workflow INFO:\n", - "\t [Job 88] Cached (preproc.coregwf.applywarp_mean).\n", - "200921-08:14:32,281 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_06_task_name_fingerfootlips/_fwhm_5/datasink\".\n", - "200921-08:14:32,284 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", - "200921-08:14:32,288 nipype.workflow INFO:\n", - "\t [Job 89] Cached (preproc.slicetimer).\n", - "200921-08:14:32,288 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-06/task-fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold.par\n", - "200921-08:14:32,289 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/art.sub-06_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-06/task-fingerfootlips/art.sub-06_ses-test_task-fingerfootlips_bold_outliers.txt\n", - "200921-08:14:32,290 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200921-08:14:32,291 nipype.interface INFO:\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/plot.sub-06_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-06/task-fingerfootlips/plot.sub-06_ses-test_task-fingerfootlips_bold.svg\n", - "\n", - "200921-08:14:32,293 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/sub-06_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-06/task-fingerfootlips/sub-06_t1w_preproc_brain.nii.gz\n", - "200921-08:14:32,293 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-06/task-fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold.par200921-08:14:32,294 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-06/task-fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_mean.mat\n", - "\n", - "200921-08:14:32,296 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-06/task-fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_mean.nii.gz200921-08:14:32,296 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/art.sub-06_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-06/task-fingerfootlips/art.sub-06_ses-test_task-fingerfootlips_bold_outliers.txt\n", - "\n", - "200921-08:14:32,298 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/_fwhm_10/ssub-06_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-06/task-fingerfootlips/fwhm-10_ssub-06_ses-test_task-fingerfootlips_bold.nii\n", - "200921-08:14:32,299 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/plot.sub-06_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-06/task-fingerfootlips/plot.sub-06_ses-test_task-fingerfootlips_bold.svg\n", - "200921-08:14:32,301 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/sub-06_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-06/task-fingerfootlips/sub-06_t1w_preproc_brain.nii.gz\n", - "200921-08:14:32,304 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-06/task-fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_mean.mat\n", - "200921-08:14:32,305 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".200921-08:14:32,306 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-06/task-fingerfootlips/sub-06_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", - "\n", - "200921-08:14:32,308 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_06_task_name_fingerfootlips/_fwhm_5/ssub-06_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-06/task-fingerfootlips/fwhm-5_ssub-06_ses-test_task-fingerfootlips_bold.nii\n", - "200921-08:14:32,312 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".\n", - "200921-08:14:34,194 nipype.workflow INFO:\n", - "\t [Job 78] Completed (preproc.datasink).\n", - "200921-08:14:34,197 nipype.workflow INFO:\n", - "\t [Job 79] Completed (preproc.datasink).\n", - "200921-08:14:34,202 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 6 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:34,274 nipype.workflow INFO:\n", - "\t [Job 90] Cached (preproc.coregwf.applywarp).\n", - "200921-08:14:34,277 nipype.workflow INFO:\n", - "\t [Job 98] Cached (preproc.coregwf.segmentation).\n", - "200921-08:14:34,280 nipype.workflow INFO:\n", - "\t [Job 100] Cached (preproc.extract).\n", - "200921-08:14:34,285 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_03_task_name_fingerfootlips/selectfiles\".\n", - "200921-08:14:34,291 nipype.workflow INFO:\n", - "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", - "200921-08:14:34,299 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.selectfiles\".\n", - "200921-08:14:36,194 nipype.workflow INFO:\n", - "\t [Job 112] Completed (preproc.selectfiles).\n", - "200921-08:14:36,197 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 9 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:36,261 nipype.workflow INFO:\n", - "\t [Job 91] Cached (preproc.smooth).\n", - "200921-08:14:36,264 nipype.workflow INFO:\n", - "\t [Job 92] Cached (preproc.smooth).\n", - "200921-08:14:36,271 nipype.workflow INFO:\n", - "\t [Job 93] Cached (preproc.art).\n", - "200921-08:14:36,274 nipype.workflow INFO:\n", - "\t [Job 99] Cached (preproc.coregwf.threshold).\n", - "200921-08:14:38,200 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 7 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:38,281 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_05_task_name_fingerfootlips/_fwhm_10/datasink\".\n", - "200921-08:14:38,288 nipype.workflow INFO:\n", - "\t [Job 101] Cached (preproc.mcflirt).\n", - "200921-08:14:38,288 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_05_task_name_fingerfootlips/_fwhm_5/datasink\".\n", - "200921-08:14:38,289 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200921-08:14:38,292 nipype.workflow INFO:\n", - "\t [Job 113] Cached (preproc.coregwf.bet_anat).\n", - "\n", - "200921-08:14:38,292 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-05/task-fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold.par\n", - "200921-08:14:38,295 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/art.sub-05_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-05/task-fingerfootlips/art.sub-05_ses-test_task-fingerfootlips_bold_outliers.txt200921-08:14:38,295 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", - "\n", - "200921-08:14:38,297 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/plot.sub-05_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-05/task-fingerfootlips/plot.sub-05_ses-test_task-fingerfootlips_bold.svg\n", - "200921-08:14:38,300 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-05/task-fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold.par200921-08:14:38,300 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/sub-05_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-05/task-fingerfootlips/sub-05_t1w_preproc_brain.nii.gz\n", - "\n", - "200921-08:14:38,302 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-05/task-fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_mean.mat200921-08:14:38,303 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/art.sub-05_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-05/task-fingerfootlips/art.sub-05_ses-test_task-fingerfootlips_bold_outliers.txt\n", - "\n", - "200921-08:14:38,305 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-05/task-fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_mean.nii.gz200921-08:14:38,306 nipype.interface INFO:\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/plot.sub-05_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-05/task-fingerfootlips/plot.sub-05_ses-test_task-fingerfootlips_bold.svg\n", - "\n", - "200921-08:14:38,307 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/_fwhm_10/ssub-05_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-05/task-fingerfootlips/fwhm-10_ssub-05_ses-test_task-fingerfootlips_bold.nii200921-08:14:38,308 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/sub-05_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-05/task-fingerfootlips/sub-05_t1w_preproc_brain.nii.gz\n", - "\n", - "200921-08:14:38,310 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-05/task-fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_mean.mat\n", - "200921-08:14:38,312 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-05/task-fingerfootlips/sub-05_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", - "200921-08:14:38,314 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_05_task_name_fingerfootlips/_fwhm_5/ssub-05_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-05/task-fingerfootlips/fwhm-5_ssub-05_ses-test_task-fingerfootlips_bold.nii\n", - "200921-08:14:38,315 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".\n", - "200921-08:14:38,318 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".\n", - "200921-08:14:40,200 nipype.workflow INFO:\n", - "\t [Job 94] Completed (preproc.datasink).\n", - "200921-08:14:40,203 nipype.workflow INFO:\n", - "\t [Job 95] Completed (preproc.datasink).\n", - "200921-08:14:40,208 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 6 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:40,278 nipype.workflow INFO:\n", - "\t [Job 102] Cached (preproc.coregwf.coreg_pre).\n", - "200921-08:14:40,281 nipype.workflow INFO:\n", - "\t [Job 105] Cached (preproc.slicetimer).\n", - "200921-08:14:40,284 nipype.workflow INFO:\n", - "\t [Job 114] Cached (preproc.coregwf.segmentation).\n", - "200921-08:14:40,287 nipype.workflow INFO:\n", - "\t [Job 116] Cached (preproc.extract).\n", - "200921-08:14:42,203 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 5 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:42,274 nipype.workflow INFO:\n", - "\t [Job 103] Cached (preproc.coregwf.coreg_bbr).\n", - "200921-08:14:42,278 nipype.workflow INFO:\n", - "\t [Job 115] Cached (preproc.coregwf.threshold).\n", - "200921-08:14:42,281 nipype.workflow INFO:\n", - "\t [Job 117] Cached (preproc.mcflirt).\n", - "200921-08:14:42,284 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_02_task_name_fingerfootlips/selectfiles\".\n", - "200921-08:14:42,291 nipype.workflow INFO:\n", - "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", - "200921-08:14:42,299 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.selectfiles\".\n", - "200921-08:14:44,201 nipype.workflow INFO:\n", - "\t [Job 128] Completed (preproc.selectfiles).\n", - "200921-08:14:44,207 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 7 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:44,283 nipype.workflow INFO:\n", - "\t [Job 104] Cached (preproc.coregwf.applywarp_mean).\n", - "200921-08:14:44,291 nipype.workflow INFO:\n", - "\t [Job 106] Cached (preproc.coregwf.applywarp).\n", - "200921-08:14:44,294 nipype.workflow INFO:\n", - "\t [Job 118] Cached (preproc.coregwf.coreg_pre).\n", - "200921-08:14:44,297 nipype.workflow INFO:\n", - "\t [Job 121] Cached (preproc.slicetimer).\n", - "200921-08:14:46,267 nipype.workflow INFO:\n", - "\t [Job 107] Cached (preproc.smooth).\n", - "200921-08:14:46,269 nipype.workflow INFO:\n", - "\t [Job 108] Cached (preproc.smooth).\n", - "200921-08:14:46,273 nipype.workflow INFO:\n", - "\t [Job 109] Cached (preproc.art).\n", - "200921-08:14:46,277 nipype.workflow INFO:\n", - "\t [Job 119] Cached (preproc.coregwf.coreg_bbr).\n", - "200921-08:14:48,283 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_04_task_name_fingerfootlips/_fwhm_10/datasink\".\n", - "200921-08:14:48,291 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_04_task_name_fingerfootlips/_fwhm_5/datasink\".\n", - "200921-08:14:48,294 nipype.workflow INFO:\n", - "\t [Job 120] Cached (preproc.coregwf.applywarp_mean).\n", - "200921-08:14:48,294 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", - "200921-08:14:48,297 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", - "200921-08:14:48,299 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-04/task-fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold.par\n", - "200921-08:14:48,300 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/art.sub-04_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-04/task-fingerfootlips/art.sub-04_ses-test_task-fingerfootlips_bold_outliers.txt200921-08:14:48,302 nipype.workflow INFO:\n", - "\t [Job 122] Cached (preproc.coregwf.applywarp).\n", - "200921-08:14:48,301 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-04/task-fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold.par\n", - "200921-08:14:48,302 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/plot.sub-04_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-04/task-fingerfootlips/plot.sub-04_ses-test_task-fingerfootlips_bold.svg\n", - "\n", - "200921-08:14:48,303 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/art.sub-04_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-04/task-fingerfootlips/art.sub-04_ses-test_task-fingerfootlips_bold_outliers.txt\n", - "200921-08:14:48,306 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/sub-04_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-04/task-fingerfootlips/sub-04_t1w_preproc_brain.nii.gz200921-08:14:48,307 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/plot.sub-04_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-04/task-fingerfootlips/plot.sub-04_ses-test_task-fingerfootlips_bold.svg\n", - "200921-08:14:48,309 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-04/task-fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_mean.mat\n", - "\n", - "200921-08:14:48,310 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/sub-04_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-04/task-fingerfootlips/sub-04_t1w_preproc_brain.nii.gz\n", - "200921-08:14:48,311 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-04/task-fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_mean.nii.gz200921-08:14:48,312 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-04/task-fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_mean.mat\n", - "\n", - "200921-08:14:48,315 nipype.interface INFO:\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-04/task-fingerfootlips/sub-04_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", - "200921-08:14:48,315 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/_fwhm_10/ssub-04_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-04/task-fingerfootlips/fwhm-10_ssub-04_ses-test_task-fingerfootlips_bold.nii200921-08:14:48,317 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_04_task_name_fingerfootlips/_fwhm_5/ssub-04_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-04/task-fingerfootlips/fwhm-5_ssub-04_ses-test_task-fingerfootlips_bold.nii\n", - "\n", - "200921-08:14:48,321 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".\n", - "200921-08:14:48,323 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".\n", - "200921-08:14:50,207 nipype.workflow INFO:\n", - "\t [Job 110] Completed (preproc.datasink).\n", - "200921-08:14:50,211 nipype.workflow INFO:\n", - "\t [Job 111] Completed (preproc.datasink).\n", - "200921-08:14:50,215 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 6 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:50,285 nipype.workflow INFO:\n", - "\t [Job 123] Cached (preproc.smooth).\n", - "200921-08:14:50,288 nipype.workflow INFO:\n", - "\t [Job 124] Cached (preproc.smooth).\n", - "200921-08:14:50,292 nipype.workflow INFO:\n", - "\t [Job 125] Cached (preproc.art).\n", - "200921-08:14:50,295 nipype.workflow INFO:\n", - "\t [Job 129] Cached (preproc.coregwf.bet_anat).\n", - "200921-08:14:52,212 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 5 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:52,289 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_03_task_name_fingerfootlips/_fwhm_10/datasink\".\n", - "200921-08:14:52,296 nipype.workflow INFO:\n", - "\t [Job 130] Cached (preproc.coregwf.segmentation).\n", - "200921-08:14:52,297 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_03_task_name_fingerfootlips/_fwhm_5/datasink\".\n", - "200921-08:14:52,299 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", - "200921-08:14:52,302 nipype.workflow INFO:\n", - "\t [Job 132] Cached (preproc.extract).\n", - "200921-08:14:52,308 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200921-08:14:52,302 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-03/task-fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold.par\n", - "\n", - "200921-08:14:52,310 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/art.sub-03_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-03/task-fingerfootlips/art.sub-03_ses-test_task-fingerfootlips_bold_outliers.txt\n", - "200921-08:14:52,312 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/plot.sub-03_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-03/task-fingerfootlips/plot.sub-03_ses-test_task-fingerfootlips_bold.svg200921-08:14:52,312 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-03/task-fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold.par\n", - "\n", - "200921-08:14:52,314 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/art.sub-03_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-03/task-fingerfootlips/art.sub-03_ses-test_task-fingerfootlips_bold_outliers.txt200921-08:14:52,314 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/sub-03_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-03/task-fingerfootlips/sub-03_t1w_preproc_brain.nii.gz\n", - "\n", - "200921-08:14:52,316 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/plot.sub-03_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-03/task-fingerfootlips/plot.sub-03_ses-test_task-fingerfootlips_bold.svg200921-08:14:52,317 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-03/task-fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_mean.mat\n", - "\n", - "200921-08:14:52,319 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/sub-03_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-03/task-fingerfootlips/sub-03_t1w_preproc_brain.nii.gz200921-08:14:52,319 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-03/task-fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", - "200921-08:14:52,321 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/_fwhm_10/ssub-03_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-03/task-fingerfootlips/fwhm-10_ssub-03_ses-test_task-fingerfootlips_bold.nii\n", - "\n", - "200921-08:14:52,323 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-03/task-fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_mean.mat\n", - "200921-08:14:52,324 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-03/task-fingerfootlips/sub-03_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", - "200921-08:14:52,326 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".200921-08:14:52,326 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_03_task_name_fingerfootlips/_fwhm_5/ssub-03_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-03/task-fingerfootlips/fwhm-5_ssub-03_ses-test_task-fingerfootlips_bold.nii\n", - "\n", - "200921-08:14:52,331 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".\n", - "200921-08:14:54,212 nipype.workflow INFO:\n", - "\t [Job 126] Completed (preproc.datasink).\n", - "200921-08:14:54,215 nipype.workflow INFO:\n", - "\t [Job 127] Completed (preproc.datasink).\n", - "200921-08:14:54,220 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 3 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:54,297 nipype.workflow INFO:\n", - "\t [Job 131] Cached (preproc.coregwf.threshold).\n", - "200921-08:14:54,302 nipype.workflow INFO:\n", - "\t [Job 133] Cached (preproc.mcflirt).\n", - "200921-08:14:54,307 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.selectfiles\" in \"/output/workingdir/preproc/_subject_id_01_task_name_fingerfootlips/selectfiles\".\n", - "200921-08:14:54,312 nipype.workflow INFO:\n", - "\t [Node] Running \"selectfiles\" (\"nipype.interfaces.io.SelectFiles\")\n", - "200921-08:14:54,316 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.selectfiles\".\n", - "200921-08:14:56,213 nipype.workflow INFO:\n", - "\t [Job 144] Completed (preproc.selectfiles).\n", - "200921-08:14:56,218 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 4 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:56,287 nipype.workflow INFO:\n", - "\t [Job 134] Cached (preproc.coregwf.coreg_pre).\n", - "200921-08:14:56,291 nipype.workflow INFO:\n", - "\t [Job 137] Cached (preproc.slicetimer).\n", - "200921-08:14:56,294 nipype.workflow INFO:\n", - "\t [Job 145] Cached (preproc.coregwf.bet_anat).\n", - "200921-08:14:56,299 nipype.workflow INFO:\n", - "\t [Job 148] Cached (preproc.extract).\n", - "200921-08:14:58,215 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 3 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:14:58,285 nipype.workflow INFO:\n", - "\t [Job 135] Cached (preproc.coregwf.coreg_bbr).\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "200921-08:14:58,289 nipype.workflow INFO:\n", - "\t [Job 146] Cached (preproc.coregwf.segmentation).\n", - "200921-08:14:58,292 nipype.workflow INFO:\n", - "\t [Job 149] Cached (preproc.mcflirt).\n", - "200921-08:15:00,219 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 5 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:15:00,297 nipype.workflow INFO:\n", - "\t [Job 136] Cached (preproc.coregwf.applywarp_mean).\n", - "200921-08:15:00,301 nipype.workflow INFO:\n", - "\t [Job 138] Cached (preproc.coregwf.applywarp).\n", - "200921-08:15:00,304 nipype.workflow INFO:\n", - "\t [Job 147] Cached (preproc.coregwf.threshold).\n", - "200921-08:15:00,308 nipype.workflow INFO:\n", - "\t [Job 150] Cached (preproc.coregwf.coreg_pre).\n", - "200921-08:15:02,287 nipype.workflow INFO:\n", - "\t [Job 139] Cached (preproc.smooth).\n", - "200921-08:15:02,292 nipype.workflow INFO:\n", - "\t [Job 140] Cached (preproc.smooth).\n", - "200921-08:15:02,300 nipype.workflow INFO:\n", - "\t [Job 141] Cached (preproc.art).\n", - "200921-08:15:02,307 nipype.workflow INFO:\n", - "\t [Job 151] Cached (preproc.coregwf.coreg_bbr).\n", - "200921-08:15:04,222 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 4 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:15:04,303 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_02_task_name_fingerfootlips/_fwhm_10/datasink\".\n", - "200921-08:15:04,310 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_02_task_name_fingerfootlips/_fwhm_5/datasink\".\n", - "200921-08:15:04,313 nipype.workflow INFO:\n", - "\t [Job 152] Cached (preproc.coregwf.applywarp_mean).\n", - "200921-08:15:04,315 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")200921-08:15:04,316 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", - "200921-08:15:04,318 nipype.workflow INFO:\n", - "\t [Job 153] Cached (preproc.slicetimer).\n", - "\n", - "200921-08:15:04,319 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-02/task-fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold.par200921-08:15:04,319 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-02/task-fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold.par\n", - "\n", - "200921-08:15:04,321 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/art.sub-02_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-02/task-fingerfootlips/art.sub-02_ses-test_task-fingerfootlips_bold_outliers.txt\n", - "200921-08:15:04,322 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/art.sub-02_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-02/task-fingerfootlips/art.sub-02_ses-test_task-fingerfootlips_bold_outliers.txt200921-08:15:04,323 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/plot.sub-02_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-02/task-fingerfootlips/plot.sub-02_ses-test_task-fingerfootlips_bold.svg\n", - "\n", - "200921-08:15:04,325 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/sub-02_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-02/task-fingerfootlips/sub-02_t1w_preproc_brain.nii.gz200921-08:15:04,325 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/plot.sub-02_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-02/task-fingerfootlips/plot.sub-02_ses-test_task-fingerfootlips_bold.svg\n", - "\n", - "200921-08:15:04,327 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-02/task-fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_mean.mat200921-08:15:04,327 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/sub-02_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-02/task-fingerfootlips/sub-02_t1w_preproc_brain.nii.gz\n", - "200921-08:15:04,329 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-02/task-fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", - "\n", - "200921-08:15:04,331 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-02/task-fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_mean.mat200921-08:15:04,332 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/_fwhm_5/ssub-02_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-02/task-fingerfootlips/fwhm-5_ssub-02_ses-test_task-fingerfootlips_bold.nii\n", - "\n", - "200921-08:15:04,334 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-02/task-fingerfootlips/sub-02_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", - "200921-08:15:04,336 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_02_task_name_fingerfootlips/_fwhm_10/ssub-02_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-02/task-fingerfootlips/fwhm-10_ssub-02_ses-test_task-fingerfootlips_bold.nii\n", - "200921-08:15:04,338 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".\n", - "200921-08:15:04,341 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".\n", - "200921-08:15:06,220 nipype.workflow INFO:\n", - "\t [Job 142] Completed (preproc.datasink).\n", - "200921-08:15:06,222 nipype.workflow INFO:\n", - "\t [Job 143] Completed (preproc.datasink).\n", - "200921-08:15:06,226 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 1 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:15:06,290 nipype.workflow INFO:\n", - "\t [Job 154] Cached (preproc.coregwf.applywarp).\n", - "200921-08:15:08,226 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 3 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:15:08,297 nipype.workflow INFO:\n", - "\t [Job 155] Cached (preproc.smooth).\n", - "200921-08:15:08,300 nipype.workflow INFO:\n", - "\t [Job 156] Cached (preproc.smooth).\n", - "200921-08:15:08,304 nipype.workflow INFO:\n", - "\t [Job 157] Cached (preproc.art).\n", - "200921-08:15:10,224 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 2 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n", - "200921-08:15:10,298 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_01_task_name_fingerfootlips/_fwhm_10/datasink\".\n", - "200921-08:15:10,309 nipype.workflow INFO:\n", - "\t [Node] Setting-up \"preproc.datasink\" in \"/output/workingdir/preproc/_subject_id_01_task_name_fingerfootlips/_fwhm_5/datasink\".200921-08:15:10,309 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", - "\n", - "200921-08:15:10,312 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-01/task-fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold.par\n", - "200921-08:15:10,316 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/art.sub-01_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-01/task-fingerfootlips/art.sub-01_ses-test_task-fingerfootlips_bold_outliers.txt200921-08:15:10,317 nipype.workflow INFO:\n", - "\t [Node] Running \"datasink\" (\"nipype.interfaces.io.DataSink\")\n", - "\n", - "200921-08:15:10,319 nipype.interface INFO:\n" + "210919-19:11:30,923 nipype.workflow WARNING:\n", + "\t Some nodes exceed the total amount of memory available (1.00GB).\n" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/plot.sub-01_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-01/task-fingerfootlips/plot.sub-01_ses-test_task-fingerfootlips_bold.svg200921-08:15:10,320 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_roi_mcf.nii.par -> /output/datasink/preproc/sub-01/task-fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold.par\n", - "\n", - "200921-08:15:10,322 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/art.sub-01_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt_outliers.txt -> /output/datasink/preproc/sub-01/task-fingerfootlips/art.sub-01_ses-test_task-fingerfootlips_bold_outliers.txt\n", - "200921-08:15:10,323 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/sub-01_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-01/task-fingerfootlips/sub-01_t1w_preproc_brain.nii.gz200921-08:15:10,323 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/plot.sub-01_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.svg -> /output/datasink/preproc/sub-01/task-fingerfootlips/plot.sub-01_ses-test_task-fingerfootlips_bold.svg\n", - "\n", - "200921-08:15:10,325 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-01/task-fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_mean.mat\n", - "200921-08:15:10,326 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/sub-01_t1w_preproc_brain.nii.gz -> /output/datasink/preproc/sub-01/task-fingerfootlips/sub-01_t1w_preproc_brain.nii.gz200921-08:15:10,327 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-01/task-fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", - "\n", - "200921-08:15:10,328 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/_fwhm_10/ssub-01_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-01/task-fingerfootlips/fwhm-10_ssub-01_ses-test_task-fingerfootlips_bold.nii200921-08:15:10,329 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.mat -> /output/datasink/preproc/sub-01/task-fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_mean.mat\n", - "\n", - "200921-08:15:10,331 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_roi_mcf.nii_mean_reg_flirt.nii.gz -> /output/datasink/preproc/sub-01/task-fingerfootlips/sub-01_ses-test_task-fingerfootlips_bold_mean.nii.gz\n", - "200921-08:15:10,333 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".200921-08:15:10,333 nipype.interface INFO:\n", - "\t sub: /output/datasink/preproc/_subject_id_01_task_name_fingerfootlips/_fwhm_5/ssub-01_ses-test_task-fingerfootlips_bold_roi_mcf_st_flirt.nii -> /output/datasink/preproc/sub-01/task-fingerfootlips/fwhm-5_ssub-01_ses-test_task-fingerfootlips_bold.nii\n", - "\n", - "200921-08:15:10,337 nipype.workflow INFO:\n", - "\t [Node] Finished \"preproc.datasink\".\n", - "200921-08:15:12,225 nipype.workflow INFO:\n", - "\t [Job 158] Completed (preproc.datasink).\n", - "200921-08:15:12,229 nipype.workflow INFO:\n", - "\t [Job 159] Completed (preproc.datasink).\n", - "200921-08:15:12,234 nipype.workflow INFO:\n", - "\t [MultiProc] Running 0 tasks, and 0 jobs ready. Free memory (GB): 56.54/56.54, Free processors: 4/4.\n" + "ename": "RuntimeError", + "evalue": "Insufficient resources available for job", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0margs_dict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m'n_procs'\u001b[0m \u001b[0;34m:\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'memory_gb'\u001b[0m \u001b[0;34m:\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mpreproc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'MultiProc'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mplugin_args\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0margs_dict\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/opt/miniconda-latest/envs/neuro/lib/python3.6/site-packages/nipype/pipeline/engine/workflows.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, plugin, plugin_args, updatehash)\u001b[0m\n\u001b[1;32m 630\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mstr2bool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"execution\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"create_report\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 631\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_write_report_info\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbase_dir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexecgraph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 632\u001b[0;31m \u001b[0mrunner\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexecgraph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mupdatehash\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mupdatehash\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mconfig\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 633\u001b[0m \u001b[0mdatestr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdatetime\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mutcnow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstrftime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"%Y%m%dT%H%M%S\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 634\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mstr2bool\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"execution\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"write_provenance\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/opt/miniconda-latest/envs/neuro/lib/python3.6/site-packages/nipype/pipeline/plugins/base.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, graph, config, updatehash)\u001b[0m\n\u001b[1;32m 117\u001b[0m \u001b[0mpoll_sleep_secs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"execution\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"poll_sleep_duration\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 118\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 119\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_prerun_check\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgraph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 120\u001b[0m \u001b[0;31m# Generate appropriate structures for worker-manager model\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 121\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_generate_dependency_list\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgraph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/opt/miniconda-latest/envs/neuro/lib/python3.6/site-packages/nipype/pipeline/plugins/multiproc.py\u001b[0m in \u001b[0;36m_prerun_check\u001b[0;34m(self, graph)\u001b[0m\n\u001b[1;32m 196\u001b[0m )\n\u001b[1;32m 197\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mraise_insufficient\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 198\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mRuntimeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Insufficient resources available for job\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 199\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 200\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0many\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtasks_num_th\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprocessors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mRuntimeError\u001b[0m: Insufficient resources available for job" ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ - "preproc.run('MultiProc', plugin_args={'n_procs': 4})" + "args_dict = {'n_procs' : 1, 'memory_gb' : 1}\n", + "preproc.run('MultiProc', plugin_args=args_dict)" ] }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "slide" + }, + "solution2": "hidden", + "solution2_first": true + }, "source": [ "## Inspect output\n", "\n", @@ -1892,7 +745,11 @@ { "cell_type": "code", "execution_count": 22, - "metadata": {}, + "metadata": { + "slideshow": { + "slide_type": "subslide" + } + }, "outputs": [ { "name": "stdout", @@ -2607,6 +1464,7 @@ ], "metadata": { "anaconda-cloud": {}, + "celltoolbar": "Slideshow", "kernelspec": { "display_name": "Python 3", "language": "python",