From 9cb4f70a42f256fd38fce6d2e880c0a9a5d80495 Mon Sep 17 00:00:00 2001
From: Moni Doerig <82578141+MoniDoerig@users.noreply.github.com>
Date: Fri, 30 Aug 2024 16:38:56 +0200
Subject: [PATCH 01/13] Update NIFTI_NORDIC.m

Renamed function, adapted arguments and added additonal code for integration with a Nipype interface
---
 NIFTI_NORDIC.m | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/NIFTI_NORDIC.m b/NIFTI_NORDIC.m
index 8f2a11b..84cdaa6 100644
--- a/NIFTI_NORDIC.m
+++ b/NIFTI_NORDIC.m
@@ -1,4 +1,16 @@
-function  NIFTI_NORDIC(fn_magn_in,fn_phase_in,fn_out,ARG)
+function NIFTI_NORDIC_nipype(fn_magn_in,fn_phase_in,fn_out,ARG_path)
+
+% Additional code for integration with the Nipype interface for NIFTI_NORDIC 
+% This customization is tailored to the specific requirements of it and may
+% need adaptations when the Nipype interface is modified
+ 
+if exist('ARG_path') 
+    arg_struct = load(ARG_path);
+    ARG = arg_struct.ARG;
+    ARG = structfun(@double, ARG, 'uniformoutput', 0); %fields need to be casted to double (from python struct with datatype int64) 
+    disp(ARG)
+end
+
 % fMRI
 %  fn_magn_in='name.nii.gz';
 %  fn_phase_in='name2.nii.gz';

From 33952c8645cdbd85de11d29a7f61070ace1d8c3e Mon Sep 17 00:00:00 2001
From: Moni Doerig <82578141+MoniDoerig@users.noreply.github.com>
Date: Fri, 30 Aug 2024 16:41:03 +0200
Subject: [PATCH 02/13] Add nipype interface for NIFTI_NORDIC_nipype

---
 NIFTI_NORDIC_interface.py | 68 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 NIFTI_NORDIC_interface.py

diff --git a/NIFTI_NORDIC_interface.py b/NIFTI_NORDIC_interface.py
new file mode 100644
index 0000000..a1d4984
--- /dev/null
+++ b/NIFTI_NORDIC_interface.py
@@ -0,0 +1,68 @@
+# Author: Monika Dörig, 2023
+# Questions & Inputs to: monika.doerig@balgrist.ch
+
+
+
+
+from nipype.interfaces.base import (CommandLine, traits, TraitedSpec,
+                                    BaseInterface, BaseInterfaceInputSpec, File)
+import os
+
+
+class NiftiNordicInputSpec(BaseInterfaceInputSpec):
+    additional_path = traits.Str(desc='Additional path to be added with addpath in MATLAB', mandatory=True)
+    fn_magn_in = traits.File(exists=True, desc='Input magnitude file', mandatory=True)
+    fn_phase_in = traits.File(exists=True, desc='Input phase file', mandatory=True)
+    fn_out = traits.Str(desc='Output prefix or suffix', mandatory=True)
+    ARG = traits.File(exists=True, desc='Path to MATLAB struct file representing input parameters')
+                      
+
+class NiftiNordicOutputSpec(TraitedSpec):
+    # traits.Either allows for the possibility that the file might not exist (None) or that it exists and is a valid file (File(exists=True))
+    output_file = traits.Either(None, File(exists=True), desc='Denoised nii file')
+    add_info_file = traits.Either(None, File(exists=True), desc='Optional output file for additional info')
+    complex_phase_file = traits.Either(None, File(exists=True), desc='Optional output file - saves phase in similar format as input phase')
+    complex_magn_file = traits.Either(None, File(exists=True), desc='Optional output file - saves magn in similar format as input magn')
+    gfactor_map_file = traits.Either(None, File(exists=True), desc='Optional output file for gfactor map')
+    residual_mat_file = traits.Either(None, File(exists=True), desc='Optional output file for NORDIC residuals')
+
+class NiftiNordic(BaseInterface):
+    input_spec = NiftiNordicInputSpec
+    output_spec = NiftiNordicOutputSpec
+    
+    def _run_interface(self, runtime):
+        # Third argument for NIFTI_NORDIC_nipype.m may need adaptation depending on the the suffix of your file: here it is defined for a .nii.gz file --> [0:-7]
+        mlab_cmd = f"matlab -r \"addpath('{self.inputs.additional_path}'); try; NIFTI_NORDIC_nipype ('{self.inputs.fn_magn_in}', '{self.inputs.fn_phase_in}', '{os.path.basename(self.inputs.fn_magn_in)[0:-7]}{self.inputs.fn_out}','{self.inputs.ARG}' ); catch ME; disp(getReport(ME)); end; quit;\""
+        mlab = CommandLine(command=mlab_cmd, terminal_output='stream', resource_monitor=True)
+        result = mlab.run()  
+        return result.runtime
+
+    def _list_outputs(self):
+        outputs = self.output_spec().get()
+        
+        # Check if the output files exist (depending on the arguments) and assign outputs 
+        output = os.path.abspath(f"{os.getcwd()}/{os.path.basename(self.inputs.fn_magn_in)[0:-7]}{self.inputs.fn_out}.nii")
+        if os.path.exists(output):
+            outputs['output_file'] = output
+            
+        info = os.path.abspath(f"{os.getcwd()}/{os.path.basename(self.inputs.fn_magn_in)[0:-7]}{self.inputs.fn_out}_info.mat")
+        if os.path.exists(info):
+            outputs['add_info_file'] = info
+            
+        complex_phase = os.path.abspath(f"{os.getcwd()}/{os.path.basename(self.inputs.fn_magn_in)[0:-7]}{self.inputs.fn_out}_phase.nii")
+        if os.path.exists(complex_phase):
+            outputs['complex_phase_file'] = complex_phase
+            
+        complex_magn = os.path.abspath(f"{os.getcwd()}/{os.path.basename(self.inputs.fn_magn_in)[0:-7]}{self.inputs.fn_out}_magn.nii")
+        if os.path.exists(complex_magn):
+            outputs['complex_magn_file'] = complex_magn
+            
+        gfactor = os.path.abspath(f"{os.getcwd()}/gfactor_{os.path.basename(self.inputs.fn_magn_in)[0:-7]}{self.inputs.fn_out}.nii")
+        if os.path.exists(gfactor):
+            outputs['gfactor_map_file'] = gfactor     
+            
+        residuals = os.path.abspath(f"{os.getcwd()}/RESIDUAL{os.path.basename(self.inputs.fn_magn_in)[0:-7]}{self.inputs.fn_out}.mat")
+        if os.path.exists(residuals):
+            outputs['residual_mat_file'] = residuals
+            
+        return outputs
\ No newline at end of file

From 9741836c9e585edba3727d489578e7ef27ffc99d Mon Sep 17 00:00:00 2001
From: Moni Doerig <82578141+MoniDoerig@users.noreply.github.com>
Date: Fri, 30 Aug 2024 16:45:49 +0200
Subject: [PATCH 03/13] Add notebook

Notebook showing example usage of using the Nipype interface and TSNR maps
---
 example_usage_NORDIC_nipype.ipynb | 1294 +++++++++++++++++++++++++++++
 1 file changed, 1294 insertions(+)
 create mode 100644 example_usage_NORDIC_nipype.ipynb

