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

LoopStructural/interpolators/supports/_2d_structured_grid.py

@@ -5,10 +5,11 @@ Cartesian grid for fold interpolator
 
 import logging
 
-from typing import Tuple
 import numpy as np
 from . import SupportType
 from ._base_support import BaseSupport
+from typing import Dict, Tuple
+from .._operator import Operator
 
 logger = logging.getLogger(__name__)
 
@@ -33,7 +34,7 @@ class StructuredGrid2D(BaseSupport):
         step_vector - 2d list or numpy array of int
         """
         self.type = SupportType.StructuredGrid2D
-        self.nsteps = np.array(nsteps)
+        self.nsteps = np.ceil(np.array(nsteps)).astype(int)
         self.step_vector = np.array(step_vector)
         self.origin = np.array(origin)
         self.maximum = origin + self.nsteps * self.step_vector
@@ -261,13 +262,22 @@ class StructuredGrid2D(BaseSupport):
         if "indexes" in kwargs:
             indexes = kwargs["indexes"]
         if "indexes" not in kwargs:
-            ii = []
-            jj = []
-            for i in range(1, self.nsteps[0] - 1):
-                for j in range(1, self.nsteps[1] - 1):
-                    ii.append(i)
-                    jj.append(j)
-            indexes = np.array([ii, jj])
+            gi = np.arange(self.n_nodes)
+            indexes = self.global_index_to_node_index(gi)
+            edge_mask = (
+                (indexes[:, 0] > 0)
+                & (indexes[:, 0] < self.nsteps[0] - 1)
+                & (indexes[:, 1] > 0)
+                & (indexes[:, 1] < self.nsteps[1] - 1)
+            )
+            indexes = indexes[edge_mask, :].T
+            # ii = []
+            # jj = []
+            # for i in range(1, self.nsteps[0] - 1):
+            #     for j in range(1, self.nsteps[1] - 1):
+            #         ii.append(i)
+            #         jj.append(j)
+            # indexes = np.array([ii, jj])
         # indexes = np.array(indexes).T
         if indexes.ndim != 2:
             print(indexes.ndim)
@@ -460,3 +470,28 @@ class StructuredGrid2D(BaseSupport):
 
     def onGeometryChange(self):
         pass
+
+    def vtk(self, node_properties={}, cell_properties={}):
+        raise NotImplementedError("VTK output not implemented for structured grid")
+        pass
+
+    def get_operators(self, weights: Dict[str, float]) -> Dict[str, Tuple[np.ndarray, float]]:
+        """Get
+
+        Parameters
+        ----------
+        weights : Dict[str, float]
+            _description_
+
+        Returns
+        -------
+        Dict[str, Tuple[np.ndarray, float]]
+            _description_
+        """
+        # in a map we only want the xy operators
+        operators = {
+            'dxy': (Operator.Dxy_mask[1, :, :], weights['dxy'] * 2),
+            'dxx': (Operator.Dxx_mask[1, :, :], weights['dxx']),
+            'dyy': (Operator.Dyy_mask[1, :, :], weights['dyy']),
+        }
+        return operators

LoopStructural/interpolators/supports/_3d_base_structured.py

@@ -41,6 +41,10 @@ class BaseStructuredSupport(BaseSupport):
             raise LoopException("nsteps cannot be zero")
         if np.any(nsteps < 0):
             raise LoopException("nsteps cannot be negative")
+        if np.any(nsteps < 3):
+            raise LoopException(
+                "step vector cannot be less than 3. Try increasing the resolution of the interpolator"
+            )
         self._nsteps = np.array(nsteps, dtype=int) + 1
         self._step_vector = np.array(step_vector)
         self._origin = np.array(origin)
@@ -134,7 +138,15 @@ class BaseStructuredSupport(BaseSupport):
         origin = np.array(origin)
         length = self.maximum - origin
         length /= self.step_vector
-        self._nsteps = np.ceil(length).astype(int)
+        self._nsteps = np.ceil(length).astype(np.int64)
+        self._nsteps[self._nsteps == 0] = (
+            3  # need to have a minimum of 3 elements to apply the finite difference mask
+        )
+        if np.any(~(self._nsteps > 0)):
+            logger.error(
+                f"Cannot resize the interpolation support. The proposed number of steps is {self._nsteps}, these must be all > 0"
+            )
+            raise ValueError("Cannot resize the interpolation support.")
         self._origin = origin
         self.onGeometryChange()
 
@@ -150,7 +162,13 @@ class BaseStructuredSupport(BaseSupport):
         maximum = np.array(maximum, dtype=float)
         length = maximum - self.origin
         length /= self.step_vector
-        self._nsteps = np.ceil(length).astype(int) + 1
+        self._nsteps = np.ceil(length).astype(np.int64)
+        self._nsteps[self._nsteps == 0] = 3
+        if np.any(~(self._nsteps > 0)):
+            logger.error(
+                f"Cannot resize the interpolation support. The proposed number of steps is {self._nsteps}, these must be all > 0"
+            )
+            raise ValueError("Cannot resize the interpolation support.")
         self.onGeometryChange()
 
     @property
@@ -236,6 +254,7 @@ class BaseStructuredSupport(BaseSupport):
         cell_indexes[inside, 0] = x[inside] // self.step_vector[None, 0]
         cell_indexes[inside, 1] = y[inside] // self.step_vector[None, 1]
         cell_indexes[inside, 2] = z[inside] // self.step_vector[None, 2]
+
         return cell_indexes, inside
 
     def position_to_cell_global_index(self, pos):
@@ -331,12 +350,9 @@ class BaseStructuredSupport(BaseSupport):
         return corner_indexes
 
     def position_to_cell_corners(self, pos):
-
         cell_indexes, inside = self.position_to_cell_index(pos)
         corner_indexes = self.cell_corner_indexes(cell_indexes)
-
         globalidx = self.global_node_indices(corner_indexes)
-
         # if global index is not inside the support set to -1
         globalidx[~inside] = -1
         return globalidx, inside
@@ -451,7 +467,7 @@ class BaseStructuredSupport(BaseSupport):
         # all elements are the same size
         return 1.0
 
-    def vtk(self):
+    def vtk(self, node_properties={}, cell_properties={}):
         try:
             import pyvista as pv
         except ImportError:
@@ -464,4 +480,9 @@ class BaseStructuredSupport(BaseSupport):
             [np.zeros(self.elements.shape[0], dtype=int)[:, None] + 8, self.elements]
         )
         elements = elements.flatten()
-        return pv.UnstructuredGrid(elements, celltype, self.nodes)
+        grid = pv.UnstructuredGrid(elements, celltype, self.nodes)
+        for key, value in node_properties.items():
+            grid[key] = value
+        for key, value in cell_properties.items():
+            grid.cell_arrays[key] = value
+        return grid

LoopStructural/interpolators/supports/_3d_structured_grid.py

@@ -5,8 +5,10 @@ Cartesian grid for fold interpolator
 
 import numpy as np
 
-from ._3d_base_structured import BaseStructuredSupport
+from LoopStructural.interpolators._operator import Operator
 
+from ._3d_base_structured import BaseStructuredSupport
+from typing import Dict, Tuple
 from . import SupportType
 
 from LoopStructural.utils import getLogger
@@ -158,13 +160,18 @@ class StructuredGrid(BaseStructuredSupport):
         if "indexes" in kwargs:
             indexes = kwargs["indexes"]
         if "indexes" not in kwargs:
-            indexes = np.array(
-                np.meshgrid(
-                    np.arange(1, self.nsteps[0] - 1),
-                    np.arange(1, self.nsteps[1] - 1),
-                    np.arange(1, self.nsteps[2] - 1),
-                )
-            ).reshape((3, -1))
+            gi = np.arange(self.n_nodes)
+            indexes = self.global_index_to_node_index(gi)
+            edge_mask = (
+                (indexes[:, 0] > 0)
+                & (indexes[:, 0] < self.nsteps[0] - 1)
+                & (indexes[:, 1] > 0)
+                & (indexes[:, 1] < self.nsteps[1] - 1)
+                & (indexes[:, 2] > 0)
+                & (indexes[:, 2] < self.nsteps[2] - 1)
+            )
+            indexes = indexes[edge_mask, :].T
+
         # indexes = np.array(indexes).T
         if indexes.ndim != 2:
             return
@@ -291,7 +298,6 @@ class StructuredGrid(BaseStructuredSupport):
             )
         idc, inside = self.position_to_cell_corners(evaluation_points)
         # print(idc[inside,:], self.n_nodes,inside)
-
         if idc.shape[0] != inside.shape[0]:
             raise ValueError("index does not match number of nodes")
         v = np.zeros(idc.shape)
@@ -336,9 +342,6 @@ class StructuredGrid(BaseStructuredSupport):
         idc, inside = self.position_to_cell_corners(evaluation_points)
         T = np.zeros((idc.shape[0], 3, 8))
         T[inside, :, :] = self.get_element_gradient_for_location(evaluation_points[inside, :])[1]
-        # indices = np.array([self.position_to_cell_index(evaluation_points)])
-        # idc = self.global_indicies(indices.swapaxes(0,1))
-        # print(idc)
         if np.max(idc[inside, :]) > property_array.shape[0]:
             cix, ciy, ciz = self.position_to_cell_index(evaluation_points)
             if not np.all(cix[inside] < self.nsteps_cells[0]):
@@ -468,3 +471,26 @@ class StructuredGrid(BaseStructuredSupport):
             "type": self.type.numerator,
             **super().to_dict(),
         }
+
+    def get_operators(self, weights: Dict[str, float]) -> Dict[str, Tuple[np.ndarray, float]]:
+        """Gets the operators specific to this support
+
+        Parameters
+        ----------
+        weights : Dict[str, float]
+            weight value per operator
+
+        Returns
+        -------
+        operators
+            A dictionary with a numpy array and float weight
+        """
+        operators = {
+            'dxy': (Operator.Dxy_mask, weights['dxy'] / 4),
+            'dyz': (Operator.Dyz_mask, weights['dyz'] / 4),
+            'dxz': (Operator.Dxz_mask, weights['dxz'] / 4),
+            'dxx': (Operator.Dxx_mask, weights['dxx'] / 1),
+            'dyy': (Operator.Dyy_mask, weights['dyy'] / 1),
+            'dzz': (Operator.Dzz_mask, weights['dzz'] / 1),
+        }
+        return operators

LoopStructural/interpolators/supports/_3d_structured_tetra.py

@@ -729,8 +729,7 @@ class TetMesh(BaseStructuredSupport):
 
         return neighbours
 
-    @property
-    def vtk(self):
+    def vtk(self, node_properties={}, cell_properties={}):
         try:
             import pyvista as pv
         except ImportError:
@@ -743,4 +742,9 @@ class TetMesh(BaseStructuredSupport):
             [np.zeros(self.elements.shape[0], dtype=int)[:, None] + 4, self.elements]
         )
         elements = elements.flatten()
-        return pv.UnstructuredGrid(elements, celltype, self.nodes)
+        grid = pv.UnstructuredGrid(elements, celltype, self.nodes)
+        for prop in node_properties:
+            grid[prop] = node_properties[prop]
+        for prop in cell_properties:
+            grid.cell_arrays[prop] = cell_properties[prop]
+        return grid

LoopStructural/interpolators/supports/_3d_unstructured_tetra.py

@@ -621,7 +621,7 @@ class UnStructuredTetMesh(BaseSupport):
         """
         return self.neighbours
 
