siibra 0.4a76__py3-none-any.whl → 0.5a1__py3-none-any.whl

siibra/features/feature.py

@@ -20,10 +20,11 @@ from ..commons import logger, InstanceTable, siibra_tqdm, __version__
 from ..core import concept
 from ..core import space, region, parcellation
 
-from typing import Union, TYPE_CHECKING, List, Dict, Type, Tuple, BinaryIO
+from typing import Union, TYPE_CHECKING, List, Dict, Type, Tuple, BinaryIO, Any, Iterator
 from hashlib import md5
 from collections import defaultdict
 from zipfile import ZipFile
+from abc import ABC
 
 if TYPE_CHECKING:
     from ..retrieval.datasets import EbrainsDataset
@@ -42,6 +43,10 @@ class NotFoundException(Exception):
     pass
 
 
+class ParseCompoundFeatureIdException(Exception):
+    pass
+
+
 _README_TMPL = """
 Downloaded from siibra toolsuite.
 siibra-python version: {version}
@@ -120,7 +125,7 @@ class Feature:
         # allows subclasses to implement lazy loading of an anchor
         return self._anchor_cached
 
-    def __init_subclass__(cls, configuration_folder=None, category=None, do_not_index=False):
+    def __init_subclass__(cls, configuration_folder=None, category=None, do_not_index=False, **kwargs):
 
         # Feature.SUBCLASSES serves as an index where feature class inheritance is cached. When users
         # queries a branch on the hierarchy, all children will also be queried. There are usecases where
@@ -144,7 +149,7 @@ class Feature:
         cls.category = category
         if category is not None:
             cls.CATEGORIZED[category].add(cls.__name__, cls)
-        return super().__init_subclass__()
+        return super().__init_subclass__(**kwargs)
 
     @classmethod
     def _get_subclasses(cls):
@@ -257,6 +262,8 @@ class Feature:
         This allows all classes in the __mro__ to have the opportunity to append files
         of interest.
         """
+        if isinstance(self, Compoundable) and "README.md" in fh.namelist():
+            return
         ebrains_page = "\n".join(
             {ds.ebrains_page for ds in self.datasets if getattr(ds, "ebrains_page", None)}
         )
@@ -295,8 +302,11 @@ class Feature:
         """
         Export as a zip archive.
 
-        Args:
-            filelike (string or filelike): name or filehandle to write the zip file. User is responsible to ensure the correct extension (.zip) is set.
+        Parameters
+        ----------
+        filelike: str or path
+            Filelike to write the zip file. User is responsible to ensure the
+            correct extension (.zip) is set.
         """
         fh = ZipFile(filelike, "w")
         self._export(fh)
@@ -333,22 +343,12 @@ class Feature:
         if not hasattr(feat.__class__, '_live_queries'):
             raise EncodeLiveQueryIdException(f"generate_livequery_featureid can only be used on live queries, but {feat.__class__.__name__} is not.")
 
-        encoded_c = []
-        if isinstance(concept, space.Space):
-            encoded_c.append(f"s:{concept.id}")
-        elif isinstance(concept, parcellation.Parcellation):
-            encoded_c.append(f"p:{concept.id}")
-        elif isinstance(concept, region.Region):
-            encoded_c.append(f"p:{concept.parcellation.id}")
-            encoded_c.append(f"r:{concept.name}")
-
-        if len(encoded_c) == 0:
-            raise EncodeLiveQueryIdException("no concept is encoded")
+        encoded_c = Feature._encode_concept(concept)
 
-        return f"lq0::{feat.__class__.__name__}::{'::'.join(encoded_c)}::{feat.id}"
+        return f"lq0::{feat.__class__.__name__}::{encoded_c}::{feat.id}"
 
     @classmethod