diff --git a/example_usage_NORDIC_nipype.ipynb b/example_usage_NORDIC_nipype.ipynb
new file mode 100644
index 0000000..b4bf839
--- /dev/null
+++ b/example_usage_NORDIC_nipype.ipynb
@@ -0,0 +1,1294 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "6d915534-be0e-4568-a8ea-f92e99275a09",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "#  NIFTI_NORDIC in Nipype\n",
+    "\n",
+    "__Author:__ Moni Dörig"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3dc72279-091b-45b4-bfdb-384a954e0651",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "### References:\n",
+    "\n",
+    "__NORDIC:__\n",
+    "- Vizioli, L., Moeller, S., Dowdle, L. et al. Lowering the thermal noise barrier in functional brain mapping with magnetic resonance imaging. Nat Commun 12, 5181 (2021). https://doi.org/10.1038/s41467-021-25431-8\n",
+    "- [Code on GitHub supporting the publication](https://github.com/SteenMoeller/NORDIC_Raw)\n",
+    "\n",
+    "__Opensource Data from OpenNeuro:__\n",
+    "- Javier Gonzalez-Castilloa and Colin W. Hoy and Daniel A. Handwerker and Vinai Roopchansingh and Souheil J. Inati and Ziad S. Saad and Robert W. Cox and Peter A. Bandettini (2023). Large Single-Subject Functional MRI Datasets at 7T. OpenNeuro. [Dataset] doi: [10.18112/openneuro.ds001555.v1.0.1](https://openneuro.org/datasets/ds001555/versions/1.0.1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e2bf1927-d779-447c-9376-018ec6c34026",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['matlab/2022a', 'afni/23.3.02', 'fsl/6.0.7.4']"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import lmod\n",
+    "await lmod.purge(force=True)\n",
+    "await lmod.load('matlab/2022a')\n",
+    "await lmod.load('afni/23.3.02')\n",
+    "await lmod.load('fsl/6.0.7.4')\n",
+    "await lmod.list()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "d9d3810b-bc7c-408e-8f63-f751525ac09c",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from nipype import Node, Function, Workflow\n",
+    "from nipype.interfaces import afni\n",
+    "from nipype.interfaces.fsl import BET, ApplyMask\n",
+    "from nipype.interfaces.io import DataSink, SelectFiles, File\n",
+    "from nipype.interfaces.utility import IdentityInterface, Function\n",
+    "from nipype.interfaces.base import (CommandLine, traits, TraitedSpec,\n",
+    "                                    BaseInterface, BaseInterfaceInputSpec, File)\n",
+    "from nipype.algorithms.confounds import TSNR\n",
+    "from scipy.io import savemat\n",
+    "import os\n",
+    "import sys"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "20c57a8d-4f7c-46a2-b392-2e3f0754d37e",
+   "metadata": {},
+   "source": [
+    "### Download data from OpenNeuro"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "aa3c7809-3d20-4bb4-ba2a-1c21d153eedc",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "%%capture\n",
+    "# Download 1 subject, don't display output\n",
+    "PATTERN = \"sub-001/ses-01\"\n",
+    "\n",
+    "!datalad install https://github.com/OpenNeuroDatasets/ds001555.git\n",
+    "!cd ds001555 && datalad get $PATTERN"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "2d34bb97-e826-41dc-9722-a79064e16c2d",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[01;34m.\u001b[0m\n",
+      "├── \u001b[01;34manat\u001b[0m\n",
+      "│   ├── \u001b[00msub-001_ses-01_acq-MPRAGE_run-001_T1w.json\u001b[0m\n",
+      "│   ├── \u001b[01;36msub-001_ses-01_acq-MPRAGE_run-001_T1w.nii.gz\u001b[0m -> \u001b[01;31m../../../.git/annex/objects/FG/jG/MD5E-s11361709--21046e99e714dbe42ab2fafbea250db8.nii.gz/MD5E-s11361709--21046e99e714dbe42ab2fafbea250db8.nii.gz\u001b[0m\n",
+      "│   ├── \u001b[00msub-001_ses-01_run-001_PD.json\u001b[0m\n",
+      "│   └── \u001b[01;36msub-001_ses-01_run-001_PD.nii.gz\u001b[0m -> \u001b[01;31m../../../.git/annex/objects/z7/Pp/MD5E-s11969134--76c8adafe414fdd1a0be886cb6917e6b.nii.gz/MD5E-s11969134--76c8adafe414fdd1a0be886cb6917e6b.nii.gz\u001b[0m\n",
+      "├── \u001b[01;34mfunc\u001b[0m\n",
+      "│   ├── \u001b[00msub-001_ses-01_task-HalfFovNoTask_run-003_bold.json\u001b[0m\n",
+      "│   ├── \u001b[01;36msub-001_ses-01_task-HalfFovNoTask_run-003_bold.nii.gz\u001b[0m -> \u001b[01;31m../../../.git/annex/objects/Mm/44/MD5E-s117000078--ec792152dff29c551f1f567c7e0fba34.nii.gz/MD5E-s117000078--ec792152dff29c551f1f567c7e0fba34.nii.gz\u001b[0m\n",
+      "│   ├── \u001b[00msub-001_ses-01_task-HalfFovNoTask_run-004_bold.json\u001b[0m\n",
+      "│   ├── \u001b[01;36msub-001_ses-01_task-HalfFovNoTask_run-004_bold.nii.gz\u001b[0m -> \u001b[01;31m../../../.git/annex/objects/G3/GK/MD5E-s117070442--ba4595bcc7e8f34a169f171a4e33a5d7.nii.gz/MD5E-s117070442--ba4595bcc7e8f34a169f171a4e33a5d7.nii.gz\u001b[0m\n",
+      "│   ├── \u001b[00msub-001_ses-01_task-HalfFovNoTask_run-006_bold.json\u001b[0m\n",
+      "│   ├── \u001b[01;36msub-001_ses-01_task-HalfFovNoTask_run-006_bold.nii.gz\u001b[0m -> \u001b[01;31m../../../.git/annex/objects/GP/g9/MD5E-s117020424--a754684d8afe0ec128e6d75f679b5bd2.nii.gz/MD5E-s117020424--a754684d8afe0ec128e6d75f679b5bd2.nii.gz\u001b[0m\n",
+      "│   ├── \u001b[00msub-001_ses-01_task-HalfFovNoTask_run-007_bold.json\u001b[0m\n",
+      "│   ├── \u001b[01;36msub-001_ses-01_task-HalfFovNoTask_run-007_bold.nii.gz\u001b[0m -> \u001b[01;31m../../../.git/annex/objects/zQ/vX/MD5E-s117117262--74f8ee93de0e7de42f27a5a5d147b1a2.nii.gz/MD5E-s117117262--74f8ee93de0e7de42f27a5a5d147b1a2.nii.gz\u001b[0m\n",
+      "│   ├── \u001b[00msub-001_ses-01_task-HalfFovNoTask_run-011_bold.json\u001b[0m\n",
+      "│   └── \u001b[01;36msub-001_ses-01_task-HalfFovNoTask_run-011_bold.nii.gz\u001b[0m -> \u001b[01;31m../../../.git/annex/objects/4x/Vz/MD5E-s117125158--d6799e63b134d605296ec54f3459b3c0.nii.gz/MD5E-s117125158--d6799e63b134d605296ec54f3459b3c0.nii.gz\u001b[0m\n",
+      "└── \u001b[00msub-001_ses-01_scans.tsv\u001b[0m\n",
+      "\n",
+      "2 directories, 15 files\n"
+     ]
+    }
+   ],
+   "source": [
+    "!cd ds001555/sub-001/ses-01 && tree -L 4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "a85e56bc-2897-496d-b92c-a1044c958d92",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#define directory with data\n",
+    "data_dir = os.path.abspath(os.path.join('.', 'ds001555'))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "380921b1-0d21-4b04-9f39-2eba6ef18cb0",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "### Nipype Interface for NIFTI_NORDIC Matlab Script"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "9ae90359-89dc-44ba-a51a-61210572a49a",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Add the scripts directory to sys.path (NIFIT_NORDIC_nipype.m and NIFTI_NORDIC_NIPYPE.py)\n",
+    "scripts_dir = os.path.abspath(os.path.join('.', 'interfaces'))\n",
+    "\n",
+    "if scripts_dir not in sys.path:\n",
+    "    sys.path.append(scripts_dir)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "65120cd4-79a0-43be-966d-9dff587bc558",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#import NiftiNordic class to wrap matlab script\n",
+    "from NIFTI_NORDIC_interface_default import NiftiNordic"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "f8c72c1a-032b-45ef-9779-66f983d993e9",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Inputs::\n",
+      "\n",
+      "        [Mandatory]\n",
+      "        additional_path: (a string)\n",
+      "                Additional path to be added with addpath in MATLAB\n",
+      "        fn_magn_in: (a string or os.PathLike object referring to an existing\n",
+      "                  file)\n",
+      "                Input magnitude file\n",
+      "        fn_phase_in: (a string or os.PathLike object referring to an existing\n",
+      "                  file)\n",
+      "                Input phase file\n",
+      "        fn_out: (a string)\n",
+      "                Output prefix or suffix\n",
+      "\n",
+      "Outputs::\n",
+      "\n",
+      "        output_file: (a pathlike object or string representing an existing\n",
+      "                  file or None)\n",
+      "                Denoised nii file\n",
+      "        add_info_file: (a pathlike object or string representing an existing\n",
+      "                  file or None)\n",
+      "                Optional output file for additional info\n",
+      "        complex_phase_file: (a pathlike object or string representing an\n",
+      "                  existing file or None)\n",
+      "                Optional output file - saves phase in similar format as input phase\n",
+      "        complex_magn_file: (a pathlike object or string representing an\n",
+      "                  existing file or None)\n",
+      "                Optional output file - saves magn in similar format as input magn\n",
+      "        gfactor_map_file: (a pathlike object or string representing an\n",
+      "                  existing file or None)\n",
+      "                Optional output file for gfactor map\n",
+      "        residual_mat_file: (a pathlike object or string representing an\n",
+      "                  existing file or None)\n",
+      "                Optional output file for NORDIC residuals\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "NiftiNordic.help()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f2c903e-aa96-4209-9402-30f356225b22",
+   "metadata": {},
+   "source": [
+    "### Initialize workflow and get funcitonal and anatomical data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "3128162b-e525-4d12-b11b-7230971353ee",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Create a workflow\n",
+    "#where to store workflow/working directories\n",
+    "experiment_dir = os.path.abspath(os.path.join('.', 'NORDIC_output'))\n",
+    "\n",
+    "workflow = Workflow(name='workflow_nordic', base_dir=experiment_dir)\n",
+    "workflow.config[\"execution\"][\"crashfile_format\"] = \"txt\"\n",
+    "\n",
+    "#functional and anatomical data\n",
+    "fn_magn_in = os.path.join(data_dir, 'sub-001/ses-01/func/sub-001_ses-01_task-HalfFovNoTask_run-003_bold.nii.gz')\n",
+    "anat = os.path.join(data_dir, 'sub-001/ses-01/anat/sub-001_ses-01_acq-MPRAGE_run-001_T1w.nii.gz')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "252e2a5f-d2c2-4f52-996a-bdd43ab33a0d",
+   "metadata": {},
+   "source": [
+    "### Get mask of anatomical image "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "c1751910-6634-47ef-88df-547fe22e9c4f",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "os.environ[\"FSLOUTPUTTYPE\"]=\"NIFTI_GZ\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "4c4f72dd-0794-43dd-94f8-35e44d9340a5",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "bet = Node(BET(), name='bet')\n",
+    "bet.inputs.in_file = anat \n",
+    "bet.inputs.mask = True  \n",
+    "bet.inputs.frac = 0.65\n",
+    "bet.inputs.output_type = 'NIFTI_GZ'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d6ed7862-74a9-4a35-981b-4a7e2812e82e",
+   "metadata": {},
+   "source": [
+    "### Motion correction of raw data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "a42866e5-66b8-4560-917a-49e13acb74a6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "volreg_raw = Node(afni.Volreg(interp='Fourier', outputtype = 'NIFTI_GZ'), \n",
+    "                 name='volreg_raw')\n",
+    "\n",
+    "volreg_raw.inputs.in_file = fn_magn_in"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5667c58a-b8db-4c64-aab5-aa07f442c19a",
+   "metadata": {},
+   "source": [
+    "### Resample anatomical mask to functional image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "abdcd5ee-1f93-408a-b30f-e6046117a085",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#resample anat mask to func dimension and resolution\n",
+    "def resample_mask(in_file, wb_mask):\n",
+    "    \n",
+    "    #get binary masks of functional run\n",
+    "    import os\n",
+    "    import nibabel as nib\n",
+    "    from nilearn.image import resample_to_img\n",
+    "\n",
+    "    base_name = os.path.basename(in_file) \n",
+    "    file_without_ext = base_name.rsplit('.', 2)[0] #split nii.gz\n",
+    "    new_file = file_without_ext + '_func_mask.nii.gz'\n",
+    "    file_path = os.path.join(os.getcwd(), new_file)\n",
+    "\n",
+    "    mask_img = resample_to_img(source_img=nib.load(wb_mask), target_img=nib.load(in_file), interpolation='nearest')\n",
+    "    nib.save(mask_img, file_path)\n",
+    "\n",
+    "    return file_path\n",
+    "\n",
+    "\n",
+    "get_fmri_mask = Node(Function(input_names=['in_file', 'wb_mask'], #func run, wb mask of bet\n",
+    "                        output_names=['mask_file'],\n",
+    "                        function=resample_mask),\n",
+    "                        name='resample_mask')\n",
+    "\n",
+    "workflow.connect(bet, 'mask_file', get_fmri_mask, 'wb_mask')\n",
+    "workflow.connect(volreg_raw, 'out_file', get_fmri_mask, 'in_file')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0ae66897-fe58-4c73-9841-42c226ebcbc8",
+   "metadata": {},
+   "source": [
+    "### Define input arguments for NORDIC \n",
+    "- not mandatory, otherwise default values will be initialized for ARG in NIFTI_NORDIC_nipype.m"
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "c342d50e-6e19-4d3a-bfe4-62e1173d07bf",
+   "metadata": {},
+   "source": [
+    "% OPTIONS \n",
+    "% ------------------------------------------------------------------------------------------\n",
+    "%   ARG.DIROUT    VAL=      string        Default is empty\n",
+    "%   ARG.noise_volume_last   VAL  = num  specifiec volume from the end of the series\n",
+    "%                                          0 default\n",
+    "%\n",
+    "%   ARG.factor_error        val  = num    >1 use higher noisefloor <1 use lower noisefloor \n",
+    "%                                          1 default \n",
+    "%\n",
+    "%   ARG.full_dynamic_range  val = [ 0 1]   0 keep the input scale, output maximizes range. \n",
+    "%                                            Default 0\n",
+    "%   ARG.temporal_phase      val = [1 2 3]  1 was default, 3 now in dMRI due tophase errors in some data\n",
+    "%   ARG.NORDIC              val = [0 1]    1 Default\n",
+    "%   ARG.MP                  val = [0 1 2]  1 NORDIC gfactor with MP estimation. \n",
+    "%                                          2 MP without gfactor correction\n",
+    "%                                          0 default\n",
+    "%   ARG.kernel_size_gfactor val = [val1 val2 val], defautl is [14 14 1]\n",
+    "%   ARG.kernel_size_PCA     val = [val1 val2 val], default is val1=val2=val3; \n",
+    "%                                                  ratio of 11:1 between spatial and temproal voxels\n",
+    "%   ARG.magnitude_only      val =[] or 1.  Using complex or magntiude only. Default is []\n",
+    "%                                          Function still needs two inputs but will ignore the second\n",
+    "%\n",
+    "%   ARG.save_add_info       val =[0 1];  If it is 1, then an additonal matlab file is being saved with degress removed etc.\n",
+    "%                                         default is 0\n",
+    "%   ARG.make_complex_nii    if the field exist, then the phase is being saved in a similar format as the input phase\n",
+    "%\n",
+    "%   ARG.phase_slice_average_for_kspace_centering     val = [0 1]   \n",
+    "%                                         if val =0, not used, if val=1 the series average pr slice is first removed\n",
+    "%                                         default is now 0\n",
+    "%   ARG.phase_filter_width  val = [1... 10]  Specifiec the width of the smoothing filter for the phase\n",
+    "%                                         default is now 3\n",
+    "%   \n",
+    "%   ARG.save_gfactor_map   val = [1 2].  1, saves the RELATIVE gfactor, 2 saves the\n",
+    "%                                            gfactor and does not complete the NORDIC processing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a5b5eff6-0130-407b-a885-c2502f7bcdff",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "arg_struct = {\n",
+    "    'noise_volume_last': 0,             # specifies volume from the end of the series, default = 0\n",
+    "    'factor_error': 1,                  # >1 use higher noisefloor, <1 use lower noisefloor, default = 1\n",
+    "    'full_dynamic_range': 0,            # 0 keep input scale, output maximises range, default = 0\n",
+    "    'temporal_phase': 1,                # calculate and apply spatial filter to each time-point - better in case of phase-drifts etc., default = 3\n",
+    "    'phase_filter_width': 3,            # specifies the width of the smoothing filter for the phase, default = 3\n",
+    "    'noise_volume_last': 0,             # specifiec volume from the end of the series, default = 0\n",
+    "    'gfactor_patch_overlap' : 6,        # overlap for the patch within which local PCA is ran\n",
+    "    'kernel_size' : [14,14,1],          # also [28, 28, 1]\n",
+    "    'magnitude_only': 1,                # Using complex or magnitude only. Default is []. Function still needs two inputs but will ignore the second\n",
+    "    'save_gfactor_map': 1,              # 1 saves the realtive gfactor, 2 saves the gfactor and does not complete the NORDIC processing\n",
+    "    'save_add_info': 1,                 # save additional information, including the number of components removed\n",
+    "    'save_residual_matlab': 1,          # saves the NORDIC residuals\n",
+    "}\n",
+    "\n",
+    "#saves mat in the given directory\n",
+    "mat_file_opt = 'ARG_nordic.mat'\n",
+    "savemat(mat_file_opt, {'ARG': arg_struct}) #needs to be called ARG for it to work in the NIFTI_NORDIC_nipype matlab script\n",
+    "\n",
+    "cwd = os.getcwd()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "151d0654-c1df-4685-8b6b-4bf4e2f7fd53",
+   "metadata": {},
+   "source": [
+    "### Create Nipype Node with NIFTI_NORDIC Interface"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "72447180-6f41-4753-b925-b0b914b6e0ec",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Define paths to files and other input arguments\n",
+    "fn_phase_in = fn_magn_in #we chose magnitude only; the function will still need two inputs, but will ignore the second\n",
+    "fn_out = '_NORDIC'\n",
+    "nifti_nordic_script_path = scripts_dir #path where NIFTI_NORDIC_nipype.mat is stored\n",
+    "#ARG = os.path.join(cwd, mat_file_opt)\n",
+    "\n",
+    "# Create the node\n",
+    "nifti_nordic_node = Node(NiftiNordic(), name='nifti_nordic')\n",
+    "\n",
+    "# Set the input values\n",
+    "nifti_nordic_node.inputs.fn_magn_in = fn_magn_in\n",
+    "nifti_nordic_node.inputs.fn_phase_in = fn_phase_in\n",
+    "nifti_nordic_node.inputs.fn_out = fn_out\n",
+    "nifti_nordic_node.inputs.additional_path = nifti_nordic_script_path #needs this to add it to the matlab paths\n",
+    "#nifti_nordic_node.inputs.ARG = ARG #input is not mandatory"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0db786a5-68cb-44fe-bbfa-4e3d75e440a8",
+   "metadata": {},
+   "source": [
+    "### Motion Correciton after Nordic"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "fbae6946-c0f8-4c11-8707-f5b0b627887d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Motion correction AFNI 3dvolreg------------------------------------------------------------------------------\n",
+    "volreg_nordic = Node(afni.Volreg(interp='Fourier', outputtype = 'NIFTI_GZ'), \n",
+    "                 name='volreg_nordic')\n",
+    "\n",
+    "workflow.connect(nifti_nordic_node, 'output_file', volreg_nordic, 'in_file')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ada57438-d076-4478-b0f0-b3dab71f6fda",
+   "metadata": {},
+   "source": [
+    "### Mask functional data (raw and after nordic)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "8c4c6408-336d-4632-850e-59dcfab358c2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "masker_raw = Node(ApplyMask(), name='masker_raw')\n",
+    "workflow.connect(volreg_raw, 'out_file', masker_raw, 'in_file')\n",
+    "workflow.connect(get_fmri_mask, 'mask_file', masker_raw, 'mask_file')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "1bedc459-112f-4a58-b7a3-2442c75d7729",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "masker_nordic = Node(ApplyMask(), name='masker_nordic')\n",
+    "workflow.connect(volreg_nordic, 'out_file', masker_nordic, 'in_file')\n",
+    "workflow.connect(get_fmri_mask, 'mask_file', masker_nordic, 'mask_file')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9d41b751-bac8-47b1-8090-742a1a1950a6",
+   "metadata": {},
+   "source": [
+    "### Node to compute TSNR\n",
+    "Computes the time-course SNR for a time series\n",
+    "\n",
+    "Typically you want to run this on a realigned time-series - in this case, it is not realigned yet."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "90303945-ee19-480e-97ac-b34ad05f4a60",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tsnr_nordic = Node(TSNR(), name='compute_tsnr_nordic')\n",
+    "workflow.connect(masker_nordic, 'out_file', tsnr_nordic,'in_file')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "389020b3-9c80-4f9b-acd4-f3a3d07b46ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tsnr_raw = Node(TSNR(), name='compute_tsnr_raw')\n",
+    "workflow.connect(masker_raw, 'out_file', tsnr_raw,'in_file')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9e589194-ec72-4586-b510-d59d13ad4b7a",
+   "metadata": {},
+   "source": [
+    "#### Plot TSNR"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "bff338c1-9ae0-4651-a7ff-16733b2599f9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_tsnr(data_path, base_name):\n",
+    "    import numpy as np\n",
+    "    import nibabel as nib\n",
+    "    import matplotlib as mpl\n",
+    "    import matplotlib.pyplot as plt\n",
+    "    import os\n",
+    "    \n",
+    "    data = nib.load(data_path).get_fdata()\n",
+    "\n",
+    "    x = data.shape[0] // 2\n",
+    "    y = data.shape[1] // 2\n",
+    "    z = data.shape[2] // 2\n",
+    "\n",
+    "    fig, axes = plt.subplots(2, 2) #, gridspec_kw={'width_ratios': [1, 1], 'height_ratios': [1, 0.1]})\n",
+    "\n",
+    "    ax = axes[0, 0]\n",
+    "    im = ax.imshow(data[:, :, z], cmap=mpl.cm.hot,vmax=40)\n",
+    "    ax.set_title(f'Axial Slice at z={z}')\n",
+    "\n",
+    "    ax = axes[0, 1]\n",
+    "    im = ax.imshow(np.rot90(data[:, y, :]), cmap=mpl.cm.hot,vmax=40)\n",
+    "    ax.set_title(f'Coronal Slice at y={y}')\n",
+    "\n",
+    "    ax = axes[1, 0]\n",
+    "    im = ax.imshow(np.rot90(data[x, :, :]), cmap=mpl.cm.hot, vmax=40)\n",
+    "    ax.set_title(f'Sagittal Slice at x={x}')\n",
+    "\n",
+    "    # Remove the unused subplot\n",
+    "    fig.delaxes(axes[1, 1])\n",
+    "\n",
+    "    cbar_ax = fig.add_axes([0.95, 0.15, 0.02, 0.7])  # [x, y, width, height]\n",
+    "    fig.colorbar(im, cax=cbar_ax)\n",
+    "\n",
+    "    fig.set_size_inches(9, 9) #8,8\n",
+    "    #mean_tsnr = np.mean(data[data>0])\n",
+    "    global_tsnr = np.median(data[data > 0])\n",
+    "    \n",
+    "\n",
+    "    if base_name.endswith('.gz'):\n",
+    "        basename = os.path.basename(base_name)[0:-7]\n",
+    "    elif base_name.endswith('.nii'):\n",
+    "        basename = os.path.basename(base_name)[0:-4]\n",
+    "    title = 'Global TSNR of  ' + basename + ': ' + str(int(global_tsnr))\n",
+    "    fig.suptitle(title, fontsize=12) \n",
+    "    \n",
+    "    path_mapflow, _ = os.path.split(os.getcwd())\n",
+    "    path_node, _ = os.path.split(path_mapflow)\n",
+    "    \n",
+    "    plt.savefig(path_node +'/'+ basename) \n",
+    "\n",
+    "#tsrn of denoised data\n",
+    "tsnr_plot_nordic = Node(Function(input_names=['data_path', 'base_name'], \n",
+    "                                function=plot_tsnr),\n",
+    "                                name='plot_tsnr_nordic')\n",
+    "\n",
+    "workflow.connect(tsnr_nordic, 'tsnr_file', tsnr_plot_nordic, 'data_path')\n",
+    "workflow.connect(volreg_nordic, 'out_file', tsnr_plot_nordic, 'base_name')\n",
+    "\n",
+    "\n",
+    "#tsrn of raw data\n",
+    "tsnr_plot_raw = Node(Function(input_names=['data_path', 'base_name'],\n",
+    "                                function=plot_tsnr),\n",
+    "                                name='plot_tsnr_raw')\n",
+    "\n",
+    "workflow.connect(tsnr_raw, 'tsnr_file', tsnr_plot_raw, 'data_path')\n",
+    "workflow.connect(volreg_raw, 'out_file', tsnr_plot_raw, 'base_name')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8faa6ef4-00ee-4e3e-becb-e3bd8c6771e5",
+   "metadata": {},
+   "source": [
+    "### Datasink Node"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "22f412a8-d5d8-4c32-a552-ef97bbf01b00",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# Create a DataSink node to save the output to a specified location\n",
+    "datasink = Node(DataSink(base_directory=os.path.join(experiment_dir, 'workflow_nordic')),\n",
+    "               name='datasink')\n",
+    "\n",
+    "\n",
+    "# Connect desired outputs to datasink\n",
+    "#nordic\n",
+    "workflow.connect(nifti_nordic_node, 'output_file', datasink, 'nordic_output') \n",
+    "workflow.connect(nifti_nordic_node, 'add_info_file', datasink, 'nordic_output.@info_file')\n",
+    "workflow.connect(nifti_nordic_node, 'gfactor_map_file', datasink, 'nordic_output.@gfactor')\n",
+    "workflow.connect(nifti_nordic_node, 'residual_mat_file', datasink, 'nordic_output.@residual')\n",
+    "\n",
+    "#tsnr\n",
+    "workflow.connect(tsnr_nordic, 'tsnr_file', datasink, 'tsnr_output.@tsnr_nordic')\n",
+    "workflow.connect(tsnr_raw, 'tsnr_file', datasink, 'tsnr_output.@tsnr_raw')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "7105331e-604d-4b1d-bbf7-1cee7accba63",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "240830-12:23:52,325 nipype.workflow INFO:\n",
+      "\t Generated workflow graph: /mnt/neurodesktop-storage/Clean_notebooks/NORDIC_output/workflow_nordic/graph.png (graph2use=colored, simple_form=True).\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Create output graph\n",
+    "workflow.write_graph(graph2use='colored', format='png', simple_form=True)\n",
+    "\n",
+    "# Visualize the graph\n",
+    "from IPython.display import Image\n",
+    "Image(filename=os.path.join(workflow.base_dir, workflow.name, 'graph.png'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "3b142b7c-4266-4549-8118-dcb6d889da89",
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "240830-12:23:56,451 nipype.workflow INFO:\n",
+      "\t Generated workflow graph: /mnt/neurodesktop-storage/Clean_notebooks/NORDIC_output/workflow_nordic/graph.png (graph2use=flat, simple_form=True).\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "workflow.write_graph(graph2use='flat', format='png', simple_form=True)\n",
+    "\n",
+    "Image(filename=os.path.join(workflow.base_dir, workflow.name, 'graph_detailed.png'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "97d968da-be73-410d-a2e8-0d2646c89a3f",
+   "metadata": {
+    "editable": true,
+    "scrolled": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "240830-12:23:56,523 nipype.workflow INFO:\n",
+      "\t Workflow workflow_nordic settings: ['check', 'execution', 'logging', 'monitoring']\n",
+      "240830-12:23:56,530 nipype.workflow INFO:\n",
+      "\t Running in parallel.\n",
+      "240830-12:23:56,533 nipype.workflow INFO:\n",
+      "\t [MultiProc] Running 0 tasks, and 3 jobs ready. Free memory (GB): 219.48/219.48, Free processors: 16/16.\n",
+      "240830-12:23:56,592 nipype.workflow INFO:\n",
+      "\t [Job 0] Cached (workflow_nordic.bet).\n",
+      "240830-12:23:56,594 nipype.workflow INFO:\n",
+      "\t [Job 1] Cached (workflow_nordic.volreg_raw).\n",
+      "240830-12:23:56,697 nipype.workflow INFO:\n",
+      "\t [Node] Setting-up \"workflow_nordic.nifti_nordic\" in \"/mnt/neurodesktop-storage/Clean_notebooks/NORDIC_output/workflow_nordic/nifti_nordic\".\n",
+      "240830-12:23:56,706 nipype.workflow INFO:\n",
+      "\t [Node] Executing \"nifti_nordic\" <NIFTI_NORDIC_interface_default.NiftiNordic>\n",
+      "240830-12:23:56,815 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:23:56.815783:MLM_LICENSE_FILE=/home/jovyan/Downloads\n",
+      "240830-12:23:57,447 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:23:57.447240:MATLAB is selecting SOFTWARE OPENGL rendering.\n",
+      "240830-12:23:58,535 nipype.workflow INFO:\n",
+      "\t [MultiProc] Running 1 tasks, and 1 jobs ready. Free memory (GB): 219.28/219.48, Free processors: 15/16.\n",
+      "                     Currently running:\n",
+      "                       * workflow_nordic.nifti_nordic\n",
+      "240830-12:23:58,669 nipype.workflow INFO:\n",
+      "\t [Job 3] Cached (workflow_nordic.resample_mask).\n",
+      "240830-12:24:00,611 nipype.workflow INFO:\n",
+      "\t [Job 5] Cached (workflow_nordic.masker_raw).\n",
+      "240830-12:24:02,603 nipype.workflow INFO:\n",
+      "\t [Job 7] Cached (workflow_nordic.compute_tsnr_raw).\n",
+      "240830-12:24:02,858 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:24:02.858003:\n",
+      "240830-12:24:02,860 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:24:02.858003:                            < M A T L A B (R) >\n",
+      "240830-12:24:02,868 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:24:02.858003:                  Copyright 1984-2022 The MathWorks, Inc.\n",
+      "240830-12:24:02,869 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:24:02.858003:             R2022a Update 7 (9.12.0.2327980) 64-bit (glnxa64)\n",
+      "240830-12:24:02,870 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:24:02.858003:                               July 13, 2023\n",
+      "240830-12:24:02,871 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:24:02.858003:\n",
+      "240830-12:24:03,629 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:24:03.629879: \n",
+      "240830-12:24:03,639 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:24:03.639134:To get started, type doc.\n",
+      "240830-12:24:03,640 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:24:03.640266:For product information, visit www.mathworks.com.\n",
+      "240830-12:24:03,641 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:24:03.640266: \n",
+      "240830-12:24:04,635 nipype.workflow INFO:\n",
+      "\t [Job 9] Cached (workflow_nordic.plot_tsnr_raw).\n",
+      "240830-12:24:06,533 nipype.workflow INFO:\n",
+      "\t [MultiProc] Running 1 tasks, and 0 jobs ready. Free memory (GB): 219.28/219.48, Free processors: 15/16.\n",
+      "                     Currently running:\n",
+      "                       * workflow_nordic.nifti_nordic\n",
+      "240830-12:24:11,174 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:24:11.174732:Phase should be -pi to pi...\n",
+      "240830-12:24:12,748 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:24:12.748198:Phase data range is -3.14 to 3.14\n",
+      "240830-12:24:13,974 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:24:13.974397:estimating slice-dependent phases ...\n",
+      "240830-12:24:32,101 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:24:32.101867:Completed estimating slice-dependent phases ...\n",
+      "240830-12:24:33,642 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:24:33.642871:estimating g-factor ...\n",
+      "240830-12:25:37,49 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:37.049247:completed estimating g-factor\n",
+      "240830-12:25:43,394 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:\n",
+      "240830-12:25:43,404 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:ARG = \n",
+      "240830-12:25:43,406 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:\n",
+      "240830-12:25:43,407 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:  struct with fields:\n",
+      "240830-12:25:43,414 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:\n",
+      "240830-12:25:43,415 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                                      DIROUT: '/mnt/neurodesktop-storage/Clean_notebooks/NORDIC_output/workflow_nordic/nifti_nordic/'\n",
+      "240830-12:25:43,416 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                           noise_volume_last: 0\n",
+      "240830-12:25:43,423 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                                factor_error: 1\n",
+      "240830-12:25:43,435 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                          full_dynamic_range: 0\n",
+      "240830-12:25:43,442 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                              temporal_phase: 1\n",
+      "240830-12:25:43,458 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                                      NORDIC: 1\n",
+      "240830-12:25:43,459 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                                          MP: 0\n",
+      "240830-12:25:43,460 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                          phase_filter_width: 3\n",
+      "240830-12:25:43,473 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                        NORDIC_patch_overlap: 2\n",
+      "240830-12:25:43,477 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                       gfactor_patch_overlap: 2\n",
+      "240830-12:25:43,478 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                         kernel_size_gfactor: []\n",
+      "240830-12:25:43,483 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                             kernel_size_PCA: []\n",
+      "240830-12:25:43,487 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:    phase_slice_average_for_kspace_centering: 0\n",
+      "240830-12:25:43,488 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                              magnitude_only: 0\n",
+      "240830-12:25:43,489 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                            save_gfactor_map: []\n",
+      "240830-12:25:43,490 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                        use_generic_NII_read: 0\n",
+      "240830-12:25:43,498 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                      data_has_zero_elements: 0\n",
+      "240830-12:25:43,499 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                              ABSOLUTE_SCALE: 2\n",
+      "240830-12:25:43,499 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                                 kernel_size: [14 14 1]\n",
+      "240830-12:25:43,501 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                               patch_average: 0\n",
+      "240830-12:25:43,502 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                           patch_average_sub: 2\n",
+      "240830-12:25:43,503 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                                   LLR_scale: 0\n",
+      "240830-12:25:43,504 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                               NVR_threshold: 1\n",
+      "240830-12:25:43,505 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                                   soft_thrs: 10\n",
+      "240830-12:25:43,506 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                                       NOISE: [96x96x54 single]\n",
+      "240830-12:25:43,506 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                         Component_threshold: [96x96x54 single]\n",
+      "240830-12:25:43,507 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                              energy_removed: [96x96x54 single]\n",
+      "240830-12:25:43,508 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                                  SNR_weight: [96x96x54 single]\n",
+      "240830-12:25:43,509 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:                              measured_noise: 0.7071\n",
+      "240830-12:25:43,517 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:43.394276:\n",
+      "240830-12:25:51,759 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:25:51.759685:starting NORDIC ...\n",
+      "240830-12:27:19,719 nipype.interface INFO:\n",
+      "\t stdout 2024-08-30T12:27:19.719756:completing NORDIC ...\n",
+      "240830-12:27:33,599 nipype.workflow INFO:\n",
+      "\t [Node] Finished \"nifti_nordic\", elapsed time 216.890259s.\n",
+      "240830-12:27:34,584 nipype.workflow INFO:\n",
+      "\t [Job 2] Completed (workflow_nordic.nifti_nordic).\n",
+      "240830-12:27:34,593 nipype.workflow INFO:\n",
+      "\t [MultiProc] Running 0 tasks, and 1 jobs ready. Free memory (GB): 219.48/219.48, Free processors: 16/16.\n",
+      "240830-12:27:34,665 nipype.workflow INFO:\n",
+      "\t [Node] Setting-up \"workflow_nordic.volreg_nordic\" in \"/mnt/neurodesktop-storage/Clean_notebooks/NORDIC_output/workflow_nordic/volreg_nordic\".\n",
+      "240830-12:27:34,693 nipype.workflow INFO:\n",
+      "\t [Node] Executing \"volreg_nordic\" <nipype.interfaces.afni.preprocess.Volreg>\n",
+      "240830-12:27:36,584 nipype.workflow INFO:\n",
+      "\t [MultiProc] Running 1 tasks, and 0 jobs ready. Free memory (GB): 219.28/219.48, Free processors: 15/16.\n",
+      "                     Currently running:\n",
+      "                       * workflow_nordic.volreg_nordic\n",
+      "240830-12:28:23,487 nipype.workflow INFO:\n",
+      "\t [Node] Finished \"volreg_nordic\", elapsed time 48.781363999999996s.\n",
+      "240830-12:28:24,588 nipype.workflow INFO:\n",
+      "\t [Job 4] Completed (workflow_nordic.volreg_nordic).\n",
+      "240830-12:28:24,590 nipype.workflow INFO:\n",
+      "\t [MultiProc] Running 0 tasks, and 1 jobs ready. Free memory (GB): 219.48/219.48, Free processors: 16/16.\n",
+      "240830-12:28:24,666 nipype.workflow INFO:\n",
+      "\t [Node] Setting-up \"workflow_nordic.masker_nordic\" in \"/mnt/neurodesktop-storage/Clean_notebooks/NORDIC_output/workflow_nordic/masker_nordic\".\n",
+      "240830-12:28:24,678 nipype.workflow INFO:\n",
+      "\t [Node] Executing \"masker_nordic\" <nipype.interfaces.fsl.maths.ApplyMask>\n",
+      "240830-12:28:26,588 nipype.workflow INFO:\n",
+      "\t [MultiProc] Running 1 tasks, and 0 jobs ready. Free memory (GB): 219.28/219.48, Free processors: 15/16.\n",
+      "                     Currently running:\n",
+      "                       * workflow_nordic.masker_nordic\n",
+      "240830-12:28:42,415 nipype.workflow INFO:\n",
+      "\t [Node] Finished \"masker_nordic\", elapsed time 17.734653s.\n",
+      "240830-12:28:42,589 nipype.workflow INFO:\n",
+      "\t [Job 6] Completed (workflow_nordic.masker_nordic).\n",
+      "240830-12:28:42,591 nipype.workflow INFO:\n",
+      "\t [MultiProc] Running 0 tasks, and 1 jobs ready. Free memory (GB): 219.48/219.48, Free processors: 16/16.\n",
+      "240830-12:28:42,653 nipype.workflow INFO:\n",
+      "\t [Node] Setting-up \"workflow_nordic.compute_tsnr_nordic\" in \"/mnt/neurodesktop-storage/Clean_notebooks/NORDIC_output/workflow_nordic/compute_tsnr_nordic\".\n",
+      "240830-12:28:42,666 nipype.workflow INFO:\n",
+      "\t [Node] Executing \"compute_tsnr_nordic\" <nipype.algorithms.confounds.TSNR>\n",
+      "240830-12:28:44,594 nipype.workflow INFO:\n",
+      "\t [MultiProc] Running 1 tasks, and 0 jobs ready. Free memory (GB): 219.28/219.48, Free processors: 15/16.\n",
+      "                     Currently running:\n",
+      "                       * workflow_nordic.compute_tsnr_nordic\n",
+      "240830-12:28:47,899 nipype.workflow INFO:\n",
+      "\t [Node] Finished \"compute_tsnr_nordic\", elapsed time 5.230113s.\n",
+      "240830-12:28:48,590 nipype.workflow INFO:\n",
+      "\t [Job 8] Completed (workflow_nordic.compute_tsnr_nordic).\n",
+      "240830-12:28:48,593 nipype.workflow INFO:\n",
+      "\t [MultiProc] Running 0 tasks, and 2 jobs ready. Free memory (GB): 219.48/219.48, Free processors: 16/16.\n",
+      "240830-12:28:48,680 nipype.workflow INFO:\n",
+      "\t [Node] Setting-up \"workflow_nordic.plot_tsnr_nordic\" in \"/mnt/neurodesktop-storage/Clean_notebooks/NORDIC_output/workflow_nordic/plot_tsnr_nordic\".\n",
+      "240830-12:28:48,681 nipype.workflow INFO:\n",
+      "\t [Node] Setting-up \"workflow_nordic.datasink\" in \"/mnt/neurodesktop-storage/Clean_notebooks/NORDIC_output/workflow_nordic/datasink\".\n",
+      "240830-12:28:48,716 nipype.workflow INFO:\n",
+      "\t [Node] Executing \"plot_tsnr_nordic\" <nipype.interfaces.utility.wrappers.Function>\n",
+      "240830-12:28:48,716 nipype.workflow INFO:\n",
+      "\t [Node] Executing \"datasink\" <nipype.interfaces.io.DataSink>\n",
+      "240830-12:28:48,729 nipype.workflow INFO:\n",
+      "\t [Node] Finished \"datasink\", elapsed time 0.009333s.\n",
+      "240830-12:28:49,667 nipype.workflow INFO:\n",
+      "\t [Node] Finished \"plot_tsnr_nordic\", elapsed time 0.948466s.\n",
+      "240830-12:28:50,590 nipype.workflow INFO:\n",
+      "\t [Job 10] Completed (workflow_nordic.plot_tsnr_nordic).\n",
+      "240830-12:28:50,592 nipype.workflow INFO:\n",
+      "\t [Job 11] Completed (workflow_nordic.datasink).\n",
+      "240830-12:28:50,593 nipype.workflow INFO:\n",
+      "\t [MultiProc] Running 0 tasks, and 0 jobs ready. Free memory (GB): 219.48/219.48, Free processors: 16/16.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<networkx.classes.digraph.DiGraph at 0x7f4a0107bb50>"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Run the workflow\n",
+    "workflow.run('MultiProc', plugin_args={'n_procs':16})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9c5f353b-e3db-4c97-b9fa-ea6bfc4ef62b",
+   "metadata": {
+    "editable": true,
+    "slideshow": {
+     "slide_type": ""
+    },
+    "tags": []
+   },
+   "source": [
+    "### Check output"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "c73c7d04-a5c0-458e-bb92-20e7f227cb24",
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[01;34m.\u001b[0m\n",
+      "├── \u001b[00msub-001_ses-01_task-HalfFovNoTask_run-003_bold_NORDIC_volreg.png\u001b[0m\n",
+      "├── \u001b[00msub-001_ses-01_task-HalfFovNoTask_run-003_bold_volreg.png\u001b[0m\n",
+      "└── \u001b[01;34mworkflow_nordic\u001b[0m\n",
+      "    ├── \u001b[01;34mbet\u001b[0m\n",
+      "    │   ├── \u001b[00m_0x47b34e7fc549b5e85aadbc455931da5c.json\u001b[0m\n",
+      "    │   ├── \u001b[00m_inputs.pklz\u001b[0m\n",
+      "    │   ├── \u001b[00m_node.pklz\u001b[0m\n",
+      "    │   ├── \u001b[01;34m_report\u001b[0m\n",
+      "    │   │   └── \u001b[00mreport.rst\u001b[0m\n",
+      "    │   ├── \u001b[00mcommand.txt\u001b[0m\n",
+      "    │   ├── \u001b[00mresult_bet.pklz\u001b[0m\n",
+      "    │   └── \u001b[01;31msub-001_ses-01_acq-MPRAGE_run-001_T1w_brain_mask.nii.gz\u001b[0m\n",
+      "    ├── \u001b[01;34mcompute_tsnr_nordic\u001b[0m\n",
+      "    │   ├── \u001b[00m_0x60d619be6978d68f8536c766ac16ea63.json\u001b[0m\n",
+      "    │   ├── \u001b[00m_inputs.pklz\u001b[0m\n",
+      "    │   ├── \u001b[00m_node.pklz\u001b[0m\n",
+      "    │   ├── \u001b[01;34m_report\u001b[0m\n",
+      "    │   │   └── \u001b[00mreport.rst\u001b[0m\n",
+      "    │   ├── \u001b[00mresult_compute_tsnr_nordic.pklz\u001b[0m\n",
+      "    │   └── \u001b[01;31mtsnr.nii.gz\u001b[0m\n",
+      "    ├── \u001b[01;34mcompute_tsnr_raw\u001b[0m\n",
+      "    │   ├── \u001b[00m_0x047af29184614900805e81efbd1e6f03.json\u001b[0m\n",
+      "    │   ├── \u001b[00m_inputs.pklz\u001b[0m\n",
+      "    │   ├── \u001b[00m_node.pklz\u001b[0m\n",
+      "    │   ├── \u001b[01;34m_report\u001b[0m\n",
+      "    │   │   └── \u001b[00mreport.rst\u001b[0m\n",
+      "    │   ├── \u001b[00mresult_compute_tsnr_raw.pklz\u001b[0m\n",
+      "    │   └── \u001b[01;31mtsnr.nii.gz\u001b[0m\n",
+      "    ├── \u001b[00md3.js\u001b[0m\n",
+      "    ├── \u001b[01;34mdatasink\u001b[0m\n",
+      "    │   ├── \u001b[00m_0x4aa87808415387063234b6bdc4295c09.json\u001b[0m\n",
+      "    │   ├── \u001b[00m_inputs.pklz\u001b[0m\n",
+      "    │   ├── \u001b[00m_node.pklz\u001b[0m\n",
+      "    │   ├── \u001b[01;34m_report\u001b[0m\n",
+      "    │   │   └── \u001b[00mreport.rst\u001b[0m\n",
+      "    │   └── \u001b[00mresult_datasink.pklz\u001b[0m\n",
+      "    ├── \u001b[00mgraph.dot\u001b[0m\n",
+      "    ├── \u001b[00mgraph.json\u001b[0m\n",
+      "    ├── \u001b[00mgraph.png\u001b[0m\n",
+      "    ├── \u001b[00mgraph1.json\u001b[0m\n",
+      "    ├── \u001b[00mgraph_detailed.dot\u001b[0m\n",
+      "    ├── \u001b[00mgraph_detailed.png\u001b[0m\n",
+      "    ├── \u001b[00mindex.html\u001b[0m\n",
+      "    ├── \u001b[01;34mmasker_nordic\u001b[0m\n",
+      "    │   ├── \u001b[00m_0xbeb77d21005a442a7278446dd6ffc9cf.json\u001b[0m\n",
+      "    │   ├── \u001b[00m_inputs.pklz\u001b[0m\n",
+      "    │   ├── \u001b[00m_node.pklz\u001b[0m\n",
+      "    │   ├── \u001b[01;34m_report\u001b[0m\n",
+      "    │   │   └── \u001b[00mreport.rst\u001b[0m\n",
+      "    │   ├── \u001b[00mcommand.txt\u001b[0m\n",
+      "    │   ├── \u001b[00mresult_masker_nordic.pklz\u001b[0m\n",
+      "    │   └── \u001b[01;31msub-001_ses-01_task-HalfFovNoTask_run-003_bold_NORDIC_volreg_masked.nii.gz\u001b[0m\n",
+      "    ├── \u001b[01;34mmasker_raw\u001b[0m\n",
+      "    │   ├── \u001b[00m_0x8d4a173240d4ea85fe78ddf45e594e72.json\u001b[0m\n",
+      "    │   ├── \u001b[00m_inputs.pklz\u001b[0m\n",
+      "    │   ├── \u001b[00m_node.pklz\u001b[0m\n",
+      "    │   ├── \u001b[01;34m_report\u001b[0m\n",
+      "    │   │   └── \u001b[00mreport.rst\u001b[0m\n",
+      "    │   ├── \u001b[00mcommand.txt\u001b[0m\n",
+      "    │   ├── \u001b[00mresult_masker_raw.pklz\u001b[0m\n",
+      "    │   └── \u001b[01;31msub-001_ses-01_task-HalfFovNoTask_run-003_bold_volreg_masked.nii.gz\u001b[0m\n",
+      "    ├── \u001b[01;34mnifti_nordic\u001b[0m\n",
+      "    │   ├── \u001b[00m_0xb636df3c2c302361143015485f01ef0e.json\u001b[0m\n",
+      "    │   ├── \u001b[00m_inputs.pklz\u001b[0m\n",
+      "    │   ├── \u001b[00m_node.pklz\u001b[0m\n",
+      "    │   ├── \u001b[01;34m_report\u001b[0m\n",
+      "    │   │   └── \u001b[00mreport.rst\u001b[0m\n",
+      "    │   ├── \u001b[00mresult_nifti_nordic.pklz\u001b[0m\n",
+      "    │   └── \u001b[00msub-001_ses-01_task-HalfFovNoTask_run-003_bold_NORDIC.nii\u001b[0m\n",
+      "    ├── \u001b[01;34mnordic_output\u001b[0m\n",
+      "    │   └── \u001b[00msub-001_ses-01_task-HalfFovNoTask_run-003_bold_NORDIC.nii\u001b[0m\n",
+      "    ├── \u001b[01;34mplot_tsnr_nordic\u001b[0m\n",
+      "    │   ├── \u001b[00m_0x322c94a82b90bedd43b4335d5beb2a52.json\u001b[0m\n",
+      "    │   ├── \u001b[00m_inputs.pklz\u001b[0m\n",
+      "    │   ├── \u001b[00m_node.pklz\u001b[0m\n",
+      "    │   ├── \u001b[01;34m_report\u001b[0m\n",
+      "    │   │   └── \u001b[00mreport.rst\u001b[0m\n",
+      "    │   └── \u001b[00mresult_plot_tsnr_nordic.pklz\u001b[0m\n",
+      "    ├── \u001b[01;34mplot_tsnr_raw\u001b[0m\n",
+      "    │   ├── \u001b[00m_0xf47c961c77d29bb46684135b631121ac.json\u001b[0m\n",
+      "    │   ├── \u001b[00m_inputs.pklz\u001b[0m\n",
+      "    │   ├── \u001b[00m_node.pklz\u001b[0m\n",
+      "    │   ├── \u001b[01;34m_report\u001b[0m\n",
+      "    │   │   └── \u001b[00mreport.rst\u001b[0m\n",
+      "    │   └── \u001b[00mresult_plot_tsnr_raw.pklz\u001b[0m\n",
+      "    ├── \u001b[01;34mresample_mask\u001b[0m\n",
+      "    │   ├── \u001b[00m_0x9dc84b6eb6fecb3c381063f9b88faf3c.json\u001b[0m\n",
+      "    │   ├── \u001b[00m_inputs.pklz\u001b[0m\n",
+      "    │   ├── \u001b[00m_node.pklz\u001b[0m\n",
+      "    │   ├── \u001b[01;34m_report\u001b[0m\n",
+      "    │   │   └── \u001b[00mreport.rst\u001b[0m\n",
+      "    │   ├── \u001b[00mresult_resample_mask.pklz\u001b[0m\n",
+      "    │   └── \u001b[01;31msub-001_ses-01_task-HalfFovNoTask_run-003_bold_volreg_func_mask.nii.gz\u001b[0m\n",
+      "    ├── \u001b[01;34mtsnr_output\u001b[0m\n",
+      "    │   └── \u001b[01;31mtsnr.nii.gz\u001b[0m\n",
+      "    ├── \u001b[01;34mvolreg_nordic\u001b[0m\n",
+      "    │   ├── \u001b[00m_0xde73c6db59b47755c292ba51961ff776.json\u001b[0m\n",
+      "    │   ├── \u001b[00m_inputs.pklz\u001b[0m\n",
+      "    │   ├── \u001b[00m_node.pklz\u001b[0m\n",
+      "    │   ├── \u001b[01;34m_report\u001b[0m\n",
+      "    │   │   └── \u001b[00mreport.rst\u001b[0m\n",
+      "    │   ├── \u001b[00mcommand.txt\u001b[0m\n",
+      "    │   ├── \u001b[00mresult_volreg_nordic.pklz\u001b[0m\n",
+      "    │   └── \u001b[01;31msub-001_ses-01_task-HalfFovNoTask_run-003_bold_NORDIC_volreg.nii.gz\u001b[0m\n",
+      "    └── \u001b[01;34mvolreg_raw\u001b[0m\n",
+      "        ├── \u001b[00m_0x1daf28854357d3106f3fae80da54a33a.json\u001b[0m\n",
+      "        ├── \u001b[00m_inputs.pklz\u001b[0m\n",
+      "        ├── \u001b[00m_node.pklz\u001b[0m\n",
+      "        ├── \u001b[01;34m_report\u001b[0m\n",
+      "        │   └── \u001b[00mreport.rst\u001b[0m\n",
+      "        ├── \u001b[00mcommand.txt\u001b[0m\n",
+      "        ├── \u001b[00mresult_volreg_raw.pklz\u001b[0m\n",
+      "        └── \u001b[01;31msub-001_ses-01_task-HalfFovNoTask_run-003_bold_volreg.nii.gz\u001b[0m\n",
+      "\n",
+      "27 directories, 86 files\n"
+     ]
+    }
+   ],
+   "source": [
+    "!cd NORDIC_output && tree -L 4"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "867eac63-0abc-405a-a142-ed5c27dc9db8",
+   "metadata": {},
+   "source": [
+    "### Plot TSNR maps and the global TSNR (median) to check the effect of NORDIC"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "1212d2a9-d788-48ae-bef7-4f123afe7c5d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tsnr_img_nordic = os.path.join(experiment_dir, 'sub-001_ses-01_task-HalfFovNoTask_run-003_bold_NORDIC_volreg.png')\n",
+    "tsnr_img_raw = os.path.join(experiment_dir, 'sub-001_ses-01_task-HalfFovNoTask_run-003_bold_volreg.png')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "3376df7d-5984-4e6b-a316-e3a7fff3efb1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import Image\n",
+    "Image(filename=tsnr_img_nordic)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "77c5312b-24f4-4262-90c4-4bb1fbc5a457",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<IPython.core.display.Image object>"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Display a local image\n",
+    "Image(filename=tsnr_img_raw)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.11.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 85dad4b3a592ec33df871c5311cec33ab38843ef Mon Sep 17 00:00:00 2001
From: Moni Doerig <82578141+MoniDoerig@users.noreply.github.com>
Date: Fri, 30 Aug 2024 16:48:25 +0200
Subject: [PATCH 04/13] corrected sys path

---
 example_usage_NORDIC_nipype.ipynb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/example_usage_NORDIC_nipype.ipynb b/example_usage_NORDIC_nipype.ipynb
index b4bf839..b67c88c 100644
--- a/example_usage_NORDIC_nipype.ipynb
+++ b/example_usage_NORDIC_nipype.ipynb
@@ -203,8 +203,8 @@
    },
    "outputs": [],
    "source": [
-    "# Add the scripts directory to sys.path (NIFIT_NORDIC_nipype.m and NIFTI_NORDIC_NIPYPE.py)\n",
-    "scripts_dir = os.path.abspath(os.path.join('.', 'interfaces'))\n",
+    "# Add the scripts directory to sys.path (NIFIT_NORDIC_nipype.m and NIFTI_NORDIC_intreface.py)\n",
+    "scripts_dir = os.path.abspath(('.')) #adapt as needed\n",
     "\n",
     "if scripts_dir not in sys.path:\n",
     "    sys.path.append(scripts_dir)"

From dfa46ef8953b646a41961d7981fdc769c8c6fa6d Mon Sep 17 00:00:00 2001
From: Moni Doerig <82578141+MoniDoerig@users.noreply.github.com>
Date: Fri, 30 Aug 2024 16:50:56 +0200
Subject: [PATCH 05/13] adapted class name

---
 example_usage_NORDIC_nipype.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/example_usage_NORDIC_nipype.ipynb b/example_usage_NORDIC_nipype.ipynb
index b67c88c..850dbf3 100644
--- a/example_usage_NORDIC_nipype.ipynb
+++ b/example_usage_NORDIC_nipype.ipynb
@@ -224,7 +224,7 @@
    "outputs": [],
    "source": [
     "#import NiftiNordic class to wrap matlab script\n",
-    "from NIFTI_NORDIC_interface_default import NiftiNordic"
+    "from NIFTI_NORDIC_interface import NiftiNordic"
    ]
   },
   {

From e3fa749b70370d16fa2ef2c0c6d1fa187154f6c5 Mon Sep 17 00:00:00 2001
From: Moni Doerig <82578141+MoniDoerig@users.noreply.github.com>
Date: Fri, 30 Aug 2024 16:51:26 +0200
Subject: [PATCH 06/13] Rename NIFTI_NORDIC.m to NIFTI_NORDIC_nipype.m

---
 NIFTI_NORDIC.m => NIFTI_NORDIC_nipype.m | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename NIFTI_NORDIC.m => NIFTI_NORDIC_nipype.m (100%)

diff --git a/NIFTI_NORDIC.m b/NIFTI_NORDIC_nipype.m
similarity index 100%
rename from NIFTI_NORDIC.m
rename to NIFTI_NORDIC_nipype.m

From 8046bae954321d374d9f5593fc995546817b4b04 Mon Sep 17 00:00:00 2001
From: Moni Doerig <82578141+MoniDoerig@users.noreply.github.com>
Date: Mon, 2 Sep 2024 09:45:16 +0200
Subject: [PATCH 07/13] Update NIFTI_NORDIC_interface.py

---
 NIFTI_NORDIC_interface.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/NIFTI_NORDIC_interface.py b/NIFTI_NORDIC_interface.py
index a1d4984..9199710 100644
--- a/NIFTI_NORDIC_interface.py
+++ b/NIFTI_NORDIC_interface.py
@@ -1,5 +1,4 @@
 # Author: Monika Dörig, 2023
-# Questions & Inputs to: monika.doerig@balgrist.ch
 
 
 
@@ -65,4 +64,4 @@ def _list_outputs(self):
         if os.path.exists(residuals):
             outputs['residual_mat_file'] = residuals
             
-        return outputs
\ No newline at end of file
+        return outputs

From 0078700e04c7500ef82a099936ae51b9515603f1 Mon Sep 17 00:00:00 2001
From: Moni Doerig <82578141+MoniDoerig@users.noreply.github.com>
Date: Mon, 2 Sep 2024 09:55:49 +0200
Subject: [PATCH 08/13] add Neurodesk reference

---
 example_usage_NORDIC_nipype.ipynb | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/example_usage_NORDIC_nipype.ipynb b/example_usage_NORDIC_nipype.ipynb
index 850dbf3..5f93ffc 100644
--- a/example_usage_NORDIC_nipype.ipynb
+++ b/example_usage_NORDIC_nipype.ipynb
@@ -12,6 +12,7 @@
    },
    "source": [
     "#  NIFTI_NORDIC in Nipype\n",
+    "This notebook was tested on Neurodesk Version [2024-04-04](https://hub.docker.com/layers/vnmd/neurodesktop/2024-04-04/images/sha256-5f7b1836e5dc33945d27bfbf91011bb21c4019e7c650b02f22edf313b1d33db4?context=explore)\n",
     "\n",
     "__Author:__ Moni Dörig"
    ]
@@ -34,7 +35,11 @@
     "- [Code on GitHub supporting the publication](https://github.com/SteenMoeller/NORDIC_Raw)\n",
     "\n",
     "__Opensource Data from OpenNeuro:__\n",
-    "- Javier Gonzalez-Castilloa and Colin W. Hoy and Daniel A. Handwerker and Vinai Roopchansingh and Souheil J. Inati and Ziad S. Saad and Robert W. Cox and Peter A. Bandettini (2023). Large Single-Subject Functional MRI Datasets at 7T. OpenNeuro. [Dataset] doi: [10.18112/openneuro.ds001555.v1.0.1](https://openneuro.org/datasets/ds001555/versions/1.0.1)"
+    "- Javier Gonzalez-Castilloa and Colin W. Hoy and Daniel A. Handwerker and Vinai Roopchansingh and Souheil J. Inati and Ziad S. Saad and Robert W. Cox and Peter A. Bandettini (2023). Large Single-Subject Functional MRI Datasets at 7T. OpenNeuro. [Dataset] doi: [10.18112/openneuro.ds001555.v1.0.1](https://openneuro.org/datasets/ds001555/versions/1.0.1)\n",
+    "\n",
+    "__Neurodesk:__\n",
+    "- Renton, A.I., Dao, T.T., Johnstone, T. et al. Neurodesk: an accessible, flexible and portable data analysis environment for reproducible neuroimaging. Nat Methods (2024). https://doi.org/10.1038/s41592-023-02145-x\n",
+    "- [Neurodesk Website](https://www.neurodesk.org/)"
    ]
   },
   {
@@ -534,7 +539,7 @@
     "nifti_nordic_node.inputs.fn_phase_in = fn_phase_in\n",
     "nifti_nordic_node.inputs.fn_out = fn_out\n",
     "nifti_nordic_node.inputs.additional_path = nifti_nordic_script_path #needs this to add it to the matlab paths\n",
-    "#nifti_nordic_node.inputs.ARG = ARG #input is not mandatory"
+    "nifti_nordic_node.inputs.ARG = ARG #input is not mandatory"
    ]
   },
   {

From fb848c1f83632340b7cc3dabfe9d247eb91985bb Mon Sep 17 00:00:00 2001
From: Moni Doerig <82578141+MoniDoerig@users.noreply.github.com>
Date: Mon, 2 Sep 2024 10:37:59 +0200
Subject: [PATCH 09/13] add optional ARG

---
 example_usage_NORDIC_nipype.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/example_usage_NORDIC_nipype.ipynb b/example_usage_NORDIC_nipype.ipynb
index 5f93ffc..09c978f 100644
--- a/example_usage_NORDIC_nipype.ipynb
+++ b/example_usage_NORDIC_nipype.ipynb
@@ -529,7 +529,7 @@
     "fn_phase_in = fn_magn_in #we chose magnitude only; the function will still need two inputs, but will ignore the second\n",
     "fn_out = '_NORDIC'\n",
     "nifti_nordic_script_path = scripts_dir #path where NIFTI_NORDIC_nipype.mat is stored\n",
-    "#ARG = os.path.join(cwd, mat_file_opt)\n",
+    "ARG = os.path.join(cwd, mat_file_opt)\n",
     "\n",
     "# Create the node\n",
     "nifti_nordic_node = Node(NiftiNordic(), name='nifti_nordic')\n",

From 6fdca19924ada780eb54a0c9477e7bb5a344aab8 Mon Sep 17 00:00:00 2001
From: Moni Doerig <82578141+MoniDoerig@users.noreply.github.com>
Date: Mon, 2 Sep 2024 10:53:06 +0200
Subject: [PATCH 10/13] Add introduction

---
 example_usage_NORDIC_nipype.ipynb | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/example_usage_NORDIC_nipype.ipynb b/example_usage_NORDIC_nipype.ipynb
index 09c978f..03b7e84 100644
--- a/example_usage_NORDIC_nipype.ipynb
+++ b/example_usage_NORDIC_nipype.ipynb
@@ -12,9 +12,17 @@
    },
    "source": [
     "#  NIFTI_NORDIC in Nipype\n",
-    "This notebook was tested on Neurodesk Version [2024-04-04](https://hub.docker.com/layers/vnmd/neurodesktop/2024-04-04/images/sha256-5f7b1836e5dc33945d27bfbf91011bb21c4019e7c650b02f22edf313b1d33db4?context=explore)\n",
     "\n",
-    "__Author:__ Moni Dörig"
+    "__Author:__ Moni Dörig\n",
+    "\n",
+    "\n",
+    "This notebook was tested on Neurodesk Version [2024-04-04](https://hub.docker.com/layers/vnmd/neurodesktop/2024-04-04/images/sha256-5f7b1836e5dc33945d27bfbf91011bb21c4019e7c650b02f22edf313b1d33db4?context=explore).\n",
+    "\n",
+    "It demonstrates how to integrate the NORDIC denoising algorithm into a Nipype workflow using a custom Nipype interface (NIFTI_NORDIC_interface.py). The NORDIC algorithm is applied via an adapted version of the NIFTI_NORDIC.m script (NIFTI_NORDIC_nipype.m), which allows for the denoising of functional MRI (fMRI) data.\n",
+    "\n",
+    "In addition to applying the NORDIC denoising, this workflow also computes the temporal signal-to-noise ratio (tSNR) maps for both the raw functional image and the denoised functional image allowing a direct comparison of the effects of NORDIC denoising on the fMRI data.\n",
+    "\n",
+    "This integration streamlines the process of applying NORDIC within a larger fMRI processing pipeline, making it easier to manage and automate using Nipype's workflow system.\n"
    ]
   },
   {

From ada2ba8c2f15999f01e1fb828bfddf094ef9831b Mon Sep 17 00:00:00 2001
From: Moni Doerig <82578141+MoniDoerig@users.noreply.github.com>
Date: Tue, 3 Sep 2024 08:36:56 +0200
Subject: [PATCH 11/13] Adjusted code to handle differnet file formats

---
 NIFTI_NORDIC_interface.py | 30 +++++++++++++++++++-----------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/NIFTI_NORDIC_interface.py b/NIFTI_NORDIC_interface.py
index 9199710..4dffec3 100644
--- a/NIFTI_NORDIC_interface.py
+++ b/NIFTI_NORDIC_interface.py
@@ -1,6 +1,4 @@
-# Author: Monika Dörig, 2023
-
-
+# Author: Monika Dörig, 2024
 
 
 from nipype.interfaces.base import (CommandLine, traits, TraitedSpec,
@@ -28,39 +26,49 @@ class NiftiNordicOutputSpec(TraitedSpec):
 class NiftiNordic(BaseInterface):
     input_spec = NiftiNordicInputSpec
     output_spec = NiftiNordicOutputSpec
+
+    # To handle the basename of .nii and .nii.gz files correctly
+    def get_base_filename(self, file_path):
+        base_name = os.path.basename(file_path)
+        base_name, ext = os.path.splitext(base_name)
+        if ext == '.gz':
+            base_name, _ = os.path.splitext(base_name)
+        return base_name
     
     def _run_interface(self, runtime):
-        # Third argument for NIFTI_NORDIC_nipype.m may need adaptation depending on the the suffix of your file: here it is defined for a .nii.gz file --> [0:-7]
-        mlab_cmd = f"matlab -r \"addpath('{self.inputs.additional_path}'); try; NIFTI_NORDIC_nipype ('{self.inputs.fn_magn_in}', '{self.inputs.fn_phase_in}', '{os.path.basename(self.inputs.fn_magn_in)[0:-7]}{self.inputs.fn_out}','{self.inputs.ARG}' ); catch ME; disp(getReport(ME)); end; quit;\""
+        self.base_name = self.get_base_filename(self.inputs.fn_magn_in)
+
+        mlab_cmd = f"matlab -r \"addpath('{self.inputs.additional_path}'); try; NIFTI_NORDIC_nipype ('{self.inputs.fn_magn_in}', '{self.inputs.fn_phase_in}', '{self.base_name}{self.inputs.fn_out}','{self.inputs.ARG}' ); catch ME; disp(getReport(ME)); end; quit;\""
         mlab = CommandLine(command=mlab_cmd, terminal_output='stream', resource_monitor=True)
         result = mlab.run()  
         return result.runtime
 
     def _list_outputs(self):
         outputs = self.output_spec().get()
+        cwd = os.getcwd()
         
         # Check if the output files exist (depending on the arguments) and assign outputs 
-        output = os.path.abspath(f"{os.getcwd()}/{os.path.basename(self.inputs.fn_magn_in)[0:-7]}{self.inputs.fn_out}.nii")
+        output = os.path.abspath(f"{cwd}/{self.base_name}{self.inputs.fn_out}.nii")
         if os.path.exists(output):
             outputs['output_file'] = output
             
-        info = os.path.abspath(f"{os.getcwd()}/{os.path.basename(self.inputs.fn_magn_in)[0:-7]}{self.inputs.fn_out}_info.mat")
+        info = os.path.abspath(f"{cwd}/{self.base_name}{self.inputs.fn_out}.mat")
         if os.path.exists(info):
             outputs['add_info_file'] = info
             
-        complex_phase = os.path.abspath(f"{os.getcwd()}/{os.path.basename(self.inputs.fn_magn_in)[0:-7]}{self.inputs.fn_out}_phase.nii")
+        complex_phase = os.path.abspath(f"{cwd}/{self.base_name}{self.inputs.fn_out}_phase.nii")
         if os.path.exists(complex_phase):
             outputs['complex_phase_file'] = complex_phase
             
-        complex_magn = os.path.abspath(f"{os.getcwd()}/{os.path.basename(self.inputs.fn_magn_in)[0:-7]}{self.inputs.fn_out}_magn.nii")
+        complex_magn = os.path.abspath(f"{cwd}/{self.base_name}{self.inputs.fn_out}_magn.nii")
         if os.path.exists(complex_magn):
             outputs['complex_magn_file'] = complex_magn
             
-        gfactor = os.path.abspath(f"{os.getcwd()}/gfactor_{os.path.basename(self.inputs.fn_magn_in)[0:-7]}{self.inputs.fn_out}.nii")
+        gfactor = os.path.abspath(f"{cwd}/gfactor_{self.base_name}{self.inputs.fn_out}.nii")
         if os.path.exists(gfactor):
             outputs['gfactor_map_file'] = gfactor     
             
-        residuals = os.path.abspath(f"{os.getcwd()}/RESIDUAL{os.path.basename(self.inputs.fn_magn_in)[0:-7]}{self.inputs.fn_out}.mat")
+        residuals = os.path.abspath(f"{cwd}/RESIDUAL{self.base_name}{self.inputs.fn_out}.mat")
         if os.path.exists(residuals):
             outputs['residual_mat_file'] = residuals
             

From bced2ea01f4b04e0fcfe0a5f9aba049c0cd048de Mon Sep 17 00:00:00 2001
From: Moni Doerig <82578141+MoniDoerig@users.noreply.github.com>
Date: Tue, 3 Sep 2024 08:44:04 +0200
Subject: [PATCH 12/13] corrected typos

---
 example_usage_NORDIC_nipype.ipynb | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/example_usage_NORDIC_nipype.ipynb b/example_usage_NORDIC_nipype.ipynb
index 03b7e84..c83d432 100644
--- a/example_usage_NORDIC_nipype.ipynb
+++ b/example_usage_NORDIC_nipype.ipynb
@@ -189,7 +189,7 @@
    },
    "outputs": [],
    "source": [
-    "#define directory with data\n",
+    "# define directory with data\n",
     "data_dir = os.path.abspath(os.path.join('.', 'ds001555'))"
    ]
   },
@@ -236,7 +236,7 @@
    },
    "outputs": [],
    "source": [
-    "#import NiftiNordic class to wrap matlab script\n",
+    "# import NiftiNordic class to wrap matlab script\n",
     "from NIFTI_NORDIC_interface import NiftiNordic"
    ]
   },
@@ -316,13 +316,13 @@
    "outputs": [],
    "source": [
     "# Create a workflow\n",
-    "#where to store workflow/working directories\n",
+    "# where to store workflow/working directories\n",
     "experiment_dir = os.path.abspath(os.path.join('.', 'NORDIC_output'))\n",
     "\n",
     "workflow = Workflow(name='workflow_nordic', base_dir=experiment_dir)\n",
     "workflow.config[\"execution\"][\"crashfile_format\"] = \"txt\"\n",
     "\n",
-    "#functional and anatomical data\n",
+    "# functional and anatomical data\n",
     "fn_magn_in = os.path.join(data_dir, 'sub-001/ses-01/func/sub-001_ses-01_task-HalfFovNoTask_run-003_bold.nii.gz')\n",
     "anat = os.path.join(data_dir, 'sub-001/ses-01/anat/sub-001_ses-01_acq-MPRAGE_run-001_T1w.nii.gz')"
    ]
@@ -403,10 +403,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "#resample anat mask to func dimension and resolution\n",
+    "# Resample anat mask to func dimension and resolution\n",
     "def resample_mask(in_file, wb_mask):\n",
     "    \n",
-    "    #get binary masks of functional run\n",
     "    import os\n",
     "    import nibabel as nib\n",
     "    from nilearn.image import resample_to_img\n",
@@ -702,7 +701,7 @@
     "    \n",
     "    plt.savefig(path_node +'/'+ basename) \n",
     "\n",
-    "#tsrn of denoised data\n",
+    "#tsnr of denoised data\n",
     "tsnr_plot_nordic = Node(Function(input_names=['data_path', 'base_name'], \n",
     "                                function=plot_tsnr),\n",
     "                                name='plot_tsnr_nordic')\n",
@@ -711,7 +710,7 @@
     "workflow.connect(volreg_nordic, 'out_file', tsnr_plot_nordic, 'base_name')\n",
     "\n",
     "\n",
-    "#tsrn of raw data\n",
+    "#tsnr of raw data\n",
     "tsnr_plot_raw = Node(Function(input_names=['data_path', 'base_name'],\n",
     "                                function=plot_tsnr),\n",
     "                                name='plot_tsnr_raw')\n",
@@ -743,13 +742,13 @@
     "\n",
     "\n",
     "# Connect desired outputs to datasink\n",
-    "#nordic\n",
+    "# nordic\n",
     "workflow.connect(nifti_nordic_node, 'output_file', datasink, 'nordic_output') \n",
     "workflow.connect(nifti_nordic_node, 'add_info_file', datasink, 'nordic_output.@info_file')\n",
     "workflow.connect(nifti_nordic_node, 'gfactor_map_file', datasink, 'nordic_output.@gfactor')\n",
     "workflow.connect(nifti_nordic_node, 'residual_mat_file', datasink, 'nordic_output.@residual')\n",
     "\n",
-    "#tsnr\n",
+    "# tsnr\n",
     "workflow.connect(tsnr_nordic, 'tsnr_file', datasink, 'tsnr_output.@tsnr_nordic')\n",
     "workflow.connect(tsnr_raw, 'tsnr_file', datasink, 'tsnr_output.@tsnr_raw')"
    ]

From 88877d7afc53a8077ae2ef775ac88f813ab30a79 Mon Sep 17 00:00:00 2001
From: Moni Doerig <82578141+MoniDoerig@users.noreply.github.com>
Date: Tue, 3 Sep 2024 08:55:31 +0200
Subject: [PATCH 13/13] add comments

---
 NIFTI_NORDIC_interface.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/NIFTI_NORDIC_interface.py b/NIFTI_NORDIC_interface.py
index 4dffec3..b908147 100644
--- a/NIFTI_NORDIC_interface.py
+++ b/NIFTI_NORDIC_interface.py
@@ -45,6 +45,7 @@ def _run_interface(self, runtime):
 
     def _list_outputs(self):
         outputs = self.output_spec().get()
+        # Save it in directory of Nipype Node
         cwd = os.getcwd()
         
         # Check if the output files exist (depending on the arguments) and assign outputs