LoopStructural 1.6.18__tar.gz → 1.6.20__tar.gz

{loopstructural-1.6.18 → loopstructural-1.6.20}/LoopStructural/__init__.py

@@ -7,6 +7,9 @@ LoopStructural
 import logging
 from logging.config import dictConfig
 
+from dataclasses import dataclass
+
+
 __all__ = ["GeologicalModel"]
 import tempfile
 from pathlib import Path
@@ -18,6 +21,14 @@ formatter = logging.Formatter("%(levelname)s: %(asctime)s: %(filename)s:%(lineno
 ch.setFormatter(formatter)
 ch.setLevel(logging.WARNING)
 loggers = {}
+@dataclass
+class LoopStructuralConfig:
+    """
+    Configuration for LoopStructural 
+    """
+   
+    nelements: int = 10_000
+
 from .modelling.core.geological_model import GeologicalModel
 from .modelling.core.stratigraphic_column import StratigraphicColumn
 from .modelling.core.fault_topology import FaultTopology

{loopstructural-1.6.18 → loopstructural-1.6.20}/LoopStructural/interpolators/_p1interpolator.py

@@ -6,8 +6,9 @@ import logging
 
 import numpy as np
 
-from ._discrete_interpolator import DiscreteInterpolator
 
+from ._discrete_interpolator import DiscreteInterpolator
+from . import InterpolatorType
 logger = logging.getLogger(__name__)
 
 
@@ -37,7 +38,7 @@ class P1Interpolator(DiscreteInterpolator):
             "tpw": 1.0,
             "ipw": 1.0,
         }
-
+        self.type = InterpolatorType.PIECEWISE_LINEAR
     def add_gradient_constraints(self, w=1.0):
         pass
 

{loopstructural-1.6.18 → loopstructural-1.6.20}/LoopStructural/interpolators/_p2interpolator.py

@@ -8,6 +8,7 @@ from typing import Optional, Callable
 import numpy as np
 
 from ..interpolators import DiscreteInterpolator
+from . import InterpolatorType
 
 logger = logging.getLogger(__name__)
 
@@ -41,7 +42,7 @@ class P2Interpolator(DiscreteInterpolator):
             "tpw": 1.0,
             "ipw": 1.0,
         }
-
+        self.type = InterpolatorType.PIECEWISE_QUADRATIC
     def setup_interpolator(self, **kwargs):
         """
         Searches through kwargs for any interpolation weights and updates

{loopstructural-1.6.18 → loopstructural-1.6.20}/LoopStructural/modelling/core/geological_model.py

@@ -2,6 +2,7 @@
 Main entry point for creating a geological model
 """
 
+from LoopStructural import LoopStructuralConfig
 from ...utils import getLogger
 
 import numpy as np
@@ -20,6 +21,7 @@ from ...modelling.features import (
     UnconformityFeature,
     StructuralFrame,
     GeologicalFeature,
+    BaseFeature,
     FeatureType,
 )
 from ...modelling.features.fold import (
@@ -330,7 +332,21 @@ class GeologicalModel:
             name of the feature to return
         """
         return self.get_feature_by_name(feature_name)
+    def __setitem__(self, feature_name, feature):
+        """Set a feature in the model using feature_name_index
 
+        Parameters
+        ----------
+        feature_name : string
+            name of the feature to set
+        feature : GeologicalFeature
+            the geological feature to set
+        """
+        if not issubclass(type(feature), BaseFeature):
+            raise TypeError("feature must be a GeologicalFeature")
+        if feature.name != feature_name:
+            raise ValueError("feature name does not match key")
+        self._add_feature(feature)
     def __contains__(self, feature_name):
         return feature_name in self.feature_name_index
 
@@ -426,7 +442,7 @@ class GeologicalModel:
         except pickle.PicklingError:
             logger.error("Error saving file")
 
-    def _add_feature(self, feature):
+    def _add_feature(self, feature, index: Optional[int] = None):
         """
         Add a feature to the model stack
 
@@ -443,9 +459,18 @@ class GeologicalModel:
             )
             self.features[self.feature_name_index[feature.name]] = feature
         else:
