simpeg · santisoler · Jan 15, 2024 · Jan 22, 2024 · Jan 22, 2024 · Jan 22, 2024
diff --git a/examples/20-published/plot_tomo_joint_with_volume.py b/examples/20-published/plot_tomo_joint_with_volume.py
@@ -59,6 +59,10 @@ def knownVolume(self):
     def knownVolume(self, value):
         self._knownVolume = utils.validate_float("knownVolume", value, min_val=0.0)
 
+    @property
+    def nP(self):
+        return "*"
+
     def __call__(self, m):
         return (self.estVol(m) - self.knownVolume) ** 2
 

diff --git a/simpeg/__init__.py b/simpeg/__init__.py
@@ -104,7 +104,6 @@
 
   objective_function.BaseObjectiveFunction
   objective_function.ComboObjectiveFunction
-  objective_function.L2ObjectiveFunction
   data_misfit.BaseDataMisfit
   data_misfit.L2DataMisfit
 

diff --git a/simpeg/data_misfit.py b/simpeg/data_misfit.py
@@ -1,47 +1,42 @@
+from abc import abstractmethod
 import numpy as np
-from .utils import Counter, sdiag, timeIt, Identity, validate_type
+from .utils import sdiag, Identity, validate_type
 from .data import Data
 from .simulation import BaseSimulation
-from .objective_function import L2ObjectiveFunction
+from .objective_function import BaseObjectiveFunction
 
 __all__ = ["L2DataMisfit"]
 
 
-class BaseDataMisfit(L2ObjectiveFunction):
+class BaseDataMisfit(BaseObjectiveFunction):
     r"""Base data misfit class.
 
-    Inherit this class to build your own data misfit function. The ``BaseDataMisfit``
-    class inherits the :py:class:`simpeg.objective_function.L2ObjectiveFunction`.
-    And as a result, it is limited to building data misfit functions of the form:
+    Inherit this class to build your own data misfit function.
 
     .. important::
+
         This class is not meant to be instantiated. You should inherit from it to
         create your own data misfit class.
 
-    .. math::
-        \phi_d (\mathbf{m}) = \| \mathbf{W} f(\mathbf{m}) \|_2^2
-
-    where :math:`\mathbf{m}` is the model vector, :math:`\mathbf{W}` is a linear weighting
-    matrix, and :math:`f` is a mapping function that acts on the model.
-
     Parameters
     ----------
     data : simpeg.data.Data
         A SimPEG data object.
     simulation : simpeg.simulation.BaseSimulation
         A SimPEG simulation object.
-    debug : bool
-        Print debugging information.
-    counter : None or simpeg.utils.Counter
-        Assign a SimPEG ``Counter`` object to store iterations and run-times.
     """
 
-    def __init__(self, data, simulation, debug=False, counter=None, **kwargs):
-        super().__init__(has_fields=True, debug=debug, counter=counter, **kwargs)
-
+    def __init__(self, data, simulation):
         self.data = data
         self.simulation = simulation
 
+    @property
+    def has_fields(self):
+        """
+        Data misfits always have fields.
+        """
+        return True
+
     @property
     def data(self):
         """A SimPEG data object.
@@ -74,36 +69,26 @@
             "simulation", value, BaseSimulation, cast=False
         )
 
-    @property
-    def debug(self):
-        """Print debugging information.
-
-        Returns
-        -------
-        bool
-            Print debugging information.
+    @abstractmethod
+    def __call__(self, model, f=None) -> float:
         """
-        return self._debug
-
-    @debug.setter
-    def debug(self, value):
-        self._debug = validate_type("debug", value, bool)
-
-    @property
-    def counter(self):
-        """SimPEG ``Counter`` object to store iterations and run-times.
+        Evaluate the objective function for a given model.
+        """
+        pass
 
-        Returns
-        -------
-        None or simpeg.utils.Counter
-            SimPEG ``Counter`` object to store iterations and run-times.
+    @abstractmethod
+    def deriv(self, model):
+        """
+        Gradient of the objective function evaluated on a given model.
         """
-        return self._counter
+        pass
 
-    @counter.setter
-    def counter(self, value):
-        if value is not None:
-            value = validate_type("counter", value, Counter, cast=False)
+    @abstractmethod
+    def deriv2(self, model):
+        """
+        Hessian of the objective function evaluated on a given model.
+        """
+        pass
 
     @property
     def nP(self):
@@ -114,9 +99,7 @@
         int
             Number of model parameters.
         """
