junifer 0.0.4.dev733__py3-none-any.whl → 0.0.4.dev781__py3-none-any.whl

junifer/data/tests/test_masks.py

@@ -5,16 +5,16 @@
 #          Synchon Mandal <s.mandal@fz-juelich.de>
 # License: AGPL
 
+import socket
 from pathlib import Path
 from typing import Callable, Dict, List, Optional, Union
 
+import nibabel as nib
 import numpy as np
 import pytest
-from nilearn.datasets import fetch_icbm152_brain_gm_mask
 from nilearn.image import resample_to_img
 from nilearn.masking import (
     compute_background_mask,
-    compute_brain_mask,
     compute_epi_mask,
     intersect_masks,
 )
@@ -23,18 +23,96 @@ from numpy.testing import assert_array_almost_equal, assert_array_equal
 from junifer.data.masks import (
     _available_masks,
     _load_vickery_patil_mask,
+    compute_brain_mask,
     get_mask,
     list_masks,
     load_mask,
     register_mask,
 )
+from junifer.datagrabber import DMCC13Benchmark
 from junifer.datareader import DefaultDataReader
 from junifer.testing.datagrabbers import (
     OasisVBMTestingDataGrabber,
+    PartlyCloudyTestingDataGrabber,
     SPMAuditoryTestingDataGrabber,
 )
 
 
+@pytest.mark.parametrize(
+    "mask_type, threshold",
+    [
+        ("brain", 0.2),
+        ("brain", 0.5),
+        ("brain", 0.8),
+        ("gm", 0.2),
+        ("gm", 0.5),
+        ("gm", 0.8),
+        ("wm", 0.2),
+        ("wm", 0.5),
+        ("wm", 0.8),
+    ],
+)
+def test_compute_brain_mask(mask_type: str, threshold: float) -> None:
+    """Test compute_brain_mask().
+
+    Parameters
+    ----------
+    mask_type : str
+        The parametrized mask type.
+    threshold : float
+        The parametrized threshold.
+
+    """
+    with PartlyCloudyTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        mask = compute_brain_mask(
+            target_data=element_data["BOLD"],
+            extra_input=None,
+            mask_type=mask_type,
+        )
+        assert isinstance(mask, nib.Nifti1Image)
+
+
+@pytest.mark.skipif(
+    socket.gethostname() != "juseless",
+    reason="only for juseless",
+)
+@pytest.mark.parametrize(
+    "mask_type",
+    [
+        "brain",
+        "gm",
+        "wm",
+    ],
+)
+def test_compute_brain_mask_for_native(mask_type: str) -> None:
+    """Test compute_brain_mask().
+
+    Parameters
+    ----------
+    mask_type : str
+        The parametrized mask type.
+
+    """
+    with DMCC13Benchmark(
+        types=["BOLD"],
+        sessions=["wave1bas"],
+        tasks=["Rest"],
+        phase_encodings=["AP"],
+        runs=["1"],
+        native_t1w=True,
+    ) as dg:
+        element_data = DefaultDataReader().fit_transform(
+            dg[("f1031ax", "wave1bas", "Rest", "AP", "1")]
+        )
+        mask = compute_brain_mask(
+            target_data=element_data["BOLD"],
+            extra_input=None,
+            mask_type=mask_type,
+        )
+        assert isinstance(mask, nib.Nifti1Image)
+
+
 def test_register_mask_built_in_check() -> None:
     """Test mask registration check for built-in masks."""
     with pytest.raises(ValueError, match=r"built-in mask"):
@@ -215,18 +293,19 @@ def test_vickery_patil_error() -> None:
 
 def test_get_mask() -> None:
     """Test the get_mask function."""
-    reader = DefaultDataReader()
     with OasisVBMTestingDataGrabber() as dg:
-        input = dg["sub-01"]
-        input = reader.fit_transform(input)
-        vbm_gm = input["VBM_GM"]
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        vbm_gm = element_data["VBM_GM"]
         vbm_gm_img = vbm_gm["data"]
-        mask = get_mask(masks="GM_prob0.2", target_data=vbm_gm)
+        mask = get_mask(masks="compute_brain_mask", target_data=vbm_gm)
 
         assert mask.shape == vbm_gm_img.shape
         assert_array_equal(mask.affine, vbm_gm_img.affine)
 