-            self.features.append(feature)
-            self.feature_name_index[feature.name] = len(self.features) - 1
-            logger.info(f"Adding {feature.name} to model at location {len(self.features)}")
+            if index is not None:
+                if index < 0 or index > len(self.features):
+                    raise IndexError(f"Index {index} out of bounds for features list")
+                self.features.insert(index, feature)
+                self.feature_name_index[feature.name] = index
+                logger.info(f"Adding {feature.name} to model at location {index}")
+                for index, feature in enumerate(self.features):
+                    self.feature_name_index[feature.name] = index
+            else:
+                self.features.append(feature)
+                self.feature_name_index[feature.name] = len(self.features) - 1
+                logger.info(f"Adding {feature.name} to model at location {len(self.features)}")
         self._add_domain_fault_above(feature)
         if feature.type == FeatureType.INTERPOLATED:
             self._add_unconformity_above(feature)
@@ -553,7 +578,7 @@ class GeologicalModel:
         }
 
         """
-        self.stratigraphic_column.clear()
+        self.stratigraphic_column.clear(basement=False)
         # if the colour for a unit hasn't been specified we can just sample from
         # a colour map e.g. tab20
         logger.info("Adding stratigraphic column to model")
@@ -561,6 +586,9 @@ class GeologicalModel:
             "set_stratigraphic_column is deprecated, use model.stratigraphic_column.add_units instead"
         )
         for i, g in enumerate(stratigraphic_column.keys()):
+            if g == 'faults':
+                logger.info('Not adding faults to stratigraphic column')
+                continue
             for u in stratigraphic_column[g].keys():
                 thickness = 0
                 if "min" in stratigraphic_column[g][u] and "max" in stratigraphic_column[g][u]:
@@ -582,15 +610,16 @@ class GeologicalModel:
             self.stratigraphic_column.add_unconformity(
                 name=''.join([g, 'unconformity']),
             )
-            self.stratigraphic_column.group_mapping[f'Group_{i+1}'] = g
+            self.stratigraphic_column.group_mapping[f'Group_{i}'] = g
 
     def create_and_add_foliation(
         self,
         series_surface_name: str,
         *,
-        series_surface_data: pd.DataFrame = None,
+        index: Optional[int] = None,
+        data: Optional[pd.DataFrame] = None,
         interpolatortype: str = "FDI",
-        nelements: int = 1000,
+        nelements: int = LoopStructuralConfig.nelements,
         tol=None,
         faults=None,
         **kwargs,
@@ -643,13 +672,13 @@ class GeologicalModel:
             **kwargs,
         )
         # add data
-        if series_surface_data is None:
-            series_surface_data = self.data.loc[self.data["feature_name"] == series_surface_name]
+        if data is None:
+            data = self.data.loc[self.data["feature_name"] == series_surface_name]
 
-        if series_surface_data.shape[0] == 0:
+        if data.shape[0] == 0:
             logger.warning("No data for {series_surface_data}, skipping")
             return
-        series_builder.add_data_from_data_frame(self.prepare_data(series_surface_data))
+        series_builder.add_data_from_data_frame(self.prepare_data(data))
         self._add_faults(series_builder, features=faults)
 
         # build feature
@@ -660,16 +689,17 @@ class GeologicalModel:
         # could just pass a regular grid of points - mask by any above unconformities??
 
         series_feature.type = FeatureType.INTERPOLATED
-        self._add_feature(series_feature)
+        self._add_feature(series_feature,index=index)
         return series_feature
 
     def create_and_add_fold_frame(
         self,
         fold_frame_name: str,
         *,
-        fold_frame_data=None,
+        index: Optional[int] = None,
+        data=None,
         interpolatortype="FDI",
-        nelements=1000,
+        nelements=LoopStructuralConfig.nelements,
         tol=None,
         buffer=0.1,
         **kwargs,
@@ -717,12 +747,12 @@ class GeologicalModel:
             **kwargs,
         )
         # add data
-        if fold_frame_data is None:
-            fold_frame_data = self.data.loc[self.data["feature_name"] == fold_frame_name]
-        if fold_frame_data.shape[0] == 0:
+        if data is None:
+            data = self.data.loc[self.data["feature_name"] == fold_frame_name]
+        if data.shape[0] == 0:
             logger.warning(f"No data for {fold_frame_name}, skipping")
             return
-        fold_frame_builder.add_data_from_data_frame(self.prepare_data(fold_frame_data))
+        fold_frame_builder.add_data_from_data_frame(self.prepare_data(data))
         self._add_faults(fold_frame_builder[0])
         self._add_faults(fold_frame_builder[1])
         self._add_faults(fold_frame_builder[2])
@@ -732,7 +762,7 @@ class GeologicalModel:
 
         fold_frame.type = FeatureType.STRUCTURALFRAME
         fold_frame.builder = fold_frame_builder
-        self._add_feature(fold_frame)
+        self._add_feature(fold_frame,index=index)
 
         return fold_frame
 
@@ -740,9 +770,10 @@ class GeologicalModel:
         self,
         foliation_name,
         *,
-        foliation_data=None,
+        index: Optional[int] = None,
+        data=None,
         interpolatortype="DFI",
-        nelements=10000,
+        nelements=LoopStructuralConfig.nelements,
         buffer=0.1,
         fold_frame=None,
         svario=True,
@@ -786,7 +817,7 @@ class GeologicalModel:
             fold_frame = self.features[-1]
         assert isinstance(fold_frame, FoldFrame), "Please specify a FoldFrame"
 
-        fold = FoldEvent(fold_frame, name=f"Fold_{foliation_data}", invert_norm=invert_fold_norm)
+        fold = FoldEvent(fold_frame, name=f"Fold_{foliation_name}", invert_norm=invert_fold_norm)
 
         if interpolatortype != "DFI":
             logger.warning("Folded foliation only supports DFI interpolator, changing to DFI")
@@ -801,12 +832,12 @@ class GeologicalModel:
             model=self,
             **kwargs,
         )
-        if foliation_data is None:
-            foliation_data = self.data.loc[self.data["feature_name"] == foliation_name]
-        if foliation_data.shape[0] == 0:
+        if data is None:
+            data = self.data.loc[self.data["feature_name"] == foliation_name]
+        if data.shape[0] == 0:
             logger.warning(f"No data for {foliation_name}, skipping")
             return
-        series_builder.add_data_from_data_frame(self.prepare_data(foliation_data))
+        series_builder.add_data_from_data_frame(self.prepare_data(data))
 
         self._add_faults(series_builder)
         # series_builder.add_data_to_interpolator(True)
@@ -817,19 +848,20 @@ class GeologicalModel:
         # series_feature = series_builder.build(**kwargs)
         series_feature = series_builder.feature
         series_builder.update_build_arguments(kwargs)
-        series_feature.type = FeatureType.INTERPOLATED
+        series_feature.type = FeatureType.FOLDED
         series_feature.fold = fold
 
-        self._add_feature(series_feature)
+        self._add_feature(series_feature,index)
         return series_feature
 
     def create_and_add_folded_fold_frame(
         self,
         fold_frame_name: str,
         *,
-        fold_frame_data: Optional[pd.DataFrame] = None,
+        index: Optional[int] = None,
+        data: Optional[pd.DataFrame] = None,
         interpolatortype="FDI",
-        nelements=10000,
+        nelements=LoopStructuralConfig.nelements,
         fold_frame=None,
         tol=None,
         **kwargs,
@@ -882,7 +914,7 @@ class GeologicalModel:
             logger.info("Using last feature as fold frame")
             fold_frame = self.features[-1]
         assert isinstance(fold_frame, FoldFrame), "Please specify a FoldFrame"
-        fold = FoldEvent(fold_frame, name=f"Fold_{fold_frame_data}")
+        fold = FoldEvent(fold_frame, name=f"Fold_{fold_frame_name}")
 
         interpolatortypes = [
             "DFI",
@@ -899,9 +931,9 @@ class GeologicalModel:
             model=self,
             **kwargs,
         )
-        if fold_frame_data is None:
-            fold_frame_data = self.data[self.data["feature_name"] == fold_frame_name]
-        fold_frame_builder.add_data_from_data_frame(self.prepare_data(fold_frame_data))
+        if data is None:
+            data = self.data[self.data["feature_name"] == fold_frame_name]
+        fold_frame_builder.add_data_from_data_frame(self.prepare_data(data))
 
         for i in range(3):
             self._add_faults(fold_frame_builder[i])
@@ -915,7 +947,7 @@ class GeologicalModel:
 
         folded_fold_frame.type = FeatureType.STRUCTURALFRAME
 
-        self._add_feature(folded_fold_frame)
+        self._add_feature(folded_fold_frame,index=index)
 
         return folded_fold_frame
 
@@ -978,14 +1010,14 @@ class GeologicalModel:
 
         interpolatortype = kwargs.get("interpolatortype", "PLI")
         # buffer = kwargs.get("buffer", 0.1)
-        nelements = kwargs.get("nelements", 1e2)
+        nelements = kwargs.get("nelements", LoopStructuralConfig.nelements)
 
         weights = [gxxgz, gxxgy, gyxgz]
 
         intrusion_frame_builder = IntrusionFrameBuilder(
             interpolatortype=interpolatortype,
             bounding_box=self.bounding_box.with_buffer(kwargs.get("buffer", 0.1)),
-            nelements=kwargs.get("nelements", 1e2),
+            nelements=kwargs.get("nelements", LoopStructuralConfig.nelements),
             name=intrusion_frame_name,
             model=self,
             **kwargs,
@@ -1128,7 +1160,7 @@ class GeologicalModel:
                 feature.add_region(f)
                 break
 
-    def add_unconformity(self, feature: GeologicalFeature, value: float) -> UnconformityFeature:
+    def add_unconformity(self, feature: GeologicalFeature, value: float, index: Optional[int] = None) -> UnconformityFeature:
         """
         Use an existing feature to add an unconformity to the model.
 
