LoopStructural 1.6.2__py3-none-any.whl → 1.6.6__py3-none-any.whl

LoopStructural/modelling/features/_geological_feature.py

@@ -2,10 +2,11 @@
 Geological features
 """
 
+from LoopStructural.utils.maths import regular_tetraherdron_for_points, gradient_from_tetrahedron
 from ...modelling.features import BaseFeature
 from ...utils import getLogger
 from ...modelling.features import FeatureType
-from ...interpolators import GeologicalInterpolator, DiscreteInterpolator
+from ...interpolators import GeologicalInterpolator
 import numpy as np
 from typing import Optional, List, Union
 from ...datatypes import ValuePoints, VectorPoints
@@ -112,7 +113,9 @@ class GeologicalFeature(BaseFeature):
         # if evaluation_points is not a numpy array try and convert
         # otherwise error
         evaluation_points = np.asarray(pos)
-        self.builder.up_to_date()
+        # if there is a builder lets make sure that the feature is up to date
+        if self.builder is not None:
+            self.builder.up_to_date()
         # check if the points are within the display region
         v = np.zeros(evaluation_points.shape[0])
         v[:] = np.nan
@@ -131,7 +134,9 @@ class GeologicalFeature(BaseFeature):
             v[nanmask] = v[~nanmask][i]
         return v
 
-    def evaluate_gradient(self, pos: np.ndarray, ignore_regions=False) -> np.ndarray:
+    def evaluate_gradient(
+        self, pos: np.ndarray, ignore_regions=False, element_scale_parameter=None
+    ) -> np.ndarray:
         """
 
         Parameters
@@ -147,6 +152,17 @@ class GeologicalFeature(BaseFeature):
         if pos.shape[1] != 3:
             raise LoopValueError("Need Nx3 array of xyz points to evaluate gradient")
         logger.info(f'Calculating gradient for {self.name}')
+        if element_scale_parameter is None:
+            if self.model is not None:
+                element_scale_parameter = np.min(self.model.bounding_box.step_vector) / 10
+            else:
+                element_scale_parameter = 1
+        else:
+            try:
+                element_scale_parameter = float(element_scale_parameter)
+            except ValueError:
+                logger.error("element_scale_parameter must be a float")
+                element_scale_parameter = 1
 
         self.builder.up_to_date()
 
@@ -156,16 +172,38 @@ class GeologicalFeature(BaseFeature):
         # evaluate the faults on the nodes of the faulted feature support
         # then evaluate the gradient at these points
         if len(self.faults) > 0:
+            # generate a regular tetrahedron for each point
+            # we will then move these points by the fault and then recalculate the gradient.
+            # this should work...
+            resolved = False
+            tetrahedron = regular_tetraherdron_for_points(pos, element_scale_parameter)
+
+            while resolved:
+                for f in self.faults:
+                    v = (
+                        f[0]
+                        .evaluate_value(tetrahedron.reshape(-1, 3), fillnan='nearest')
+                        .reshape(tetrahedron.shape[0], 4)
+                    )
+                    flag = np.logical_or(np.all(v > 0, axis=1), np.all(v < 0, axis=1))
+                    if np.any(~flag):
+                        logger.warning(
+                            f"Points are too close to fault {f[0].name}. Refining the tetrahedron"
+                        )
+                        element_scale_parameter *= 0.5
+                        tetrahedron = regular_tetraherdron_for_points(pos, element_scale_parameter)
+
+                resolved = True
+
+            tetrahedron_faulted = self._apply_faults(np.array(tetrahedron.reshape(-1, 3))).reshape(
+                tetrahedron.shape
+            )
+
+            values = self.interpolator.evaluate_value(tetrahedron_faulted.reshape(-1, 3)).reshape(
+                (-1, 4)
+            )
+            v[mask, :] = gradient_from_tetrahedron(tetrahedron[mask, :, :], values[mask])
 
-            if issubclass(type(self.interpolator), DiscreteInterpolator):
-                points = self.interpolator.support.nodes
-            else:
-                raise NotImplementedError(
-                    "Faulted feature gradients are only supported by DiscreteInterpolator at the moment."
-                )
-            points_faulted = self._apply_faults(points)
-            values = self.interpolator.evaluate_value(points_faulted)
-            v[mask, :] = self.interpolator.support.evaluate_gradient(pos[mask, :], values)
             return v
         pos = self._apply_faults(pos)
         if mask.dtype not in [int, bool]:

