FIX: effigies review

Author: jdkent

nipype/workflows/fmri/fsl/preprocess.py

@@ -4,7 +4,6 @@
 from __future__ import division
 
 import os
-
 from ....interfaces import fsl as fsl          # fsl
 from ....interfaces import utility as util     # utility
 from ....pipeline import engine as pe          # pypeline engine
@@ -757,7 +756,7 @@ def create_featreg_preproc(name='featpreproc', highpass=True, whichvol='middle',
     return featpreproc
 
 
-def create_susan_smooth(name="susan_smooth", separate_masks=True, list_fwhms=False):
+def create_susan_smooth(name="susan_smooth", separate_masks=True):
     """Create a SUSAN smoothing workflow
 
     Parameters
@@ -767,7 +766,6 @@ def create_susan_smooth(name="susan_smooth", separate_masks=True, list_fwhms=Fal
 
         name : name of workflow (default: susan_smooth)
         separate_masks : separate masks for each run
-        list_fwhms : multiple full wide half maximum smoothing kernels
 
     Inputs::
 
@@ -790,18 +788,18 @@ def create_susan_smooth(name="susan_smooth", separate_masks=True, list_fwhms=Fal
 
     """
     # replaces the functionality of a "for loop"
-    def cartesian_product(fwhms, in_files, mask_files, merge_out, median_out):
-        if type(in_files) == str:
-            in_files = [in_files]
-        if type(mask_files) == str:
-            mask_files = [mask_files]
-        multi_in_files = [in_file for in_file in in_files for fwhm in fwhms]
-        multi_mask_files = [mask_file for mask_file in mask_files for fwhm in fwhms]
-        multi_fwhms = [fwhm for fwhm in fwhms for in_file in in_files]
-        multi_merge_out = [merge for merge in merge_out for fwhm in fwhms]
-        multi_median_out = [median for median in median_out for fwhm in fwhms]
-
-        return multi_in_files, multi_mask_files, multi_fwhms, multi_merge_out, multi_median_out
+    def cartesian_product(fwhms, in_files, usans, btthresh):
+        from nipype.utils.filemanip import filename_to_list
+        # ensure all inputs are lists
+        in_files = filename_to_list(in_files)
+        fwhms = [fwhms] if isinstance(fwhms, (int, float)) else fwhms
+        # create cartesian product lists (s_<name> = single element of list)
+        cart_in_file = [s_in_file for s_in_file in in_files for s_fwhm in fwhms]
+        cart_fwhm = [s_fwhm for s_in_file in in_files for s_fwhm in fwhms]
+        cart_usans = [s_usans for s_usans in usans for s_fwhm in fwhms]
+        cart_btthresh = [s_btthresh for s_btthresh in btthresh for s_fwhm in fwhms]
+
+        return cart_in_file, cart_fwhm, cart_usans, cart_btthresh
 
     susan_smooth = pe.Workflow(name=name)
 
@@ -820,27 +818,17 @@ def cartesian_product(fwhms, in_files, mask_files, merge_out, median_out):
     of the median value for each run and a mask consituting the mean
     functional
     """
-    if list_fwhms:
-        multi_inputs = pe.Node(util.Function(input_names=['fwhms',
-                                                          'in_files',
-                                                          'mask_files',
-                                                          'merge_out',
-                                                          'median_out'],
-                                             output_names=['multi_in_files',
-                                                           'multi_mask_files',
-                                                           'multi_fwhms',
-                                                           'multi_merge_out',
-                                                           'multi_median_out'],
-                                             function=cartesian_product),
-                               name='multi_inputs')
-
-        smooth = pe.MapNode(interface=fsl.SUSAN(),
-                            iterfield=['in_file', 'brightness_threshold', 'usans', 'fwhm'],
-                            name='smooth')
-    else:
-        smooth = pe.MapNode(interface=fsl.SUSAN(),
-                            iterfield=['in_file', 'brightness_threshold', 'usans'],
-                            name='smooth')
+
+    multi_inputs = pe.Node(util.Function(function=cartesian_product,
+                                         output_names=['cart_in_file',
+                                                       'cart_fwhm',
+                                                       'cart_usans',
+                                                       'cart_btthresh']),
+                           name='multi_inputs')
+
+    smooth = pe.MapNode(interface=fsl.SUSAN(),
+                        iterfield=['in_file', 'brightness_threshold', 'usans', 'fwhm'],
+                        name='smooth')
 
     """
     Determine the median value of the functional runs using the mask
@@ -896,24 +884,17 @@ def cartesian_product(fwhms, in_files, mask_files, merge_out, median_out):
     """
     Define a function to get the brightness threshold for SUSAN
     """
-    # if you are going to iterate over multiple values of fwhm
-    if list_fwhms:
-        susan_smooth.connect([
-            (inputnode, multi_inputs, [('in_files', 'in_files'),
-                                       ('fwhm', 'fwhms'),
-                                       ('mask_file', 'mask_files')]),
-        ])
-        susan_smooth.connect(median, ('out_stat', getbtthresh), multi_inputs, 'median_out')
-        susan_smooth.connect(merge, ('out', getusans), multi_inputs, 'merge_out')
-        susan_smooth.connect(multi_inputs, 'multi_fwhms', smooth, 'fwhm')
-        susan_smooth.connect(multi_inputs, 'multi_in_files', smooth, 'in_file')
-        susan_smooth.connect(multi_inputs, 'multi_median_out', smooth, 'brightness_threshold')
-        susan_smooth.connect(multi_inputs, 'multi_merge_out', smooth, 'usans')
-    else:
-        susan_smooth.connect(inputnode, 'in_files', smooth, 'in_file')
-        susan_smooth.connect(inputnode, 'fwhm', smooth, 'fwhm')
-        susan_smooth.connect(median, ('out_stat', getbtthresh), smooth, 'brightness_threshold')
-        susan_smooth.connect(merge, ('out', getusans), smooth, 'usans')
+
+    susan_smooth.connect([
+        (inputnode, multi_inputs, [('in_files', 'in_files'),
+                                   ('fwhm', 'fwhms')]),
+        (median, multi_inputs, [(('out_stat', getbtthresh), 'btthresh')]),
+        (merge, multi_inputs, [(('out', getusans), 'usans')]),
+        (multi_inputs, smooth, [('cart_in_file', 'in_file'),
+                                ('cart_fwhm', 'fwhm'),
+                                ('cart_btthresh', 'brightness_threshold'),
+                                ('cart_usans', 'usans')]),
+    ])
 
     outputnode = pe.Node(interface=util.IdentityInterface(fields=['smoothed_files']),
                          name='outputnode')