@@ -1165,10 +1197,10 @@ class GeologicalModel:
             else:
                 f.add_region(uc_feature)
         # now add the unconformity to the feature list
-        self._add_feature(uc_feature)
+        self._add_feature(uc_feature,index=index)
         return uc_feature
 
-    def add_onlap_unconformity(self, feature: GeologicalFeature, value: float) -> GeologicalFeature:
+    def add_onlap_unconformity(self, feature: GeologicalFeature, value: float, index: Optional[int] = None) -> GeologicalFeature:
         """
         Use an existing feature to add an unconformity to the model.
 
@@ -1196,12 +1228,18 @@ class GeologicalModel:
                 continue
             if f != feature:
                 f.add_region(uc_feature)
-        self._add_feature(uc_feature.inverse())
+        self._add_feature(uc_feature.inverse(),index=index)
 
         return uc_feature
 
     def create_and_add_domain_fault(
-        self, fault_surface_data, *, nelements=10000, interpolatortype="FDI", **kwargs
+        self,
+        fault_surface_data,
+        *,
+        nelements=LoopStructuralConfig.nelements,
+        interpolatortype="FDI",
+        index: Optional[int] = None,
+        **kwargs,
     ):
         """
         Parameters
@@ -1242,7 +1280,7 @@ class GeologicalModel:
         domain_fault = domain_fault_feature_builder.feature
         domain_fault_feature_builder.update_build_arguments(kwargs)
         domain_fault.type = FeatureType.DOMAINFAULT