LoopStructural/modelling/features/_projected_vector_feature.py

@@ -0,0 +1,112 @@
+"""
+"""
+
+import numpy as np
+from typing import Optional
+
+from ...modelling.features import BaseFeature
+
+from ...utils import getLogger
+
+logger = getLogger(__name__)
+
+
+class ProjectedVectorFeature(BaseFeature):
+    def __init__(
+        self,
+        name: str,
+        vector: np.ndarray,
+        plane_feature: BaseFeature,
+    ):
+        """
+
+        Create a geological feature by projecting a vector onto a feature representing a plane
+        E.g. project a thickness vector onto an axial surface
+
+        Parameters
+        ----------
+        name: feature name
+        vector: the vector to project
+        plane_feature: the plane
+
+
+        Parameters
+        ----------
+        name : str
+            name of the feature
+        geological_feature_a : BaseFeature
+            Left hand side of cross product
+        geological_feature_b : BaseFeature
+            Right hand side of cross product
+        """
+        super().__init__(name)
+        self.plane_feature = plane_feature
+        self.vector = vector
+
+        self.value_feature = None
+
+    def evaluate_gradient(self, locations: np.ndarray, ignore_regions=False) -> np.ndarray:
+        """
+        Calculate the gradient of the geological feature by using numpy to
+        calculate the cross
+        product between the two existing feature gradients.
+        This means both features have to be evaluated for the locations
+
+        Parameters
+        ----------
+        locations
+
+        Returns
+        -------
+
+        """
+
+        # project s0 onto axis plane B X A X B
+        plane_normal = self.plane_feature.evaluate_gradient(locations, ignore_regions)
+        vector = np.tile(self.vector, (locations.shape[0], 1))
+
+        projected_vector = np.cross(
+            plane_normal, np.cross(vector, plane_normal, axisa=1, axisb=1), axisa=1, axisb=1
+        )
+        return projected_vector
+
+    def evaluate_value(self, evaluation_points: np.ndarray, ignore_regions=False) -> np.ndarray:
+        """
+        Return 0 because there is no value for this feature
+        Parameters
+        ----------
+        evaluation_points
+
+        Returns
+        -------
+
+        """
+        values = np.zeros(evaluation_points.shape[0])
+        if self.value_feature is not None:
+            values[:] = self.value_feature.evaluate_value(evaluation_points, ignore_regions)
+        return values
+
+    def mean(self):
+        if self.value_feature:
+            return self.value_feature.mean()
+        return 0.0
+
+    def min(self):
+        if self.value_feature:
+            return self.value_feature.min()
+        return 0.0
+
+    def max(self):
+        if self.value_feature:
+            return self.value_feature.max()
+        return 0.0
+
+    def get_data(self, value_map: Optional[dict] = None):
+        return
+
+    def copy(self, name: Optional[str] = None):
+        if name is None:
+            name = f'{self.name}_copy'
+        return ProjectedVectorFeature(
+            name=name, vector=self.vector, plane_feature=self.plane_feature
+        )

LoopStructural/modelling/features/_structural_frame.py

@@ -115,7 +115,7 @@ class StructuralFrame(BaseFeature):
         """
         return self.features[i]
 
-    def evaluate_value(self, evaluation_points, ignore_regions=False):
+    def evaluate_value(self, pos, ignore_regions=False):
         """
         Evaluate the value of the structural frame for the points.
         Can optionally only evaluate one coordinate
@@ -129,14 +129,14 @@ class StructuralFrame(BaseFeature):
         -------
 
         """
-        v = np.zeros(evaluation_points.shape)  # create new 3d array of correct length
+        v = np.zeros(pos.shape)  # create new 3d array of correct length
         v[:] = np.nan
-        v[:, 0] = self.features[0].evaluate_value(evaluation_points, ignore_regions=ignore_regions)
-        v[:, 1] = self.features[1].evaluate_value(evaluation_points, ignore_regions=ignore_regions)
-        v[:, 2] = self.features[2].evaluate_value(evaluation_points, ignore_regions=ignore_regions)
+        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
 
-    def evaluate_gradient(self, evaluation_points, i=None, ignore_regions=False):
+    def evaluate_gradient(self, pos, i=None, ignore_regions=False):
         """
         Evaluate the gradient of the structural frame.
         Can optionally only evaluate the ith coordinate