-        raw_mask_img, _, _ = load_mask("GM_prob0.2", resolution=1.5)
+        raw_mask_callable, _, _ = load_mask(
+            "compute_brain_mask", resolution=1.5
+        )
+        raw_mask_img = raw_mask_callable(vbm_gm)  # type: ignore
         res_mask_img = resample_to_img(
             raw_mask_img,
             vbm_gm_img,
@@ -245,13 +324,11 @@ def test_mask_callable() -> None:
     _available_masks["identity"] = {
         "family": "Callable",
         "func": ident,
-        "space": "MNI",
+        "space": "MNI152Lin",
     }
-    reader = DefaultDataReader()
     with OasisVBMTestingDataGrabber() as dg:
-        input = dg["sub-01"]
-        input = reader.fit_transform(input)
-        vbm_gm = input["VBM_GM"]
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        vbm_gm = element_data["VBM_GM"]
         vbm_gm_img = vbm_gm["data"]
         mask = get_mask(masks="identity", target_data=vbm_gm)
 
@@ -262,11 +339,9 @@ def test_mask_callable() -> None:
 
 def test_get_mask_errors() -> None:
     """Test passing wrong parameters to get_mask."""
-    reader = DefaultDataReader()
     with OasisVBMTestingDataGrabber() as dg:
-        input = dg["sub-01"]
-        input = reader.fit_transform(input)
-        vbm_gm = input["VBM_GM"]
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        vbm_gm = element_data["VBM_GM"]
         # Test wrong masks definitions (more than one key per dict)
         with pytest.raises(ValueError, match=r"only one key"):
             get_mask(masks={"GM_prob0.2": {}, "Other": {}}, target_data=vbm_gm)
@@ -286,7 +361,8 @@ def test_get_mask_errors() -> None:
             ValueError, match=r"parameters to the intersection"
         ):
             get_mask(
-                masks=["GM_prob0.2", {"threshold": 1}], target_data=vbm_gm
+                masks=["compute_brain_mask", {"threshold": 1}],
+                target_data=vbm_gm,
             )
 
         # Test "inherited" masks errors
@@ -310,19 +386,20 @@ def test_get_mask_errors() -> None:
                 masks="inherit", target_data=vbm_gm, extra_input=extra_input
             )
 