-        self._add_feature(domain_fault)
+        self._add_feature(domain_fault, index=index)
         self._add_domain_fault_below(domain_fault)
 
         domain_fault_uc = UnconformityFeature(domain_fault, 0)
@@ -1255,7 +1293,8 @@ class GeologicalModel:
         fault_name: str,
         displacement: float,
         *,
-        fault_data: Optional[pd.DataFrame] = None,
+        index: Optional[int] = None,
+        data: Optional[pd.DataFrame] = None,
         interpolatortype="FDI",
         tol=None,
         fault_slip_vector=None,
@@ -1344,14 +1383,14 @@ class GeologicalModel:
         fault_frame_builder = FaultBuilder(
             interpolatortype,
             bounding_box=self.bounding_box,
-            nelements=kwargs.pop("nelements", 1e4),
+            nelements=kwargs.pop("nelements", LoopStructuralConfig.nelements),
             name=fault_name,
             model=self,
             **kwargs,
         )
-        if fault_data is None:
-            fault_data = self.data.loc[self.data["feature_name"] == fault_name]
-        if fault_data.shape[0] == 0:
+        if data is None:
+            data = self.data.loc[self.data["feature_name"] == fault_name]
+        if data.shape[0] == 0:
             logger.warning(f"No data for {fault_name}, skipping")
             return
 