@@ -151,19 +151,11 @@ class StructuralFrame(BaseFeature):
 
         """
         if i is not None:
-            return self.features[i].support.evaluate_gradient(
-                evaluation_points, ignore_regions=ignore_regions
-            )
+            return self.features[i].support.evaluate_gradient(pos, ignore_regions=ignore_regions)
         return (
-            self.features[0].support.evaluate_gradient(
-                evaluation_points, ignore_regions=ignore_regions
-            ),
-            self.features[1].support.evaluate_gradient(
-                evaluation_points, ignore_regions=ignore_regions
-            ),
-            self.features[2].support.evaluate_gradient(
-                evaluation_points, ignore_regions=ignore_regions
-            ),
+            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),
         )
 
     def get_data(self, value_map: Optional[dict] = None) -> List[Union[ValuePoints, VectorPoints]]:
@@ -184,3 +176,9 @@ class StructuralFrame(BaseFeature):
         for f in self.features:
             data.extend(f.get_data(value_map))
         return data
+
+    def copy(self, name: Optional[str] = None):
+        if name is None:
+            name = f'{self.name}_copy'
+        # !TODO check if this needs to be a deep copy
+        return StructuralFrame(name, self.features, self.fold, self.model)

LoopStructural/modelling/features/_unconformity_feature.py

@@ -19,7 +19,7 @@ class UnconformityFeature(GeologicalFeature):
         # just don't link the regions
         GeologicalFeature.__init__(
             self,
-            name=f"{feature.name}_unconformity",
+            name=f"__{feature.name}_unconformity",
             faults=feature.faults,
             regions=[],  # feature.regions.copy(),  # don't want to share regionsbetween unconformity and # feature.regions,
             builder=feature.builder,
@@ -75,9 +75,9 @@ class UnconformityFeature(GeologicalFeature):
             true if above the unconformity, false if below
         """
         if self.sign:
-            return self.evaluate_value(pos) < self.value
+            return self.evaluate_value(pos) <= self.value
         if not self.sign:
-            return self.evaluate_value(pos) > self.value
+            return self.evaluate_value(pos) >= self.value
 
     def __call__(self, pos) -> np.ndarray:
         return self.evaluate(pos)

LoopStructural/modelling/features/builders/_base_builder.py

@@ -29,6 +29,12 @@ class BaseBuilder:
         self._build_arguments = {}
         self.faults = []
 
+    def set_not_up_to_date(self, caller):
+        logger.info(
+            f"Setting {self.name} to not up to date from an instance of {caller.__class__.__name__}"
+        )
+        self._up_to_date = False
+
     @property
     def model(self):
         return self._model
@@ -46,6 +52,7 @@ class BaseBuilder:
         # self._build_arguments = {}
         for k, i in build_arguments.items():
             if i != self._build_arguments.get(k, None):
+                logger.info(f"Setting {k} to {i} for {self.name}")
                 self._build_arguments[k] = i
                 ## if build_arguments change then flag to reinterpolate
                 self._up_to_date = False
@@ -107,5 +114,6 @@ class BaseBuilder:
         -------
 
         """
+        logger.info(f'Adding fault {fault.name} to {self.name}')
         self._up_to_date = False
         self.faults.append(fault)

LoopStructural/modelling/features/builders/_folded_feature_builder.py

@@ -1,5 +1,5 @@
 from ....modelling.features.builders import GeologicalFeatureBuilder
-from ....modelling.features.fold import FoldRotationAngle
+from ....modelling.features.fold.fold_function import FoldRotationType, get_fold_rotation_profile
 import numpy as np
 
 from ....utils import getLogger, InterpolatorError
@@ -19,6 +19,8 @@ class FoldedFeatureBuilder(GeologicalFeatureBuilder):
         name="Feature",
         region=None,
         svario=True,
+        axis_profile_type=FoldRotationType.FOURIER_SERIES,
+        limb_profile_type=FoldRotationType.FOURIER_SERIES,
         **kwargs,
     ):
         """Builder for creating a geological feature using fold constraints
