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

LoopStructural/interpolators/_surfe_wrapper.py

@@ -2,15 +2,16 @@
 Wrapper for using surfepy
 """
 
-from ..utils.helper import get_vectors
+from ..utils.maths import get_vectors
 from ..interpolators import GeologicalInterpolator
 
 import numpy as np
 
 from ..utils import getLogger
+import surfepy
+from typing import Optional
 
 logger = getLogger(__name__)
-import surfepy
 
 
 class SurfeRBFInterpolator(GeologicalInterpolator):
@@ -19,6 +20,8 @@ class SurfeRBFInterpolator(GeologicalInterpolator):
     def __init__(self, method="single_surface"):
         GeologicalInterpolator.__init__(self)
         self.surfe = None
+        if not method:
+            method = "single_surface"
         if method == "single_surface":
             logger.info("Using single surface interpolator")
             self.surfe = surfepy.Surfe_API(1)
@@ -29,7 +32,10 @@ class SurfeRBFInterpolator(GeologicalInterpolator):
             logger.info("Using surfe horizon")
             self.surfe = surfepy.Surfe_API(4)
 
-    def add_gradient_ctr_pts(self):
+    def set_region(self, **kwargs):
+        pass
+
+    def add_gradient_constraints(self, w=1):
         points = self.get_gradient_constraints()
         if points.shape[0] > 0:
             logger.info("Adding ")
@@ -40,12 +46,12 @@ class SurfeRBFInterpolator(GeologicalInterpolator):
             self.surfe.SetTangentConstraints(strike_vector)
             self.surfe.SetTangentConstraints(dip_vector)
 
-    def add_norm_ctr_pts(self):
+    def add_norm_constraints(self, w=1):
         points = self.get_norm_constraints()
         if points.shape[0] > 0:
             self.surfe.SetPlanarConstraints(points[:, :6])
 
-    def add_ctr_pts(self):
+    def add_value_constraints(self, w=1):
 
         points = self.get_value_constraints()
         if points.shape[0] > 0:
@@ -59,15 +65,39 @@ class SurfeRBFInterpolator(GeologicalInterpolator):
                     points[i, 3],
                 )
 
-    def add_tangent_ctr_pts(self):
+    def add_interface_constraints(self, w=1):
+        pass
+
+    def add_value_inequality_constraints(self, w=1):
+        ## inequalities are causing a segfault
+        # points = self.get_value_inequality_constraints()
+        # if points.shape[0] > 0:
+        #     #
+        #     self.surfe.AddValueInequalityConstraints(points[:,0],points[:,1],points[:,2],points[:,3])
+        pass
+
+    def add_inequality_pairs_constraints(
+        self,
+        w: float = 1.0,
+        upper_bound=np.finfo(float).eps,
+        lower_bound=-np.inf,
+        pairs: Optional[list] = None,
+    ):
+        # self.surfe.Add
+        pass
+
+    def reset(self):
+        pass
+
+    def add_tangent_constraints(self, w=1):
         points = self.get_tangent_constraints()
         if points.shape[0] > 0:
             self.surfe.SetTangentConstraints(points[:, :6])
 
-    def _solve(self, **kwargs):
+    def solve_system(self, **kwargs):
         self.surfe.ComputeInterpolant()
 
-    def _setup_interpolator(self, **kwargs):
+    def setup_interpolator(self, **kwargs):
         """
         Setup the interpolator
 
@@ -90,10 +120,10 @@ class SurfeRBFInterpolator(GeologicalInterpolator):
 
 
         """
-        self.add_gradient_ctr_pts()
-        self.add_norm_ctr_pts()
-        self.add_ctr_pts()
-        self.add_tangent_ctr_pts()
+        self.add_gradient_constraints()
+        self.add_norm_constraints()
+        self.add_value_constraints()
+        self.add_tangent_constraints()
 
         kernel = kwargs.get("kernel", "r3")
         logger.info("Setting surfe RBF kernel to %s" % kernel)

LoopStructural/interpolators/supports/_2d_base_unstructured.py

@@ -338,3 +338,19 @@ class BaseUnstructured2d(BaseSupport):
         """
         verts, c, tri, inside = self.get_element_for_location(pos, return_verts=False)
         return self.evaluate_shape_derivatives(pos, tri)
+
+    def vtk(self, node_properties={}, cell_properties={}):
+        """
+        Create a vtk unstructured grid from the mesh
+        """
+        import pyvista as pv
+
+        grid = pv.UnstructuredGrid()
+        grid.points = self.nodes
+        grid.cell_types = np.ones(self.elements.shape[0]) * pv.vtk.VTK_TRIANGLE
+        grid.cells = np.c_[np.ones(self.elements.shape[0]) * 3, self.elements]
+        for key, value in node_properties.items():
+            grid.point_data[key] = value
+        for key, value in cell_properties.items():
+            grid.cell_data[key] = value
+        return grid

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

@@ -134,7 +134,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 +158,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 +250,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 +346,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 +463,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 +476,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)
@@ -468,3 +474,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 (

LoopStructural/modelling/core/geological_model.py

@@ -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"

LoopStructural/modelling/features/_analytical_feature.py

@@ -28,7 +28,16 @@ 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)
@@ -48,16 +57,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,13 +74,13 @@ 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
 

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
@@ -131,7 +132,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 +150,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 +170,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/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)