-    def deserialize_query_context(Cls, feature_id: str) -> Tuple[Type['Feature'], concept.AtlasConcept, str]:
+    def deserialize_query_context(cls, feature_id: str) -> Tuple[Type['Feature'], concept.AtlasConcept, str]:
         """
         Deserialize id into query context.
 
@@ -360,41 +360,69 @@ class Feature:
 
         clsname, *concepts, fid = rest
 
-        Features = Cls.parse_featuretype(clsname)
+        Features = cls._parse_featuretype(clsname)
 
         if len(Features) == 0:
             raise ParseLiveQueryIdException(f"classname {clsname!r} could not be parsed correctly. {feature_id!r}")
         F = Features[0]
 
+        concept = cls._decode_concept(concepts)
+
+        return (F, concept, fid)
+
+    @staticmethod
+    def _encode_concept(concept: concept.AtlasConcept):
+        encoded_c = []
+        if isinstance(concept, space.Space):
+            encoded_c.append(f"s:{concept.id}")
+        elif isinstance(concept, parcellation.Parcellation):
+            encoded_c.append(f"p:{concept.id}")
+        elif isinstance(concept, region.Region):
+            encoded_c.append(f"p:{concept.parcellation.id}")
+            encoded_c.append(f"r:{concept.name}")
+
+        if len(encoded_c) == 0:
+            raise EncodeLiveQueryIdException("no concept is encoded")
+
+        return '::'.join(encoded_c)
+
+    @classmethod
+    def _decode_concept(cls, concepts: List[str]) -> concept.AtlasConcept:
+        # choose exception to divert try-except correctly
+        if issubclass(cls, CompoundFeature):
+            exception = ParseCompoundFeatureIdException
+        else:
+            exception = ParseLiveQueryIdException
+
         concept = None
         for c in concepts:
             if c.startswith("s:"):
                 if concept is not None:
-                    raise ParseLiveQueryIdException("Conflicting spec.")
+                    raise exception("Conflicting spec.")
                 concept = space.Space.registry()[c.replace("s:", "")]
             if c.startswith("p:"):
                 if concept is not None:
-                    raise ParseLiveQueryIdException("Conflicting spec.")
+                    raise exception("Conflicting spec.")
                 concept = parcellation.Parcellation.registry()[c.replace("p:", "")]
             if c.startswith("r:"):
                 if concept is None:
-                    raise ParseLiveQueryIdException("region has been encoded, but parcellation has not been populated in the encoding, {feature_id!r}")
+                    raise exception("region has been encoded, but parcellation has not been populated in the encoding, {feature_id!r}")
                 if not isinstance(concept, parcellation.Parcellation):
-                    raise ParseLiveQueryIdException("region has been encoded, but previous encoded concept is not parcellation")
+                    raise exception("region has been encoded, but previous encoded concept is not parcellation")
                 concept = concept.get_region(c.replace("r:", ""))
-        if concept is None:
-            raise ParseLiveQueryIdException(f"concept was not populated: {feature_id!r}")
 
-        return (F, concept, fid)
+        if concept is None:
+            raise ParseLiveQueryIdException("concept was not populated in feature id")
+        return concept
 
     @classmethod
-    def parse_featuretype(cls, feature_type: str) -> List[Type['Feature']]:
-        ftypes = {
+    def _parse_featuretype(cls, feature_type: str) -> List[Type['Feature']]:
+        ftypes = sorted({
             feattype
             for FeatCls, feattypes in cls.SUBCLASSES.items()
             if all(w.lower() in FeatCls.__name__.lower() for w in feature_type.split())
             for feattype in feattypes
-        }
+        }, key=lambda t: t.__name__)
         if len(ftypes) > 1:
             return [ft for ft in ftypes if getattr(ft, 'category')]
         else:
@@ -422,7 +450,12 @@ class Feature:
         return live_instances
 
     @classmethod
-    def match(cls, concept: Union[region.Region, parcellation.Parcellation, space.Space], feature_type: Union[str, Type['Feature'], list], **kwargs) -> List['Feature']:
+    def match(
+        cls,
+        concept: Union[region.Region, parcellation.Parcellation, space.Space],
+        feature_type: Union[str, Type['Feature'], list],
+        **kwargs
+    ) -> List['Feature']:
         """
         Retrieve data features of the desired modality.
 
@@ -448,7 +481,7 @@ class Feature:
         if isinstance(feature_type, str):
             # feature type given as a string. Decode the corresponding class.
             # Some string inputs, such as connectivity, may hit multiple matches.