+        # Block fetch_icbm152_brain_gm_mask space transformation
+        with pytest.raises(RuntimeError, match="prohibited"):
+            get_mask(
+                masks="fetch_icbm152_brain_gm_mask",
+                target_data=vbm_gm,
+                extra_input=extra_input,
+            )
+
 
 @pytest.mark.parametrize(
     "mask_name,function,params,resample",
     [
-        ("compute_brain_mask", compute_brain_mask, {"threshold": 0.2}, False),
         ("compute_background_mask", compute_background_mask, None, False),
         ("compute_epi_mask", compute_epi_mask, None, False),
-        (
-            "fetch_icbm152_brain_gm_mask",
-            fetch_icbm152_brain_gm_mask,
-            None,
-            True,
-        ),
     ],
 )
 def test_nilearn_compute_masks(
@@ -345,11 +422,9 @@ def test_nilearn_compute_masks(
         Whether to resample the mask to the target data.
 
     """
-    reader = DefaultDataReader()
     with SPMAuditoryTestingDataGrabber() as dg:
-        input = dg["sub001"]
-        input = reader.fit_transform(input)
-        bold = input["BOLD"]
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
+        bold = element_data["BOLD"]
         bold_img = bold["data"]
 
         if params is None:
@@ -378,27 +453,30 @@ def test_nilearn_compute_masks(
 
 def test_get_mask_inherit() -> None:
     """Test using the inherit mask functionality."""
-    reader = DefaultDataReader()
     with SPMAuditoryTestingDataGrabber() as dg:
-        input = dg["sub001"]
-        input = reader.fit_transform(input)
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
         # Compute brain mask using nilearn
-        gm_mask = compute_brain_mask(input["BOLD"]["data"], threshold=0.2)
+        gm_mask = compute_brain_mask(element_data["BOLD"], threshold=0.2)
 
         # Get mask using the compute_brain_mask function
         mask1 = get_mask(
             masks={"compute_brain_mask": {"threshold": 0.2}},
-            target_data=input["BOLD"],
+            target_data=element_data["BOLD"],
         )
 
         # Now get the mask using the inherit functionality, passing the
         # computed mask as extra data
         extra_input = {
-            "BOLD_MASK": {"data": gm_mask, "space": input["BOLD"]["space"]}
+            "BOLD_MASK": {
+                "data": gm_mask,
+                "space": element_data["BOLD"]["space"],
+            }
         }
-        input["BOLD"]["mask_item"] = "BOLD_MASK"
+        element_data["BOLD"]["mask_item"] = "BOLD_MASK"
         mask2 = get_mask(
-            masks="inherit", target_data=input["BOLD"], extra_input=extra_input
+            masks="inherit",
+            target_data=element_data["BOLD"],
+            extra_input=extra_input,
         )
 
         # Both masks should be equal
@@ -408,7 +486,6 @@ def test_get_mask_inherit() -> None:
 @pytest.mark.parametrize(
     "masks,params",
     [
-        (["GM_prob0.2", "GM_prob0.2_cortex"], {}),
         (["compute_brain_mask", "compute_background_mask"], {}),
         (["compute_brain_mask", "compute_epi_mask"], {}),
     ],
@@ -426,10 +503,8 @@ def test_get_mask_multiple(
         Parameters to pass to the intersect_masks function.
 
     """
-    reader = DefaultDataReader()
     with SPMAuditoryTestingDataGrabber() as dg:
-        input = dg["sub001"]
-        input = reader.fit_transform(input)
+        element_data = DefaultDataReader().fit_transform(dg["sub001"])
         if not isinstance(masks, list):
             junifer_masks = [masks]
         else:
@@ -438,10 +513,12 @@ def test_get_mask_multiple(
             # Convert params to junifer style (one dict per param)
             junifer_params = [{k: params[k]} for k in params.keys()]
             junifer_masks.extend(junifer_params)
-        target_img = input["BOLD"]["data"]
+        target_img = element_data["BOLD"]["data"]
         resolution = np.min(target_img.header.get_zooms()[:3])
 
-        computed = get_mask(masks=junifer_masks, target_data=input["BOLD"])
+        computed = get_mask(
+            masks=junifer_masks, target_data=element_data["BOLD"]
+        )
 
         masks_names = [
             next(iter(x.keys())) if isinstance(x, dict) else x for x in masks
@@ -464,7 +541,13 @@ def test_get_mask_multiple(
         ]
 
         for t_func in mask_funcs:
-            mask_imgs.append(_available_masks[t_func]["func"](target_img))
+            # Bypass for custom mask
+            if t_func == "compute_brain_mask":
+                mask_imgs.append(
+                    _available_masks[t_func]["func"](element_data["BOLD"])
+                )
+            else:
+                mask_imgs.append(_available_masks[t_func]["func"](target_img))
 
         mask_imgs = [
             resample_to_img(
@@ -478,21 +561,3 @@ def test_get_mask_multiple(
 
         expected = intersect_masks(mask_imgs, **params)
         assert_array_equal(computed.get_fdata(), expected.get_fdata())
-
-
-def test_get_mask_multiple_incorrect_space() -> None:
-    """Test incorrect space error for getting multiple masks."""
-    reader = DefaultDataReader()
-    with SPMAuditoryTestingDataGrabber() as dg:
-        input = dg["sub001"]
-        input = reader.fit_transform(input)
-
-        with pytest.raises(RuntimeError, match="unable to merge."):
-            get_mask(
-                masks=[
-                    "GM_prob0.2",
-                    "compute_brain_mask",
-                    "fetch_icbm152_brain_gm_mask",
-                ],
-                target_data=input["BOLD"],
-            )

junifer/data/tests/test_parcellations.py

@@ -30,7 +30,11 @@ from junifer.data.parcellations import (
     register_parcellation,
 )
 from junifer.datareader import DefaultDataReader
-from junifer.testing.datagrabbers import OasisVBMTestingDataGrabber
+from junifer.pipeline.utils import _check_ants
+from junifer.testing.datagrabbers import (
+    OasisVBMTestingDataGrabber,
+    PartlyCloudyTestingDataGrabber,
+)
 
 
 def test_register_parcellation_built_in_check() -> None:
@@ -58,7 +62,7 @@ def test_register_parcellation_already_registered() -> None:
         name="testparc",
         parcellation_path="testparc.nii.gz",
         parcels_labels=["1", "2", "3"],
-        space="MNI",
+        space="MNI152Lin",
     )
     assert (
         load_parcellation("testparc", path_only=True)[2].name
@@ -71,13 +75,13 @@ def test_register_parcellation_already_registered() -> None:
             name="testparc",
             parcellation_path="testparc.nii.gz",
             parcels_labels=["1", "2", "3"],
-            space="MNI",
+            space="MNI152Lin",
         )
     register_parcellation(
         name="testparc",
         parcellation_path="testparc2.nii.gz",
         parcels_labels=["1", "2", "3"],
-        space="MNI",
+        space="MNI152Lin",
         overwrite=True,
     )
 
@@ -100,14 +104,16 @@ def test_parcellation_wrong_labels_values(tmp_path: Path) -> None:
     assert schaefer is not None
 
     # Test wrong number of labels
-    register_parcellation("WrongLabels", schaefer_path, labels[:10], "MNI")
+    register_parcellation(
+        "WrongLabels", schaefer_path, labels[:10], "MNI152Lin"
+    )
 
     with pytest.raises(ValueError, match=r"has 100 parcels but 10"):
         load_parcellation("WrongLabels")
 
     # Test wrong number of labels
     register_parcellation(
-        "WrongLabels2", schaefer_path, [*labels, "wrong"], "MNI"
+        "WrongLabels2", schaefer_path, [*labels, "wrong"], "MNI152Lin"
     )
 
     with pytest.raises(ValueError, match=r"has 100 parcels but 101"):
@@ -119,7 +125,9 @@ def test_parcellation_wrong_labels_values(tmp_path: Path) -> None:
     new_schaefer_img = new_img_like(schaefer, schaefer_data)
     nib.save(new_schaefer_img, new_schaefer_path)
 
-    register_parcellation("WrongValues", new_schaefer_path, labels[:-1], "MNI")
+    register_parcellation(
+        "WrongValues", new_schaefer_path, labels[:-1], "MNI152Lin"
+    )
     with pytest.raises(ValueError, match=r"the range [0, 99]"):
         load_parcellation("WrongValues")
 
@@ -129,7 +137,9 @@ def test_parcellation_wrong_labels_values(tmp_path: Path) -> None:
     new_schaefer_img = new_img_like(schaefer, schaefer_data)
     nib.save(new_schaefer_img, new_schaefer_path)
 
-    register_parcellation("WrongValues2", new_schaefer_path, labels, "MNI")
+    register_parcellation(
+        "WrongValues2", new_schaefer_path, labels, "MNI152Lin"
+    )
     with pytest.raises(ValueError, match=r"the range [0, 100]"):
         load_parcellation("WrongValues2")
 
@@ -137,13 +147,25 @@ def test_parcellation_wrong_labels_values(tmp_path: Path) -> None:
 @pytest.mark.parametrize(
     "name, parcellation_path, parcels_labels, space, overwrite",
     [
-        ("testparc_1", "testparc_1.nii.gz", ["1", "2", "3"], "MNI", True),
-        ("testparc_2", "testparc_2.nii.gz", ["1", "2", "6"], "MNI", True),
+        (
+            "testparc_1",
+            "testparc_1.nii.gz",
+            ["1", "2", "3"],
+            "MNI152Lin",
+            True,
+        ),
+        (
+            "testparc_2",
+            "testparc_2.nii.gz",
+            ["1", "2", "6"],
+            "MNI152Lin",
+            True,
+        ),
         (
             "testparc_3",
             Path("testparc_3.nii.gz"),
             ["1", "2", "6"],
-            "MNI",
+            "MNI152Lin",
             True,
         ),
     ],
@@ -1172,28 +1194,26 @@ def test_merge_parcellations_3D_multiple_duplicated_labels() -> None:
 
 def test_get_parcellation_single() -> None:
     """Test tailored single parcellation fetch."""
-    reader = DefaultDataReader()
-    with OasisVBMTestingDataGrabber() as dg:
-        element = dg["sub-01"]
-        element_data = reader.fit_transform(element)
-        vbm_gm = element_data["VBM_GM"]
-        vbm_gm_img = vbm_gm["data"]
+    with PartlyCloudyTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        bold = element_data["BOLD"]
+        bold_img = bold["data"]
         # Get tailored parcellation
         tailored_parcellation, tailored_labels = get_parcellation(
-            parcellation=["Schaefer100x7"],
-            target_data=vbm_gm,
+            parcellation=["TianxS1x3TxMNInonlinear2009cAsym"],
+            target_data=bold,
         )
         # Check shape and affine with original element data
-        assert tailored_parcellation.shape == vbm_gm_img.shape
-        assert_array_equal(tailored_parcellation.affine, vbm_gm_img.affine)
+        assert tailored_parcellation.shape == bold_img.shape[:3]
+        assert_array_equal(tailored_parcellation.affine, bold_img.affine)
         # Get raw parcellation
         raw_parcellation, raw_labels, _, _ = load_parcellation(
-            "Schaefer100x7",
+            "TianxS1x3TxMNInonlinear2009cAsym",
             resolution=1.5,
         )
         resampled_raw_parcellation = resample_to_img(
             source_img=raw_parcellation,
-            target_img=vbm_gm_img,
+            target_img=bold_img,
             interpolation="nearest",
             copy=True,
         )
@@ -1207,36 +1227,34 @@ def test_get_parcellation_single() -> None:
 
 def test_get_parcellation_multi_same_space() -> None:
     """Test tailored multi parcellation fetch in same space."""
-    reader = DefaultDataReader()
-    with OasisVBMTestingDataGrabber() as dg:
-        element = dg["sub-01"]
-        element_data = reader.fit_transform(element)
-        vbm_gm = element_data["VBM_GM"]
-        vbm_gm_img = vbm_gm["data"]
+    with PartlyCloudyTestingDataGrabber() as dg:
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
+        bold = element_data["BOLD"]
+        bold_img = bold["data"]
         # Get tailored parcellation
         tailored_parcellation, tailored_labels = get_parcellation(
             parcellation=[
-                "Schaefer100x7",
-                "TianxS2x3TxMNI6thgeneration",
+                "Shen_2015_268",
+                "TianxS1x3TxMNInonlinear2009cAsym",
             ],
-            target_data=vbm_gm,
+            target_data=bold,
         )
         # Check shape and affine with original element data
-        assert tailored_parcellation.shape == vbm_gm_img.shape
-        assert_array_equal(tailored_parcellation.affine, vbm_gm_img.affine)
+        assert tailored_parcellation.shape == bold_img.shape[:3]
+        assert_array_equal(tailored_parcellation.affine, bold_img.affine)
         # Get raw parcellations
         raw_parcellations = []
         raw_labels = []
         parcellations_names = [
-            "Schaefer100x7",
-            "TianxS2x3TxMNI6thgeneration",
+            "Shen_2015_268",
+            "TianxS1x3TxMNInonlinear2009cAsym",
         ]
         for name in parcellations_names:
             img, labels, _, _ = load_parcellation(name=name, resolution=1.5)
             # Resample raw parcellations
             resampled_img = resample_to_img(
                 source_img=img,
-                target_img=vbm_gm_img,
+                target_img=bold_img,
                 interpolation="nearest",
                 copy=True,
             )
@@ -1256,19 +1274,18 @@ def test_get_parcellation_multi_same_space() -> None:
         assert tailored_labels == merged_labels
 
 
+@pytest.mark.skipif(
+    _check_ants() is False, reason="requires ANTs to be in PATH"
+)
 def test_get_parcellation_multi_different_space() -> None:
     """Test tailored multi parcellation fetch in different space."""
-    reader = DefaultDataReader()
     with OasisVBMTestingDataGrabber() as dg:
-        element = dg["sub-01"]
-        element_data = reader.fit_transform(element)
-        vbm_gm = element_data["VBM_GM"]
+        element_data = DefaultDataReader().fit_transform(dg["sub-01"])
         # Get tailored parcellation
-        with pytest.raises(RuntimeError, match="unable to merge."):
-            get_parcellation(
-                parcellation=[
-                    "Schaefer100x7",
-                    "SUITxSUIT",
-                ],
-                target_data=vbm_gm,
-            )
+        get_parcellation(
+            parcellation=[
+                "Schaefer100x7",
+                "TianxS1x3TxMNInonlinear2009cAsym",
+            ],
+            target_data=element_data["VBM_GM"],
+        )

junifer/data/tests/test_template_spaces.py

@@ -11,7 +11,10 @@ import pytest
 
 from junifer.data import get_template, get_xfm
 from junifer.datareader import DefaultDataReader
-from junifer.testing.datagrabbers import OasisVBMTestingDataGrabber
+from junifer.testing.datagrabbers import (
+    OasisVBMTestingDataGrabber,
+    PartlyCloudyTestingDataGrabber,
+)
 
 
 @pytest.mark.skipif(
@@ -33,15 +36,32 @@ def test_get_xfm(tmp_path: Path) -> None:
     assert isinstance(xfm_path, Path)
 
 
-def test_get_template() -> None:
-    """Test tailored template image fetch."""
-    with OasisVBMTestingDataGrabber() as dg:
+@pytest.mark.parametrize(
+    "template_type",
+    [
+        "T1w",
+        "brain",
+        "gm",
+        "wm",
+        "csf",
+    ],
+)
+def test_get_template(template_type: str) -> None:
+    """Test tailored template image fetch.
+
+    Parameters
+    ----------
+    template_type : str
+        The parametrized template type.
+
+    """
+    with PartlyCloudyTestingDataGrabber() as dg:
         element = dg["sub-01"]
         element_data = DefaultDataReader().fit_transform(element)
-        vbm_gm = element_data["VBM_GM"]
+        bold = element_data["BOLD"]
         # Get tailored parcellation
         tailored_template = get_template(
-            space=vbm_gm["space"], target_data=vbm_gm
+            space=bold["space"], target_data=bold, template_type=template_type
         )
         assert isinstance(tailored_template, nib.Nifti1Image)
 
@@ -54,7 +74,22 @@ def test_get_template_invalid_space() -> None:
         vbm_gm = element_data["VBM_GM"]
         # Get tailored parcellation
         with pytest.raises(ValueError, match="Unknown template space:"):
-            _ = get_template(space="andromeda", target_data=vbm_gm)
+            get_template(space="andromeda", target_data=vbm_gm)
+
+
+def test_get_template_invalid_template_type() -> None:
+    """Test invalid template type check for template fetch."""
+    with OasisVBMTestingDataGrabber() as dg:
+        element = dg["sub-01"]
+        element_data = DefaultDataReader().fit_transform(element)
+        vbm_gm = element_data["VBM_GM"]
+        # Get tailored parcellation
+        with pytest.raises(ValueError, match="Unknown template type:"):
+            get_template(
+                space=vbm_gm["space"],
+                target_data=vbm_gm,
+                template_type="xenon",
+            )
 
 
 def test_get_template_closest_resolution() -> None:

junifer/datagrabber/aomic/id1000.py

@@ -154,4 +154,7 @@ class DataladAOMICID1000(PatternDataladDataGrabber):
                 out["T1w"].update({"space": "native"})
             else:
                 out["T1w"].update({"space": "MNI152NLin2009cAsym"})
+        if out.get("Warp"):
+            # Add source space information
+            out["Warp"].update({"src": "MNI152NLin2009cAsym"})
         return out

junifer/datagrabber/aomic/piop1.py

@@ -204,6 +204,9 @@ class DataladAOMICPIOP1(PatternDataladDataGrabber):
                 out["T1w"].update({"space": "native"})
             else:
                 out["T1w"].update({"space": "MNI152NLin2009cAsym"})
+        if out.get("Warp"):
+            # Add source space information
+            out["Warp"].update({"src": "MNI152NLin2009cAsym"})
         return out
 
     def get_elements(self) -> List:

junifer/datagrabber/aomic/piop2.py

@@ -204,4 +204,7 @@ class DataladAOMICPIOP2(PatternDataladDataGrabber):
                 out["T1w"].update({"space": "native"})
             else:
                 out["T1w"].update({"space": "MNI152NLin2009cAsym"})
+        if out.get("Warp"):
+            # Add source space information
+            out["Warp"].update({"src": "MNI152NLin2009cAsym"})
         return out

junifer/datagrabber/dmcc13_benchmark.py

@@ -271,6 +271,9 @@ class DMCC13Benchmark(PatternDataladDataGrabber):
                 out["T1w"].update({"space": "native"})
             else:
                 out["T1w"].update({"space": "MNI152NLin2009cAsym"})
+        if out.get("Warp"):
+            # Add source space information
+            out["Warp"].update({"src": "MNI152NLin2009cAsym"})
         return out
 
     def get_elements(self) -> List:

junifer/datagrabber/hcp1200/hcp1200.py

@@ -159,6 +159,9 @@ class HCP1200(PatternDataGrabber):
         # Add space for T1w data type
         if "T1w" in out:
             out["T1w"].update({"space": "native"})
+        # Add source space for Warp data type
+        if "Warp" in out:
+            out["Warp"].update({"src": "MNI152NLin6Asym"})
         return out
 
     def get_elements(self) -> List: