Keep working.

Author: tsalo

xcp_d/interfaces/bids.py

@@ -259,32 +259,31 @@ def _run_interface(self, runtime):
         Sources = self.inputs.Sources
 
         tpl = get_entity(name_source, 'tpl')
-        res = get_entity(name_source, 'res')
-        den = get_entity(name_source, 'den')
+        tpl_str = f'tpl-{tpl}_' if tpl else ''
+        if tpl:
+            output_dir = os.path.join(output_dir, f'tpl-{tpl}')
+
         cohort = get_entity(name_source, 'cohort')
+        cohort_str = f'cohort-{cohort}_' if cohort else ''
+        if cohort:
+            output_dir = os.path.join(output_dir, f'cohort-{cohort}')
 
-        cohort_str = f'_cohort-{cohort}' if cohort else ''
+        res = get_entity(name_source, 'res')
         res_str = f'_res-{res}' if res else ''
-        den_str = f'_den-{den}' if den else ''
 
-        atlas_out_dir = os.path.join(output_dir, f'tpl-{tpl}')
-        if cohort:
-            atlas_out_dir = os.path.join(atlas_out_dir, f'cohort-{cohort}')
-
-        if res:
-            out_basename = f'tpl-{tpl}{cohort_str}_atlas-{atlas}{res_str}_dseg'
-        else:
-            out_basename = f'tpl-{tpl}{cohort_str}_atlas-{atlas}{den_str}_dseg'
+        den = get_entity(name_source, 'den')
+        den_str = f'_den-{den}' if den else ''
 
+        out_basename = f'{tpl_str}{cohort_str}atlas-{atlas}{res_str}{den_str}_dseg'
         if in_file.endswith('.tsv'):
             extension = '.tsv'
         elif in_file.endswith('.dlabel.nii'):
             extension = '.dlabel.nii'
         else:
             extension = '.nii.gz'
 
-        os.makedirs(atlas_out_dir, exist_ok=True)
-        out_file = os.path.join(atlas_out_dir, f'{out_basename}{extension}')
+        os.makedirs(output_dir, exist_ok=True)
+        out_file = os.path.join(output_dir, f'{out_basename}{extension}')
 
         if out_file.endswith('.nii.gz') and os.path.isfile(out_file):
             # Check that native-resolution atlas doesn't have a different resolution from the last
@@ -300,14 +299,14 @@ def _run_interface(self, runtime):
         # Don't copy the file if it exists, to prevent any race conditions between parallel
         # processes.
         if not os.path.isfile(out_file):
-            lock_file = os.path.join(atlas_out_dir, f'{out_basename}{extension}.lock')
+            lock_file = os.path.join(output_dir, f'{out_basename}{extension}.lock')
             with filelock.SoftFileLock(lock_file, timeout=60):
                 shutil.copyfile(in_file, out_file)
 
         # Only write out a sidecar if metadata are provided
         if meta_dict or Sources:
-            meta_file = os.path.join(atlas_out_dir, f'{out_basename}.json')
-            lock_meta = os.path.join(atlas_out_dir, f'{out_basename}.json.lock')
+            meta_file = os.path.join(output_dir, f'{out_basename}.json')
+            lock_meta = os.path.join(output_dir, f'{out_basename}.json.lock')
             meta_dict = meta_dict or {}
             meta_dict = meta_dict.copy()
             if Sources:

xcp_d/workflows/anatomical/parcellation.py

@@ -179,12 +179,12 @@ def init_parcellate_surfaces_wf(files_to_parcellate, name='parcellate_surfaces_w
             name=f'ds_parcellated_{file_to_parcellate}',
             run_without_submitting=True,
             mem_gb=1,
-            iterfield=['segmentation', 'in_file'],
+            iterfield=['atlas', 'in_file'],
         )
         workflow.connect([
             (inputnode, ds_parcellated_surface, [
                 (file_to_parcellate, 'source_file'),
-                ('atlas_names', 'segmentation'),
+                ('atlas_names', 'atlas'),
             ]),
             (add_hash_parcellated_surface, ds_parcellated_surface, [('out_file', 'in_file')]),
         ])  # fmt:skip

xcp_d/workflows/bold/outputs.py

@@ -208,7 +208,7 @@ def init_postproc_derivatives_wf(
         DerivativesDataSink(
             source_file=name_source,
             dismiss_entities=dismiss_hash(
-                ['segmentation', 'den', 'res', 'space', 'cohort', 'desc']
+                ['atlas', 'den', 'res', 'space', 'cohort', 'desc']
             ),
             suffix='motion',
             extension='.tsv',
@@ -269,7 +269,7 @@ def init_postproc_derivatives_wf(
         ds_temporal_mask = pe.Node(
             DerivativesDataSink(
                 dismiss_entities=dismiss_hash(
-                    ['segmentation', 'den', 'res', 'space', 'cohort', 'desc']
+                    ['atlas', 'den', 'res', 'space', 'cohort', 'desc']
                 ),
                 suffix='outliers',
                 extension='.tsv',
@@ -484,10 +484,10 @@ def init_postproc_derivatives_wf(
             name='ds_coverage',
             run_without_submitting=True,
             mem_gb=1,
-            iterfield=['segmentation', 'in_file', 'meta_dict'],
+            iterfield=['atlas', 'in_file', 'meta_dict'],
         )
         workflow.connect([
-            (inputnode, ds_coverage, [('atlas_names', 'segmentation')]),
+            (inputnode, ds_coverage, [('atlas_names', 'atlas')]),
             (add_hash_coverage, ds_coverage, [
                 ('out_file', 'in_file'),
                 ('metadata', 'meta_dict'),
@@ -537,10 +537,10 @@ def init_postproc_derivatives_wf(
             name='ds_timeseries',
             run_without_submitting=True,
             mem_gb=1,
-            iterfield=['segmentation', 'in_file', 'meta_dict'],
+            iterfield=['atlas', 'in_file', 'meta_dict'],
         )
         workflow.connect([
-            (inputnode, ds_timeseries, [('atlas_names', 'segmentation')]),
+            (inputnode, ds_timeseries, [('atlas_names', 'atlas')]),
             (add_hash_timeseries, ds_timeseries, [
                 ('out_file', 'in_file'),
                 ('metadata', 'meta_dict'),
@@ -612,10 +612,10 @@ def init_postproc_derivatives_wf(
                 name='ds_correlations',
                 run_without_submitting=True,
                 mem_gb=1,
-                iterfield=['segmentation', 'in_file', 'meta_dict'],
+                iterfield=['atlas', 'in_file', 'meta_dict'],
             )
             workflow.connect([
-                (inputnode, ds_correlations, [('atlas_names', 'segmentation')]),
+                (inputnode, ds_correlations, [('atlas_names', 'atlas')]),
                 (add_hash_correlations, ds_correlations, [
                     ('out_file', 'in_file'),
                     ('metadata', 'meta_dict'),
@@ -636,11 +636,11 @@ def init_postproc_derivatives_wf(
                 name='ds_coverage_ciftis',
                 run_without_submitting=True,
                 mem_gb=1,
-                iterfield=['segmentation', 'in_file', 'meta_dict'],
+                iterfield=['atlas', 'in_file', 'meta_dict'],
             )
             workflow.connect([
                 (inputnode, ds_coverage_ciftis, [
-                    ('atlas_names', 'segmentation'),
+                    ('atlas_names', 'atlas'),
                     ('coverage_ciftis', 'in_file'),
                 ]),
                 (add_denoised_to_src, ds_coverage_ciftis, [('metadata', 'meta_dict')]),
@@ -676,11 +676,11 @@ def init_postproc_derivatives_wf(
                 name='ds_timeseries_ciftis',
                 run_without_submitting=True,
                 mem_gb=1,
-                iterfield=['segmentation', 'in_file', 'meta_dict'],
+                iterfield=['atlas', 'in_file', 'meta_dict'],
             )
             workflow.connect([
                 (inputnode, ds_timeseries_ciftis, [
-                    ('atlas_names', 'segmentation'),
+                    ('atlas_names', 'atlas'),
                     ('timeseries_ciftis', 'in_file'),
                 ]),
                 (add_ccoverage_to_src, ds_timeseries_ciftis, [('metadata', 'meta_dict')]),
@@ -741,11 +741,11 @@ def init_postproc_derivatives_wf(
                     name='ds_correlation_ciftis',
                     run_without_submitting=True,
                     mem_gb=1,
-                    iterfield=['segmentation', 'in_file', 'meta_dict'],
+                    iterfield=['atlas', 'in_file', 'meta_dict'],
                 )
                 workflow.connect([
                     (inputnode, ds_correlation_ciftis, [
-                        ('atlas_names', 'segmentation'),
+                        ('atlas_names', 'atlas'),
                         ('correlation_ciftis', 'in_file'),
                     ]),
                     (make_ccorrs_meta_dict2, ds_correlation_ciftis, [('metadata', 'meta_dict')]),
@@ -786,10 +786,10 @@ def init_postproc_derivatives_wf(
                 name=f'ds_correlations_exact_{i_exact_scan}',
                 run_without_submitting=True,
                 mem_gb=1,
-                iterfield=['segmentation', 'in_file'],
+                iterfield=['atlas', 'in_file'],
             )
             workflow.connect([
-                (inputnode, ds_correlations_exact, [('atlas_names', 'segmentation')]),
+                (inputnode, ds_correlations_exact, [('atlas_names', 'atlas')]),
                 (add_hash_correlations_exact, ds_correlations_exact, [('out_file', 'in_file')]),
             ])  # fmt:skip
 
@@ -876,10 +876,10 @@ def init_postproc_derivatives_wf(
             name='ds_parcellated_reho',
             run_without_submitting=True,
             mem_gb=1,
-            iterfield=['segmentation', 'in_file', 'meta_dict'],
+            iterfield=['atlas', 'in_file', 'meta_dict'],
         )
         workflow.connect([
-            (inputnode, ds_parcellated_reho, [('atlas_names', 'segmentation')]),
+            (inputnode, ds_parcellated_reho, [('atlas_names', 'atlas')]),
             (add_hash_parcellated_reho, ds_parcellated_reho, [
                 ('out_file', 'in_file'),
                 ('metadata', 'meta_dict'),
@@ -988,10 +988,10 @@ def init_postproc_derivatives_wf(
                 name='ds_parcellated_alff',
                 run_without_submitting=True,
                 mem_gb=1,
-                iterfield=['segmentation', 'in_file', 'meta_dict'],
+                iterfield=['atlas', 'in_file', 'meta_dict'],
             )
             workflow.connect([
-                (inputnode, ds_parcellated_alff, [('atlas_names', 'segmentation')]),
+                (inputnode, ds_parcellated_alff, [('atlas_names', 'atlas')]),
                 (add_hash_parcellated_alff, ds_parcellated_alff, [
                     ('out_file', 'in_file'),
                     ('metadata', 'meta_dict'),

xcp_d/workflows/parcellation.py

@@ -69,6 +69,8 @@ def init_load_atlases_wf(name='load_atlases_wf'):
         file_format=config.workflow.file_format,
         bids_filters=config.execution.bids_filters,
     )
+    # TODO: Grab the atlas-<label>_description.json at the top of the dataset and
+    # copy it to the output directory.
 
     # Reorganize the atlas file information
     atlas_names, atlas_files, atlas_labels_files, atlas_metadata = [], [], [], []