@@ -36,6 +38,7 @@ class FoldedFeatureBuilder(GeologicalFeatureBuilder):
         region : _type_, optional
             _description_, by default None
         """
+        # create the feature builder, this intialises the interpolator
         GeologicalFeatureBuilder.__init__(
             self,
             interpolatortype=interpolatortype,
@@ -45,11 +48,27 @@ class FoldedFeatureBuilder(GeologicalFeatureBuilder):
             region=region,
             **kwargs,
         )
+        # link the interpolator to the fold object
         self.interpolator.fold = fold
         self.fold = fold
         self.fold_weights = fold_weights
         self.kwargs = kwargs
         self.svario = svario
+        self.axis_profile_type = axis_profile_type
+        self.limb_profile_type = limb_profile_type
+
+    @property
+    def fold_axis_rotation(self):
+        if self.fold.fold_axis_rotation is None:
+            self.set_fold_axis()
+        return self.fold.fold_axis_rotation
+
+    @property
+    def fold_limb_rotation(self):
+        _axis = self.fold.fold_axis  # get axis to make sure its initialised
+        if self.fold.fold_limb_rotation is None:
+            self.set_fold_limb_rotation()
+        return self.fold.fold_limb_rotation
 
     def set_fold_axis(self):
         """calculates the fold axis/ fold axis rotation and adds this to the fold"""
@@ -67,31 +86,41 @@ class FoldedFeatureBuilder(GeologicalFeatureBuilder):
             if not self.fold.foldframe[1].is_valid():
                 raise InterpolatorError("Fold frame direction coordinate is not valid")
             far, fad = self.fold.foldframe.calculate_fold_axis_rotation(self)
-            fold_axis_rotation = FoldRotationAngle(far, fad, svario=self.svario)
-            a_wl = kwargs.get("axis_wl", None)
+            fold_axis_rotation = get_fold_rotation_profile(self.axis_profile_type, far, fad)
             if "axis_function" in kwargs:
                 # allow predefined function to be used
-                fold_axis_rotation.set_function(kwargs["axis_function"])
+                logger.error("axis_function is deprecated, use a specific fold rotation angle profile type")
             else:
-                fold_axis_rotation.fit_fourier_series(wl=a_wl)
+                fold_axis_rotation.fit(params={'wavelength': kwargs.get("axis_wl", None)})
             self.fold.fold_axis_rotation = fold_axis_rotation
+            fold_axis_rotation.add_observer(self)
 
     def set_fold_limb_rotation(self):
         """Calculates the limb rotation of the fold and adds it to the fold object"""
         kwargs = self.kwargs
+        # need to calculate the fold axis before the fold limb rotation angle
+        if self.fold.fold_axis is None:
+            self.set_fold_axis()
         # give option of passing own fold limb rotation function
-        flr, fld = self.fold.foldframe.calculate_fold_limb_rotation(
-            self, self.fold.get_fold_axis_orientation
-        )
-        fold_limb_rotation = FoldRotationAngle(flr, fld, svario=self.svario)
-        l_wl = kwargs.get("limb_wl", None)
+        flr, fld = self.calculate_fold_limb_rotation_angle()
+
+        fold_limb_rotation = get_fold_rotation_profile(self.limb_profile_type, flr, fld)
         if "limb_function" in kwargs:
             # allow for predefined functions to be used
-            fold_limb_rotation.set_function(kwargs["limb_function"])
+            logger.error("limb_function is deprecated, use a specific fold rotation angle profile type")
         else:
-            fold_limb_rotation.fit_fourier_series(wl=l_wl, **kwargs)
+            fold_limb_rotation.fit(params={'wavelength': kwargs.get("limb_wl", None)})
+
         self.fold.fold_limb_rotation = fold_limb_rotation
+        fold_limb_rotation.add_observer(self)
+
+    def calculate_fold_limb_rotation_angle(self):
+        flr, fld = self.fold.foldframe.calculate_fold_limb_rotation(
+            self, self.fold.get_fold_axis_orientation
+        )
+        return flr, fld
 
+    # def
     def build(self, data_region=None, constrained=None, **kwargs):
         """the main function to run the interpolation and set up the parameters
 