-        if self._mapping is not None:
-            return self.mapping.nP
-        elif self.simulation.model is not None:
+        if self.simulation.model is not None:
             return len(self.simulation.model)
         else:
             return "*"
@@ -147,15 +130,8 @@
 
     @property
     def W(self):
-        r"""The data weighting matrix.
-
-        For a discrete least-squares data misfit function of the form:
-
-        .. math::
-            \phi_d (\mathbf{m}) = \| \mathbf{W} \mathbf{f}(\mathbf{m}) \|_2^2
-
-        :math:`\mathbf{W}` is a linear weighting matrix, :math:`\mathbf{m}` is the model vector,
-        and :math:`\mathbf{f}` is a discrete mapping function that acts on the model vector.
+        """
+        The data weighting matrix.
 
         Returns
         -------
@@ -165,22 +141,22 @@
 
         if getattr(self, "_W", None) is None:
             if self.data is None:
-                raise Exception(
+                raise TypeError(
                     "data with standard deviations must be set before the data "
                     "misfit can be constructed. Please set the data: "
                     "dmis.data = Data(dobs=dobs, relative_error=rel"
                     ", noise_floor=eps)"
                 )
             standard_deviation = self.data.standard_deviation
             if standard_deviation is None:
-                raise Exception(
+                raise TypeError(
                     "data standard deviations must be set before the data misfit "
                     "can be constructed (data.relative_error = 0.05, "
                     "data.noise_floor = 1e-5), alternatively, the W matrix "
                     "can be set directly (dmisfit.W = 1./standard_deviation)"
                 )
             if any(standard_deviation <= 0):
-                raise Exception(
+                raise ValueError(
                     "data.standard_deviation must be strictly positive to construct "
                     "the W matrix. Please set data.relative_error and or "
                     "data.noise_floor."
@@ -205,9 +181,9 @@
     def residual(self, m, f=None):
         r"""Computes the data residual vector for a given model.
 
-        Where :math:`\mathbf{d}_\text{obs}` is the observed data vector and :math:`\mathbf{d}_\text{pred}`
-        is the predicted data vector for a model vector :math:`\mathbf{m}`, this function
-        computes the data residual:
+        Where :math:`\mathbf{d}_\text{obs}` is the observed data vector and
+        :math:`\mathbf{d}_\text{pred}` is the predicted data vector for a model
+        vector :math:`\mathbf{m}`, this method computes the data residual:
 
         .. math::
             \mathbf{r} = \mathbf{d}_\text{pred} - \mathbf{d}_\text{obs}
@@ -255,20 +231,14 @@
         A SimPEG data object that has observed data and uncertainties.
     simulation : simpeg.simulation.BaseSimulation
         A SimPEG simulation object.
-    debug : bool
-        Print debugging information.
-    counter : None or simpeg.utils.Counter
-        Assign a SimPEG ``Counter`` object to store iterations and run-times.
     """
 
-    @timeIt
     def __call__(self, m, f=None):
         """Evaluate the residual for a given model."""
 
         R = self.W * self.residual(m, f=f)
         return np.vdot(R, R)
 
-    @timeIt
     def deriv(self, m, f=None):
         r"""Gradient of the data misfit function evaluated for the model provided.
 
@@ -297,7 +267,6 @@
             m, self.W.T * (self.W * self.residual(m, f=f)), f=f
         )
 
-    @timeIt
     def deriv2(self, m, v, f=None):
         r"""Hessian of the data misfit function evaluated for the model provided.