@@ -1367,7 +1406,7 @@ class GeologicalModel:
         if intermediate_axis:
             intermediate_axis = intermediate_axis
         fault_frame_builder.create_data_from_geometry(
-            fault_frame_data=self.prepare_data(fault_data),
+            fault_frame_data=self.prepare_data(data),
             fault_center=fault_center,
             fault_normal_vector=fault_normal_vector,
             fault_slip_vector=fault_slip_vector,
@@ -1399,7 +1438,7 @@ class GeologicalModel:
                 break
         if displacement == 0:
             fault.type = FeatureType.INACTIVEFAULT
-        self._add_feature(fault)
+        self._add_feature(fault,index=index)
 
         return fault
 
@@ -1515,7 +1554,7 @@ class GeologicalModel:
         if self.stratigraphic_column is None:
             logger.warning("No stratigraphic column defined")
             return strat_id
-        
+
         s_id = 0
         for g in reversed(self.stratigraphic_column.get_groups()):
             feature_id = self.feature_name_index.get(g.name, -1)
@@ -1526,7 +1565,7 @@ class GeologicalModel:
                     s_id += 1
             if feature_id == -1:
                 logger.error(f"Model does not contain {g.name}")
-        
+
         return strat_id
 
     def evaluate_model_gradient(self, points: np.ndarray, *, scale: bool = True) -> np.ndarray:
@@ -1548,16 +1587,13 @@ class GeologicalModel:
         if scale:
             xyz = self.scale(xyz, inplace=False)
         grad = np.zeros(xyz.shape)
-        for group in reversed(self.stratigraphic_column.keys()):
-            if group == "faults":
-                continue
-            feature_id = self.feature_name_index.get(group, -1)
+        for g in reversed(self.stratigraphic_column.get_groups()):
+            feature_id = self.feature_name_index.get(g.name, -1)
             if feature_id >= 0:
-                feature = self.features[feature_id]
-                gradt = feature.evaluate_gradient(xyz)
+                gradt = self.features[feature_id].evaluate_gradient(xyz)
                 grad[~np.isnan(gradt).any(axis=1)] = gradt[~np.isnan(gradt).any(axis=1)]
             if feature_id == -1:
-                logger.error(f"Model does not contain {group}")
+                logger.error(f"Model does not contain {g.name}")
 
         return grad
 
@@ -1728,7 +1764,6 @@ class GeologicalModel:
             list of unique stratigraphic ids, featurename, unit name and min and max scalar values
         """
         return self.stratigraphic_column.get_stratigraphic_ids()
-        
 
     def get_fault_surfaces(self, faults: List[str] = []):
         surfaces = []

{loopstructural-1.6.18 → loopstructural-1.6.20}/LoopStructural/modelling/core/stratigraphic_column.py

@@ -1,7 +1,7 @@
 import enum
 from typing import Dict, Optional, List, Tuple
 import numpy as np
-from LoopStructural.utils import rng, getLogger, Observable
+from LoopStructural.utils import rng, getLogger, Observable, random_colour
 logger = getLogger(__name__)
 logger.info("Imported LoopStructural Stratigraphic Column module")
 class UnconformityType(enum.Enum):
@@ -57,7 +57,7 @@ class StratigraphicUnit(StratigraphicColumnElement, Observable['StratigraphicUni
         self._thickness = thickness
         self.data = data
         self.element_type = StratigraphicColumnElementType.UNIT
-        self._id = id
+        self.id = id
         self.min_value = None  # Minimum scalar field value for the unit
         self.max_value = None  # Maximum scalar field value for the unit
     @property
@@ -99,7 +99,7 @@ class StratigraphicUnit(StratigraphicColumnElement, Observable['StratigraphicUni
         colour = self.colour
         if isinstance(colour, np.ndarray):
             colour = colour.astype(float).tolist()
-        return {"name": self.name, "colour": colour, "thickness": self.thickness, 'uuid': self.uuid}
+        return {"name": self.name, "colour": colour, "thickness": self.thickness, 'uuid': self.uuid, 'id': self.id}
 
     @classmethod
     def from_dict(cls, data):
@@ -112,7 +112,7 @@ class StratigraphicUnit(StratigraphicColumnElement, Observable['StratigraphicUni
         colour = data.get("colour")
         thickness = data.get("thickness", None)
         uuid = data.get("uuid", None)
-        return cls(uuid=uuid, name=name, colour=colour, thickness=thickness)
+        return cls(uuid=uuid, name=name, colour=colour, thickness=thickness, id=data.get("id", None))
 
     def __str__(self):
         """
@@ -575,3 +575,29 @@ class StratigraphicColumn(Observable['StratigraphicColumn']):
         ax.axis("off")
 
         return fig
+    
+    def cmap(self):
+        try:
+            import matplotlib.colors as colors
+
+            colours = []
+            boundaries = []
+            data = []
+            for group in self.get_groups():
+                for u in group.units:
+                    colour = u.colour
+                    if not isinstance(colour, str):
+                        try:
+                            u.colour = colors.to_hex(colour)
+                        except ValueError:
+                            logger.warning(f"Cannot convert colour {colour} to hex, using default")
+                            u.colour = random_colour()
+                    data.append((u.id, u.colour))
+                    colours.append(u.colour)
+                    boundaries.append(u.id)
+             # print(u,v)
+            cmap = colors.ListedColormap(colours)
+        except ImportError:
+            logger.warning("Cannot use predefined colours as I can't import matplotlib")
+            cmap = "tab20"
+        return cmap

{loopstructural-1.6.18 → loopstructural-1.6.20}/LoopStructural/modelling/features/_base_geological_feature.py

@@ -271,7 +271,7 @@ class BaseFeature(metaclass=ABCMeta):
 
     def surfaces(
         self,
-        value: Union[float, int, List[Union[float, int]]],
+        value: Optional[Union[float, int, List[Union[float, int]]]] = None,
         bounding_box=None,
         name: Optional[Union[List[str], str]] = None,
         colours: Optional[Union[str, np.ndarray]] = None,
@@ -293,6 +293,7 @@ class BaseFeature(metaclass=ABCMeta):
                 raise ValueError("Must specify bounding box")
             bounding_box = self.model.bounding_box
         regions = self.regions
+        
         try:
             self.regions = [
                 r for r in self.regions if r.name != self.name and r.parent.name != self.name

loopstructural-1.6.20/LoopStructural/modelling/features/_feature_converters.py

@@ -0,0 +1,36 @@
+from LoopStructural.modelling.features.fold import FoldEvent
+from LoopStructural.modelling.features.builders import FoldedFeatureBuilder, StructuralFrameBuilder
+def add_fold_to_feature(feature, fold_frame,**kwargs):
+    fold = FoldEvent(fold_frame, name=f"Fold_{feature.name}", invert_norm=kwargs.get('invert_fold_norm', False))
+
+    builder = FoldedFeatureBuilder.from_feature_builder(
+        feature.builder,
+        fold, 
+        **kwargs
+    )
+    feature = builder.feature
+    feature.fold = fold
+    return feature
+
+def convert_feature_to_structural_frame(feature, **kwargs):
+    """
+    Convert a geological feature to a structural frame by adding the feature to the frame
+
+    Parameters
+    ----------
+    feature : GeologicalFeature
+        the geological feature to convert
+    
+    Returns
+    -------
+    StructuralFrame
+        the updated structural frame with the feature added
+    """
+    builder = feature.builder
+
+    new_builder = StructuralFrameBuilder.from_feature_builder(
+        builder,
+        **kwargs
+    )
+    return new_builder.frame
+    

{loopstructural-1.6.18 → loopstructural-1.6.20}/LoopStructural/modelling/features/_geological_feature.py

@@ -77,7 +77,7 @@ class GeologicalFeature(BaseFeature):
         print(self.name, json)
         json["interpolator"] = self.interpolator.to_json()
         return json
-
+    
     def is_valid(self):
         return self.interpolator.valid
 

{loopstructural-1.6.18 → loopstructural-1.6.20}/LoopStructural/modelling/features/_structural_frame.py

@@ -134,7 +134,7 @@ class StructuralFrame(BaseFeature):
         v[:, 0] = self.features[0].evaluate_value(pos, ignore_regions=ignore_regions)
         v[:, 1] = self.features[1].evaluate_value(pos, ignore_regions=ignore_regions)
         v[:, 2] = self.features[2].evaluate_value(pos, ignore_regions=ignore_regions)
-        return v
+        return v[:,0]
 
     def evaluate_gradient(self, pos, i=None, ignore_regions=False):
         """
@@ -152,11 +152,7 @@ class StructuralFrame(BaseFeature):
         """
         if i is not None:
             return self.features[i].support.evaluate_gradient(pos, ignore_regions=ignore_regions)
-        return (
-            self.features[0].support.evaluate_gradient(pos, ignore_regions=ignore_regions),
-            self.features[1].support.evaluate_gradient(pos, ignore_regions=ignore_regions),
-            self.features[2].support.evaluate_gradient(pos, ignore_regions=ignore_regions),
-        )
+        return self.features[0].support.evaluate_gradient(pos, ignore_regions=ignore_regions)            
 
     def get_data(self, value_map: Optional[dict] = None) -> List[Union[ValuePoints, VectorPoints]]:
         """Return the data associated with the features in the