@@ -115,15 +144,17 @@ class FoldedFeatureBuilder(GeologicalFeatureBuilder):
         self.add_data_to_interpolator(constrained=constrained)
         if not self.fold.foldframe[0].is_valid():
             raise InterpolatorError("Fold frame main coordinate is not valid")
-        self.set_fold_axis()
-        self.set_fold_limb_rotation()
+        if self.fold.fold_axis is None:
+            self.set_fold_axis()
+        if self.fold.fold_limb_rotation is None:
+            self.set_fold_limb_rotation()
         logger.info("Adding fold to {}".format(self.name))
         self.interpolator.fold = self.fold
         # if we have fold weights use those, otherwise just use default
         # self.interpolator.add_fold_constraints(**self.fold_weights)
-        kwargs["fold_weights"] = self.fold_weights
+        # kwargs["fold_weights"] = self.fold_weights
         if "cgw" not in kwargs:
             # try adding very small cg
             kwargs["cgw"] = 0.0
         # now the fold is set up run the standard interpolation
-        super().build(self, data_region=data_region, **kwargs)
+        return super().build(data_region=data_region, **kwargs)

LoopStructural/modelling/features/builders/_geological_feature_builder.py

@@ -67,7 +67,7 @@ class GeologicalFeatureBuilder(BaseBuilder):
                 "interpolator is {} and must be a GeologicalInterpolator".format(type(interpolator))
             )
         self._interpolator = interpolator
-
+        self._up_to_date = self._interpolator.up_to_date
         header = (
             xyz_names()
             + val_name()
@@ -93,6 +93,13 @@ class GeologicalFeatureBuilder(BaseBuilder):
         self._orthogonal_features = {}
         self._equality_constraints = {}
 
+    def set_not_up_to_date(self, caller):
+        logger.info(
+            f"Setting {self.name} to not up to date from an instance of {caller.__class__.__name__}"
+        )
+        self._up_to_date = False
+        self._interpolator.up_to_date = False
+
     @property
     def interpolator(self):
         return self._interpolator
@@ -109,6 +116,7 @@ class GeologicalFeatureBuilder(BaseBuilder):
         else:
             self._interpolation_region = RegionEverywhere()
             self._interpolator.set_region(region=self._interpolation_region)
+        logger.info(f'Setting interpolation region {self.name}')
         self._up_to_date = False
 
     def add_data_from_data_frame(self, data_frame, overwrite=False):
@@ -156,6 +164,8 @@ class GeologicalFeatureBuilder(BaseBuilder):
             logger.error("Cannot cast {} as integer, setting step to 1".format(step))
             step = 1
         self._orthogonal_features[feature.name] = [feature, w, region, step, B]
+
+        logger.info(f"Adding orthogonal constraint {feature.name} to {self.name}")
         self._up_to_date = False
 
     def add_data_to_interpolator(self, constrained=False, force_constrained=False, **kwargs):
@@ -315,12 +325,13 @@ class GeologicalFeatureBuilder(BaseBuilder):
                     self.interpolator.support.barycentre[element_idx[::step], :],
                     vector[element_idx[::step], :],
                     w=w,
-                    B=B,
+                    b=B,
                     name=f'{feature.name}_orthogonal',
                 )
 
     def add_equality_constraints(self, feature, region, scalefactor=1.0):
         self._equality_constraints[feature.name] = [feature, region, scalefactor]
+        logger.info(f'Adding equality constraints to {self.name}')
         self._up_to_date = False
 
     def install_equality_constraints(self):