-            ftype_candidates = cls.parse_featuretype(feature_type)
+            ftype_candidates = cls._parse_featuretype(feature_type)
             if len(ftype_candidates) == 0:
                 raise ValueError(
                     f"feature_type {str(feature_type)} did not match with any "
@@ -483,10 +516,16 @@ class Feature:
 
         live_instances = feature_type.livequery(concept, **kwargs)
 
-        return list(dict.fromkeys(preconfigured_instances + live_instances))
+        results = list(dict.fromkeys(preconfigured_instances + live_instances))
+        return CompoundFeature.compound(results, concept)
 
     @classmethod
-    def get_instance_by_id(cls, feature_id: str, **kwargs):
+    def _get_instance_by_id(cls, feature_id: str, **kwargs):
+        try:
+            return CompoundFeature._get_instance_by_id(feature_id, **kwargs)
+        except ParseCompoundFeatureIdException:
+            pass
+
         try:
             F, concept, fid = cls.deserialize_query_context(feature_id)
             return [
@@ -495,12 +534,21 @@ class Feature:
                 if f.id == fid or f.id == feature_id
             ][0]
         except ParseLiveQueryIdException:
-            return [
+            candidates = [
                 inst
                 for Cls in Feature.SUBCLASSES[Feature]
                 for inst in Cls.get_instances()
                 if inst.id == feature_id
-            ][0]
+            ]
+            if len(candidates) == 0:
+                raise NotFoundException(f"No feature instance wth {feature_id} found.")
+            if len(candidates) == 1:
+                return candidates[0]
+            else:
+                raise RuntimeError(
+                    f"Multiple feature instance match {feature_id}",
+                    [c.name for c in candidates]
+                )
         except IndexError:
             raise NotFoundException
 
@@ -563,3 +611,251 @@ class Feature:
                 return getattr(self.inst, __name)
 
         return ProxyFeature(feature, fid)
+
+
+class Compoundable(ABC):
+    """
+    Base class for structures which allow compounding.
+    Determines the necessary grouping and compounding attributes.
+    """
+    _filter_attrs = []  # the attributes to filter this instance of feature
+    _compound_attrs = []  # `compound_key` has to be created from `filter_attributes`
+
+    def __init_subclass__(cls, **kwargs):
+        assert len(cls._filter_attrs) > 0, "All compoundable classes have to have `_filter_attrs` defined."
+        assert len(cls._compound_attrs) > 0, "All compoundable classes have to have `_compound_attrs` defined."
+        assert all(attr in cls._filter_attrs for attr in cls._compound_attrs), "`_compound_attrs` must be a subset of `_filter_attrs`."
+        return super().__init_subclass__(**kwargs)
+
+    def __init__(self):
+        assert all(hasattr(self, attr) for attr in self._filter_attrs), "`_filter_attrs` can only consist of the attributes of the class."
+
+    @property
+    def filter_attributes(self) -> Dict[str, Any]:
+        """
+        Attributes that help distinguish or combine features of the same type
+        among others.
+        """
+        return {attr: getattr(self, attr) for attr in self._filter_attrs}
+
+    @property
+    def _compound_key(self) -> Tuple[Any]:
+        """
+        A tuple of values that define the basis for compounding elements of
+        the same type.
+        """
+        return tuple([self.filter_attributes[attr] for attr in self._compound_attrs])
+
+    @property
+    def _element_index(self) -> Any:
+        """
+        Unique index of this compoundable feature as a subfeature of the
+        Compound. Should be hashable.
+        """
+        index = [
+            self.filter_attributes[attr]
+            for attr in self._filter_attrs
+            if attr not in self._compound_attrs
+        ]
+        return index[0] if len(index) == 1 else tuple(index)
+
+
+class CompoundFeature(Feature):
+    """
+    A compound aggregating mutliple features of the same type, forming its
+    elements. The anatomical anchors and data of the features is merged.
+    Features need to subclass "Compoundable" to allow aggregation
+    into a compound feature.
+    """
+
+    def __init__(
+        self,
+        elements: List['Feature'],
+        queryconcept: Union[region.Region, parcellation.Parcellation, space.Space]
+    ):
+        """
+        A compound of several features of the same type with an anchor created
+        as a sum of adjoinable anchors.
+        """
+        self._feature_type = elements[0].__class__
+        assert all(isinstance(f, self._feature_type) for f in elements), NotImplementedError("Cannot compound features of different types.")
+        self.category = elements[0].category  # same feature types have the same category
+        assert issubclass(self._feature_type, Compoundable), NotImplementedError(f"Cannot compound {self._feature_type}.")
+
+        modality = elements[0].modality
+        assert all(f.modality == modality for f in elements), NotImplementedError("Cannot compound features of different modalities.")
+
+        compound_keys = {element._compound_key for element in elements}
+        assert len(compound_keys) == 1, ValueError(
+            "Only features with identical compound_key can be aggregated."
+        )
+        self._compounding_attributes = {
+            attr: elements[0].filter_attributes[attr]
+            for attr in elements[0]._compound_attrs
+        }
+
+        self._elements = {f._element_index: f for f in elements}
+        assert len(self._elements) == len(elements), RuntimeError(
+            "Element indices should be unique to each element within a CompoundFeature."
+        )
+
+        Feature.__init__(
+            self,
+            modality=modality,
+            description="\n".join({f.description for f in elements}),
+            anchor=sum([f.anchor for f in elements]),
+            datasets=list(dict.fromkeys([ds for f in elements for ds in f.datasets]))
+        )
+        self._queryconcept = queryconcept
+
+    def __getattr__(self, attr: str) -> Any:
+        """Expose compounding attributes explicitly."""
+        if attr in self._compounding_attributes:
+            return self._compounding_attributes[attr]
+        else:
+            raise AttributeError(f"{self._feature_type.__name__} has no attribute {attr}.")
+
+    def __dir__(self):
+        return super().__dir__() + list(self._compounding_attributes.keys())
+
+    @property
+    def elements(self):
+        """Features that make up the compound feature."""
+        return list(self._elements.values())
+
+    @property
+    def indices(self):
+        """Unique indices to features making up the compound feature."""
+        return list(self._elements.keys())
+
+    @property
+    def feature_type(self) -> Type:
+        """Feature type of the elements forming the CompoundFeature."""
+        return self._feature_type
+
+    @property
+    def name(self) -> str:
+        """Returns a short human-readable name of this feature."""
+        groupby = ', '.join([
+            f"{v} {k}" for k, v in self._compounding_attributes.items()
+        ])
+        return (
+            f"{self.__class__.__name__} of {len(self)} "
+            f"{self.feature_type.__name__} features grouped by ({groupby})"
+            f" anchored at {self.anchor}"
+        )
+
+    @property
+    def id(self) -> str:
+        return "::".join((
+            "cf0",
+            f"{self._feature_type.__name__}",
+            self._encode_concept(self._queryconcept),
+            self.datasets[0].id if self.datasets else "nodsid",
+            md5(self.name.encode("utf-8")).hexdigest()
+        ))
+
+    def __iter__(self) -> Iterator['Feature']:
+        """Iterate over subfeatures"""
+        return self.elements.__iter__()
+
+    def __len__(self):
+        """Number of subfeatures making the CompoundFeature"""
+        return len(self._elements)
+
+    def __getitem__(self, index: Any):
+        """Get the nth element in the compound."""
+        return self.elements[index]
+
+    def get_element(self, index: Any):
+        """Get the element with its unique index in the compound."""
+        try:
+            return self._elements[index]
+        except Exception:
+            raise IndexError(f"No feature with index '{index}' in this compound.")
+
+    @classmethod
+    def compound(
+        cls,
+        features: List['Feature'],
+        queryconcept: Union[region.Region, parcellation.Parcellation, space.Space]
+    ) -> List['CompoundFeature']:
+        """
+        Compound features of the same the same type based on their `_compound_key`.
+
+        If there are features that are not of type `Compoundable`, they are
+        returned as is.
+
+        Parameters
+        ----------
+        features: List[Feature]
+            Feature instances to be compounded.
+        queryconcept:
+            AtlasConcept used for the query.
+
+        Returns
+        -------
+        List[CompoundFeature | Feature]
+        """
+        non_compound_features = []
+        grouped_features = defaultdict(list)
+        for f in features:
+            if isinstance(f, Compoundable):
+                grouped_features[f._compound_key].append(f)
+                continue
+            non_compound_features.append(f)
+        return non_compound_features + [
+            cls(fts, queryconcept)
+            for fts in grouped_features.values() if fts
+        ]
+
+    @classmethod
+    def _get_instance_by_id(cls, feature_id: str, **kwargs):
+        """
+        Use the feature id to obtain the same feature instance.
+
+        Parameters
+        ----------
+        feature_id : str
+
+        Returns
+        -------
+        CompoundFeature
+
+        Raises
+        ------
+        ParseCompoundFeatureIdException
+            If no or multiple matches are found. Or id is not fitting to
+            compound features.
+        """
+        if not feature_id.startswith("cf0::"):
+            raise ParseCompoundFeatureIdException("CompoundFeature id must start with cf0::")
+        cf_version, clsname, *queryconcept, dsid, fid = feature_id.split("::")
+        assert cf_version == "cf0"
+        candidates = [
+            f
+            for f in Feature.match(
+                concept=cls._decode_concept(queryconcept),
+                feature_type=clsname
+            )
+            if f.id == fid or f.id == feature_id
+        ]
+        if candidates:
+            if len(candidates) == 1:
+                return candidates[0]
+            else:
+                raise ParseCompoundFeatureIdException(
+                    f"The query with id '{feature_id}' have resulted multiple instances.")
+        else:
+            raise ParseCompoundFeatureIdException
+
+    def _export(self, fh: ZipFile):
+        super()._export(fh)
+        for idx, element in siibra_tqdm(self._elements.items(), desc="Exporting elements", unit="element"):
+            if '/' in str(idx):
+                logger.warning(f"'/' will be replaced with ' ' of the file for element with index {idx}")
+            filename = '/'.join([
+                str(i).replace('/', ' ')
+                for i in (idx if isinstance(idx, tuple) else [idx])
+            ])
+            fh.writestr(f"{self.feature_type.__name__}/{filename}.csv", element.data.to_csv())

siibra/features/tabular/bigbrain_intensity_profile.py

@@ -29,10 +29,13 @@ class BigBrainIntensityProfile(
         "cortical layers: Cortical and laminar thickness gradients diverge in sensory and "
         "motor cortices. PLoS Biology, 18(4), e3000678. "
         "http://dx.doi.org/10.1371/journal.pbio.3000678'."
-        "Taken from the tutorial at https://github.com/kwagstyl/cortical_layers_tutorial "
-        "and assigned to cytoarchitectonic regions of Julich-Brain."
+        "The data is taken from the tutorial at "
+        "https://github.com/kwagstyl/cortical_layers_tutorial. Each vertex is "
+        "assigned to the regional map when queried."
     )
 
+    _filter_attrs = cortical_profile.CorticalProfile._filter_attrs + ["location"]
+
     def __init__(
         self,
         regionname: str,

siibra/features/tabular/cell_density_profile.py

@@ -13,9 +13,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .. import anchor as _anchor
 from . import cortical_profile
 
+from .. import anchor as _anchor
 from ...commons import PolyLine, logger, create_key
 from ...retrieval import requests
 
@@ -43,6 +43,8 @@ class CellDensityProfile(
 
     BIGBRAIN_VOLUMETRIC_SHRINKAGE_FACTOR = 1.931
 
+    _filter_attrs = cortical_profile.CorticalProfile._filter_attrs + ["section", "patch"]
+
     @classmethod
     def CELL_READER(cls, b):
         return pd.read_csv(BytesIO(b[2:]), delimiter=" ", header=0).astype(

siibra/features/tabular/cortical_profile.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 
 from . import tabular
+from ..feature import Compoundable
 
 from .. import anchor as _anchor
 
@@ -23,7 +24,7 @@ from textwrap import wrap
 import numpy as np
 
 
-class CorticalProfile(tabular.Tabular):
+class CorticalProfile(tabular.Tabular, Compoundable):
     """
     Represents a 1-dimensional profile of measurements along cortical depth,
     measured at relative depths between 0 representing the pial surface,
@@ -43,6 +44,9 @@ class CorticalProfile(tabular.Tabular):
     LAYERS = {0: "0", 1: "I", 2: "II", 3: "III", 4: "IV", 5: "V", 6: "VI", 7: "WM"}
     BOUNDARIES = list(zip(list(LAYERS.keys())[:-1], list(LAYERS.keys())[1:]))
 
+    _filter_attrs = ["modality"]
+    _compound_attrs = ["modality"]
+
     def __init__(
         self,
         description: str,
@@ -169,18 +173,18 @@ class CorticalProfile(tabular.Tabular):
             "matplotlib", "plotly", or others supported by pandas DataFrame
             plotting backend.
         **kwargs
-            Keyword arguments are passed on to the plot command.
-            'layercolor' can be used to specify a color for cortical layer shading.
+            Keyword arguments are passed on to the plot command. 'layercolor'
+            can be used to specify a color for cortical layer shading.
         """
         wrapwidth = kwargs.pop("textwrap") if "textwrap" in kwargs else 40
         kwargs["title"] = kwargs.get("title", "\n".join(wrap(self.name, wrapwidth)))
+        layercolor = kwargs.pop("layercolor", "gray")
 
-        if backend == "matplotlib":    
+        if backend == "matplotlib":
             kwargs["xlabel"] = kwargs.get("xlabel", "Cortical depth")
             kwargs["ylabel"] = kwargs.get("ylabel", self.unit)
             kwargs["grid"] = kwargs.get("grid", True)
             kwargs["ylim"] = kwargs.get("ylim", (0, max(self._values)))
-            layercolor = kwargs.pop("layercolor") if "layercolor" in kwargs else "black"
             axs = self.data.plot(*args, **kwargs, backend=backend)
 
             if self.boundaries_mapped:
@@ -194,22 +198,22 @@ class CorticalProfile(tabular.Tabular):
                         ha="center",
                     )
                     if i % 2 == 0:
-                        axs.axvspan(d1, d2, color=layercolor, alpha=0.1)
+                        axs.axvspan(d1, d2, color=layercolor, alpha=0.3)
 
             axs.set_title(axs.get_title(), fontsize="medium")
             return axs
         elif backend == "plotly":
             kwargs["title"] = kwargs["title"].replace("\n", "<br>")
             kwargs["labels"] = {
-                "index": kwargs.pop("xlabel", "Cortical depth"),
-                "value": kwargs.pop("ylabel", self.unit)
+                "index": kwargs.pop("xlabel", None) or kwargs.pop("index", "Cortical depth"),
+                "value": kwargs.pop("ylabel", None) or kwargs.pop("value", self.unit)
             }
             fig = self.data.plot(*args, **kwargs, backend=backend)
             if self.boundaries_mapped:
                 bvals = list(self.boundary_positions.values())
                 for i, (d1, d2) in enumerate(list(zip(bvals[:-1], bvals[1:]))):
                     fig.add_vrect(
-                        x0=d1, x1=d2, line_width=0, fillcolor="gray",
+                        x0=d1, x1=d2, line_width=0, fillcolor=layercolor,
                         opacity=0.2 if i % 2 == 0 else 0.0,
                         label=dict(text=self.LAYERS[i + 1], textposition="bottom center")
                     )
@@ -218,7 +222,7 @@ class CorticalProfile(tabular.Tabular):
                 yaxis_range=(0, max(self._values)),
                 title=dict(
                     automargin=True, yref="container", xref="container",
-                    pad=dict(t=15), xanchor="left"
+                    pad=dict(t=40), xanchor="left", yanchor="top"
                 )
             )
             return fig

siibra/features/tabular/gene_expression.py

@@ -16,8 +16,6 @@
 from .. import anchor as _anchor
 from . import tabular
 
-from ... import logger
-
 import pandas as pd
 from textwrap import wrap
 from typing import List

siibra/features/tabular/layerwise_bigbrain_intensities.py

@@ -32,8 +32,9 @@ class LayerwiseBigBrainIntensities(
         "cortical layers: Cortical and laminar thickness gradients diverge in sensory and "
         "motor cortices. PLoS Biology, 18(4), e3000678. "
         "http://dx.doi.org/10.1371/journal.pbio.3000678'."
-        "Taken from the tutorial at https://github.com/kwagstyl/cortical_layers_tutorial "
-        "and assigned to cytoarchitectonic regions of Julich-Brain."
+        "The data is taken from the tutorial at "
+        "https://github.com/kwagstyl/cortical_layers_tutorial. Each vertex is "
+        "assigned to the regional map when queried."
     )
 
     def __init__(

siibra/features/tabular/receptor_density_profile.py

@@ -34,6 +34,8 @@ class ReceptorDensityProfile(
         "to the border between layer VI and the white matter."
     )
 
+    _filter_attrs = cortical_profile.CorticalProfile._filter_attrs + ["receptor"]
+
     def __init__(
         self,
         receptor: str,
@@ -47,7 +49,7 @@ class ReceptorDensityProfile(
         cortical_profile.CorticalProfile.__init__(
             self,
             description=self.DESCRIPTION,
-            modality=f"{receptor} receptor density",
+            modality="Receptor density",
             anchor=anchor,
             datasets=datasets,
         )
@@ -73,6 +75,10 @@ class ReceptorDensityProfile(
             vocabularies.RECEPTOR_SYMBOLS[self.type]['receptor']['name'],
         )
 
+    @property
+    def name(self):
+        return super().name + f" for {self.type}"
+
     @property
     def neurotransmitter(self):
         return "{} ({})".format(