-    def vtk(self):
+    def vtk(self, node_properties={}, cell_properties={}):
         try:
             import pyvista as pv
         except ImportError:
@@ -634,4 +634,10 @@ class UnStructuredTetMesh(BaseSupport):
             [np.zeros(self.elements.shape[0], dtype=int)[:, None] + 4, self.elements]
         )
         elements = elements.flatten()
-        return pv.UnstructuredGrid(elements, celltype, self.nodes)
+        grid = pv.UnstructuredGrid(elements, celltype, self.nodes)
+        for key, value in node_properties.items():
+            grid[key] = value
+        for key, value in cell_properties.items():
+            grid.cell_arrays[key] = value
+
+        return grid

LoopStructural/interpolators/supports/__init__.py

@@ -18,6 +18,7 @@ class SupportType(IntEnum):
     BaseStructured = 6
     TetMesh = 10
     P2UnstructuredTetMesh = 11
+    DataSupported = 12
 
 
 from ._2d_base_unstructured import BaseUnstructured2d
@@ -29,6 +30,11 @@ from ._3d_unstructured_tetra import UnStructuredTetMesh
 from ._3d_structured_tetra import TetMesh
 from ._3d_p2_tetra import P2UnstructuredTetMesh
 
+
+def no_support(*args, **kwargs):
+    return None
+
+
 support_map = {
     SupportType.StructuredGrid2D: StructuredGrid2D,
     SupportType.StructuredGrid: StructuredGrid,
@@ -37,6 +43,7 @@ support_map = {
     SupportType.P2Unstructured2d: P2Unstructured2d,
     SupportType.TetMesh: TetMesh,
     SupportType.P2UnstructuredTetMesh: P2UnstructuredTetMesh,
+    SupportType.DataSupported: no_support,
 }
 
 from ._support_factory import SupportFactory

LoopStructural/interpolators/supports/_base_support.py

@@ -112,3 +112,10 @@ class BaseSupport(metaclass=ABCMeta):
         Return the element size
         """
         pass
+
+    @abstractmethod
+    def vtk(self, node_properties={}, cell_properties={}):
+        """
+        Return a vtk object
+        """
+        pass

LoopStructural/modelling/__init__.py

@@ -6,12 +6,12 @@ Geological modelling classes and functions
 __all__ = [
     "GeologicalModel",
     "ProcessInputData",
-    "Loop3DView",
     "Map2LoopProcessor",
     "LoopProjectfileProcessor",
 ]
 from ..utils import getLogger
 from ..utils import LoopImportError
+from .core.geological_model import GeologicalModel
 
 logger = getLogger(__name__)
 from ..modelling.input import (
@@ -25,5 +25,3 @@ except (LoopImportError, ImportError):
     logger.warning(
         "Cannot use LoopProjectfileProcessor: Loop project file cannot be imported, try installing LoopProjectFile"
     )
-# from LoopStructural.modelling.features import StructuralFrame
-# from LoopStructural.modelling.features.fault import FaultSegment

LoopStructural/modelling/core/geological_model.py

@@ -649,7 +649,7 @@ class GeologicalModel:
             for g in stratigraphic_column.keys():
                 for u in stratigraphic_column[g].keys():
                     stratigraphic_column[g][u]["colour"] = cmap_colours[ci, :]
-
+                    ci += 1
         self.stratigraphic_column = stratigraphic_column
 
     def create_and_add_foliation(
@@ -825,8 +825,6 @@ class GeologicalModel:
 
         fold = FoldEvent(fold_frame, name=f"Fold_{foliation_data}", invert_norm=invert_fold_norm)
 
-        if "fold_weights" not in kwargs:
-            kwargs["fold_weights"] = {}
         if interpolatortype != "DFI":
             logger.warning("Folded foliation only supports DFI interpolator, changing to DFI")
             interpolatortype = "DFI"
@@ -1184,7 +1182,7 @@ class GeologicalModel:
                 logger.debug(f"Reached unconformity {f.name}")
                 break
             logger.debug(f"Adding {uc_feature.name} as unconformity to {f.name}")
-            if f.type == FeatureType.FAULT:
+            if f.type == FeatureType.FAULT or f.type == FeatureType.INACTIVEFAULT:
                 continue
             if f == feature:
                 continue
@@ -1419,7 +1417,7 @@ class GeologicalModel:
         return fault
 
     # TODO move rescale to bounding box/transformer
-    def rescale(self, points: np.ndarray, inplace: bool = True) -> np.ndarray:
+    def rescale(self, points: np.ndarray, inplace: bool = False) -> np.ndarray:
         """
         Convert from model scale to real world scale - in the future this
         should also do transformations?
@@ -1442,7 +1440,7 @@ class GeologicalModel:
         return points
 
     # TODO move scale to bounding box/transformer
-    def scale(self, points: np.ndarray, inplace: bool = True) -> np.ndarray:
+    def scale(self, points: np.ndarray, inplace: bool = False) -> np.ndarray:
         """Take points in UTM coordinates and reproject
         into scaled model space
 
@@ -1811,7 +1809,7 @@ class GeologicalModel:
         grid = self.bounding_box.structured_grid(name=name)
 
         grid.cell_properties['stratigraphy'] = self.evaluate_model(
-            self.bounding_box.cell_centers(), scale=False
+            self.rescale(self.bounding_box.cell_centers())
         )
         return grid, self.stratigraphic_ids()
 
@@ -1826,6 +1824,7 @@ class GeologicalModel:
     ):
         path = pathlib.Path(filename)
         extension = path.suffix
+        parent = path.parent
         name = path.stem
         stratigraphic_surfaces = self.get_stratigraphic_surfaces()
         if fault_surfaces:
@@ -1834,19 +1833,19 @@ class GeologicalModel:
                 if extension == ".geoh5" or extension == '.omf':
                     s.save(filename)
                 else:
-                    s.save(f'{name}_{s.name}.{extension}')
+                    s.save(f'{parent}/{name}_{s.name}{extension}')
         if stratigraphic_surfaces:
             for s in self.get_stratigraphic_surfaces():
                 if extension == ".geoh5" or extension == '.omf':
                     s.save(filename)
                 else:
-                    s.save(f'{name}_{s.name}.{extension}')
+                    s.save(f'{parent}/{name}_{s.name}{extension}')
         if block_model:
             grid, ids = self.get_block_model()
             if extension == ".geoh5" or extension == '.omf':
                 grid.save(filename)
             else:
-                grid.save(f'{name}_block_model.{extension}')
+                grid.save(f'{parent}/{name}_block_model{extension}')
         if stratigraphic_data:
             if self.stratigraphic_column is not None:
                 for group in self.stratigraphic_column.keys():
@@ -1856,7 +1855,7 @@ class GeologicalModel:
                         if extension == ".geoh5" or extension == '.omf':
                             data.save(filename)
                         else:
-                            data.save(f'{name}_{group}_data.{extension}')
+                            data.save(f'{parent}/{name}_{group}_data{extension}')
         if fault_data:
             for f in self.fault_names():
                 for d in self.__getitem__(f).get_data():
@@ -1864,4 +1863,4 @@ class GeologicalModel:
 
                         d.save(filename)
                     else:
-                        d.save(f'{name}_{group}.{extension}')
+                        d.save(f'{parent}/{name}_{group}{extension}')

LoopStructural/modelling/features/__init__.py

@@ -30,3 +30,4 @@ from ._cross_product_geological_feature import CrossProductGeologicalFeature
 
 from ._unconformity_feature import UnconformityFeature
 from ._analytical_feature import AnalyticalGeologicalFeature
+from ._projected_vector_feature import ProjectedVectorFeature

LoopStructural/modelling/features/_analytical_feature.py

@@ -28,10 +28,27 @@ class AnalyticalGeologicalFeature(BaseFeature):
         list of FaultSegments that affect this feature
     """
 
-    def __init__(self, name, vector, origin, regions=[], faults=[], model=None, builder=None):
+    def __init__(
+        self,
+        name: str,
+        vector: np.ndarray,
+        origin: np.ndarray,
+        regions=[],
+        faults=[],
+        model=None,
+        builder=None,
+    ):
         BaseFeature.__init__(self, name, model, faults, regions, builder)
-        self.vector = np.array(vector, dtype=float)
-        self.origin = np.array(origin, dtype=float)
+        try:
+            self.vector = np.array(vector, dtype=float).reshape(3)
+        except ValueError:
+            logger.error("AnalyticalGeologicalFeature: vector must be a 3 element array")
+            raise ValueError("vector must be a 3 element array")
+        try:
+            self.origin = np.array(origin, dtype=float).reshape(3)
+        except ValueError:
+            logger.error("AnalyticalGeologicalFeature: origin must be a 3 element array")
+            raise ValueError("origin must be a 3 element array")
         self.type = FeatureType.ANALYTICAL
 
     def to_json(self):
@@ -48,16 +65,16 @@ class AnalyticalGeologicalFeature(BaseFeature):
         json["origin"] = self.origin.tolist()
         return json
 
-    def evaluate_value(self, xyz, ignore_regions=False):
-        xyz = np.array(xyz)
-        if len(xyz.shape) == 1:
-            xyz = xyz[None, :]
-        if len(xyz.shape) != 2:
+    def evaluate_value(self, pos: np.ndarray, ignore_regions=False):
+        pos = np.array(pos)
+        if len(pos.shape) == 1:
+            pos = pos[None, :]
+        if len(pos.shape) != 2:
             raise ValueError("xyz must be a 1D or 2D array")
-        xyz2 = np.zeros(xyz.shape)
-        xyz2[:] = xyz[:]
+        xyz2 = np.zeros(pos.shape)
+        xyz2[:] = pos[:]
         for f in self.faults:
-            xyz2[:] = f.apply_to_points(xyz)
+            xyz2[:] = f.apply_to_points(pos)
         if self.model is not None:
             xyz2[:] = self.model.rescale(xyz2, inplace=False)
         xyz2[:] = xyz2 - self.origin
@@ -65,15 +82,28 @@ class AnalyticalGeologicalFeature(BaseFeature):
         distance = normal[0] * xyz2[:, 0] + normal[1] * xyz2[:, 1] + normal[2] * xyz2[:, 2]
         return distance / np.linalg.norm(self.vector)
 
-    def evaluate_gradient(self, xyz, ignore_regions=False):
-        xyz = np.array(xyz)
-        if len(xyz.shape) == 1:
-            xyz = xyz[None, :]
-        if len(xyz.shape) != 2:
-            raise ValueError("xyz must be a 1D or 2D array")
-        v = np.zeros(xyz.shape)
+    def evaluate_gradient(self, pos: np.ndarray, ignore_regions=False):
+        pos = np.array(pos)
+        if len(pos.shape) == 1:
+            pos = pos[None, :]
+        if len(pos.shape) != 2:
+            raise ValueError("pos must be a 1D or 2D array")
+        v = np.zeros(pos.shape)
         v[:, :] = self.vector[None, :]
         return v
 
     def get_data(self, value_map: Optional[dict] = None):
         return
+
+    def copy(self, name: Optional[str] = None):
+        if name is None:
+            name = self.name
+        return AnalyticalGeologicalFeature(
+            name,
+            self.vector.copy(),
+            self.origin.copy(),
+            list(self.regions),
+            list(self.faults),
+            self.model,
+            self.builder,
+        )

LoopStructural/modelling/features/_base_geological_feature.py

@@ -291,11 +291,29 @@ class BaseFeature(metaclass=ABCMeta):
             if self.model is None:
                 raise ValueError("Must specify bounding box")
             bounding_box = self.model.bounding_box
-        callable = lambda xyz: self.evaluate_value(self.model.scale(xyz))
-        isosurfacer = LoopIsosurfacer(bounding_box, callable=callable)
-        if name is None and self.name is not None:
-            name = self.name
-        return isosurfacer.fit(value, name)
+        regions = self.regions
+        try:
+            self.regions = [
+                r for r in self.regions if r.name != self.name and r.parent.name != self.name
+            ]
+
+            callable = lambda xyz: (
+                self.evaluate_value(self.model.scale(xyz))
+                if self.model is not None
+                else self.evaluate_value(xyz)
+            )
+            isosurfacer = LoopIsosurfacer(bounding_box, callable=callable)
+            if name is None and self.name is not None:
+                name = self.name
+            surfaces = isosurfacer.fit(value, name)
+        except Exception as e:
+            logger.error(f"Failed to create surface for {self.name} at value {value}")
+            logger.error(e)
+            surfaces = []
+        finally:
+            self.regions = regions
+
+        return surfaces
 
     def scalar_field(self, bounding_box=None):
         """Create a scalar field for the feature
@@ -341,10 +359,10 @@ class BaseFeature(metaclass=ABCMeta):
             if self.model is None:
                 raise ValueError("Must specify bounding box")
             bounding_box = self.model.bounding_box
-        grid = bounding_box.vtk()
-        points = grid.points
+        points = bounding_box.cell_centers()
         value = self.evaluate_gradient(points)
-
+        if self.model is not None:
+            points = self.model.rescale(points)
         return VectorPoints(points, value, self.name)
 
     @abstractmethod
@@ -362,3 +380,14 @@ class BaseFeature(metaclass=ABCMeta):
             dictionary of data
         """
         raise NotImplementedError
+
+    @abstractmethod
+    def copy(self, name: Optional[str] = None):
+        """Copy the feature
+
+        Returns
+        -------
+        BaseFeature
+            copied feature
+        """
+        raise NotImplementedError

LoopStructural/modelling/features/_cross_product_geological_feature.py

@@ -98,3 +98,10 @@ class CrossProductGeologicalFeature(BaseFeature):
 
     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 CrossProductGeologicalFeature(
+            name, self.geological_feature_a, self.geological_feature_b
+        )