@@ -463,19 +474,22 @@ class GeologicalFeatureBuilder(BaseBuilder):
         Apply the fault to the model grid to ensure that the support
         is big enough to capture the faulted feature.
         """
+        if self.interpolator.support is not None:
 
-        origin = self.interpolator.support.origin
-        maximum = self.interpolator.support.maximum
-        pts = self.model.bounding_box.with_buffer(buffer).regular_grid(local=True)
-        for f in self.faults:
-            pts = f.apply_to_points(pts)
+            origin = self.interpolator.support.origin
+            maximum = self.interpolator.support.maximum
+            pts = self.model.bounding_box.with_buffer(buffer).regular_grid(local=True)
+            for f in self.faults:
+                pts = f.apply_to_points(pts)
 
-        origin[origin > np.min(pts, axis=0)] = np.min(pts, axis=0)[origin > np.min(pts, axis=0)]
-        maximum[maximum < np.max(pts, axis=0)] = np.max(pts, axis=0)[maximum < np.max(pts, axis=0)]
-        self.interpolator.support.origin = origin
-        self.interpolator.support.maximum = maximum
+            origin[origin > np.min(pts, axis=0)] = np.min(pts, axis=0)[origin > np.min(pts, axis=0)]
+            maximum[maximum < np.max(pts, axis=0)] = np.max(pts, axis=0)[
+                maximum < np.max(pts, axis=0)
+            ]
+            self.interpolator.support.origin = origin
+            self.interpolator.support.maximum = maximum
 
-    def build(self, fold=None, fold_weights={}, data_region=None, **kwargs):
+    def build(self, data_region=None, **kwargs):
         """
         Runs the interpolation and builds the geological feature
 
@@ -536,7 +550,9 @@ class GeologicalFeatureBuilder(BaseBuilder):
         logger.info(f'running interpolation for {self.name}')
 
         self.interpolator.solve_system(
-            solver=kwargs.get('solver', None), solver_kwargs=kwargs.get('solver_kwargs', {})
+            solver=kwargs.get('solver', 'cg'),
+            tol=kwargs.get('tol', None),
+            solver_kwargs=kwargs.get('solver_kwargs', {}),
         )
         logger.info(f'Finished building  {self.name}')
         self._up_to_date = True

LoopStructural/modelling/features/builders/_structural_frame_builder.py

@@ -110,8 +110,8 @@ class StructuralFrameBuilder:
         )  # ,region=self.region))
 
         self._frame = frame(
-            self.name,
-            [
+            name=self.name,
+            features=[
                 self.builders[0].feature,
                 self.builders[1].feature,
                 self.builders[2].feature,
@@ -235,3 +235,8 @@ class StructuralFrameBuilder:
     def up_to_date(self, callback=None):
         for i in range(3):
             self.builders[i].up_to_date(callback=callback)
+
+    def set_not_up_to_date(self, caller):
+
+        for i in range(3):
+            self.builders[i].set_not_up_to_date(caller)

LoopStructural/modelling/features/fault/__init__.py

@@ -1,3 +1,3 @@
-from ._fault_function import Composite, CubicFunction, Ones, Zeros
+from ._fault_function import Composite, CubicFunction, Ones, Zeros, FaultDisplacement
 from ._fault_function_feature import FaultDisplacementFeature
 from ._fault_segment import FaultSegment

LoopStructural/modelling/features/fault/_fault_function.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod, ABCMeta
-from typing import Optional
+from typing import Optional, List
 import numpy as np
 
 from ....utils import getLogger
@@ -367,6 +367,24 @@ class FaultDisplacement:
         gz = CubicFunction.from_dict(data["gz"])
         return cls(gx=gx, gy=gy, gz=gz)
 
+    def plot(self, range=(-1, 1), axs: Optional[List] = None):
+        try:
+            import matplotlib.pyplot as plt
+
+            if axs is None:
+                fig, ax = plt.subplots(1, 3, figsize=(15, 5))
+            for i, (name, f) in enumerate(zip(["gx", "gy", "gz"], [self.gx, self.gy, self.gz])):
+                x = np.linspace(range[0], range[1], 100)
+                ax[i].plot(x, f(x), label=name)
+                ax[i].set_title(name)
+                ax[i].set_xlabel("Fault frame coordinate")
+                ax[i].set_ylabel("Displacement")
+                ax[i].legend()
+
+        except ImportError:
+            logger.warning("matplotlib not installed, not plotting")
+            return
+
 
 class BaseFault(object):
     """ """

LoopStructural/modelling/features/fault/_fault_function_feature.py

@@ -80,3 +80,6 @@ class FaultDisplacementFeature(BaseFeature):
 
     def get_data(self, value_map: Optional[dict] = None):
         pass
+
+    def copy(self, name: Optional[str] = None):
+        raise NotImplementedError("Not implemented yet")