Remove unused methods

Author: domfournier

simpeg/dask/objective_function.py

@@ -8,7 +8,6 @@
 import numpy as np
 
 from dask.distributed import Client, Future
-from dask import array, delayed, compute
 from ..data_misfit import L2DataMisfit
 
 from simpeg.utils import validate_list_of_types
@@ -88,16 +87,6 @@ def _deriv2(objfct, multiplier, _, v):
     return multiplier * deriv2
 
 
-def _get_attr(objfct, key):
-    if isinstance(objfct, ComboObjectiveFunction):
-        attr = []
-        for objfct_ in objfct.objfcts:
-            attr.append(_get_attr(objfct_, key))
-        return attr
-
-    return objfct.nP
-
-
 def _store_model(objfct, model):
 
     if isinstance(objfct, ComboObjectiveFunction):
@@ -251,30 +240,6 @@ def __call__(self, m, f=None):
         values = self.client.gather(values)
         return np.sum(values)
 
-    @property
-    def nP(self):
-        """Number of model parameters.
-
-        Returns
-        -------
-        int
-            Number of model parameters.
-        """
-        if self._nP is None:
-            nP = []
-            for futures in self._workloads:
-                for future, worker in zip(futures, self._workers, strict=True):
-                    nP.append(
-                        self.client.submit(
-                            _get_attr,
-                            future,
-                            "nP",
-                            workers=worker,
-                        )
-                    )
-            self._nP = np.sum(self.client.gather(nP))
-        return self._nP
-
     @property
     def client(self):
         """
@@ -590,200 +555,3 @@ def residuals(self, m, f=None):
             residuals += client.gather(future_residuals)
 
         return residuals
-
-    #
-    # def broadcast_updates(self, updates: dict):
-    #     """
-    #     Set the attributes of the objective functions and simulations
-    #     """
-    #     stores = []
-    #     client = self.client
-    #     for fun, (key, value) in updates.items():
-    #         if fun not in self._lookup:
-    #             continue
-    #
-    #         future, worker = self._lookup[fun]
-    #
-    #         stores.append(
-    #             client.submit(
-    #                 _setter_broadcast,
-    #                 future,
-    #                 key,
-    #                 value,
-    #                 workers=worker,
-    #             )
-    #         )
-    #     self.client.gather(stores)  # blocking call to ensure all models were stored
-
-
-class DaskComboMisfits(ComboObjectiveFunction):
-    """
-    A composite objective function for distributed computing.
-    """
-
-    def __init__(
-        self,
-        objfcts: list[BaseObjectiveFunction],
-        multipliers=None,
-        worker: str | None = None,
-        **kwargs,
-    ):
-        self._model: np.ndarray | None = None
-
-        super().__init__(objfcts=objfcts, multipliers=multipliers, **kwargs)
-
-    def __call__(self, m, f=None):
-        self.model = m
-
-        futures = []
-        count = 0
-
-        delayed_call = delayed(_calc_objective)
-        for objfct in self.objfcts:
-            if self.multipliers[count] == 0.0:
-                continue
-
-            futures.append(delayed_call(objfct, self.multipliers[count], m))
-            count += 1
-
-        return np.sum(compute(futures)[0])
-
-    def deriv(self, m, f=None):
-        """
-        First derivative of the composite objective function is the sum of the
-        derivatives of each objective function in the list, weighted by their
-        respective multplier.
-
-        :param numpy.ndarray m: model
-        :param SimPEG.Fields f: Fields object (if applicable)
-        """
-        self.model = m
-
-        futures = []
-
-        count = 0
-
-        delayed_call = delayed(_deriv)
-        for objfct in self.objfcts:
-            if self.multipliers[count] == 0.0:  # don't evaluate the fct
-                continue
-
-            futures.append(
-                array.from_delayed(
-                    delayed_call(
-                        objfct,
-                        self.multipliers[count],
-                        m,
-                    ),
-                    shape=m.shape,
-                    dtype=float,
-                )
-            )
-
-            count += 1
-
-        return array.vstack(futures).sum(axis=0).compute()
-
-    def deriv2(self, m, v=None, f=None):
-        """
-        Second derivative of the composite objective function is the sum of the
-        second derivatives of each objective function in the list, weighted by
-        their respective multplier.
-
-        :param numpy.ndarray m: model
-        :param numpy.ndarray v: vector we are multiplying by
-        :param SimPEG.Fields f: Fields object (if applicable)
-        """
-        self.model = m
-
-        futures = []
-        count = 0
-
-        delayed_call = delayed(_deriv2)
-        for objfct in self.objfcts:
-            if self.multipliers[count] == 0.0:  # don't evaluate the fct
-                continue
-
-            futures.append(
-                array.from_delayed(
-                    delayed_call(objfct, self.multipliers[count], m, v),
-                    shape=m.shape,
-                    dtype=float,
-                )
-            )
-            count += 1
-
-        return array.vstack(futures).sum(axis=0).compute()
-
-    def get_dpred(self, m, f=None):
-        """
-        Request calculation of predicted data from all simulations.
-        """
-        self.model = m
-
-        futures = []
-        delayed_call = delayed(_calc_dpred)
-
-        for objfct in self.objfcts:
-            futures.append(delayed_call(objfct, m))
-
-        return compute(futures)[0]
-
-    def getJtJdiag(self, m, f=None):
-        """
-        Request calculation of the diagonal of JtJ from all simulations.
-        """
-        self.model = m
-
-        if getattr(self, "_jtjdiag", None) is None:
-
-            futures = []
-            delayed_call = delayed(_get_jtj_diag)
-
-            for objfct in self.objfcts:
-                futures.append(
-                    array.from_delayed(
-                        delayed_call(objfct, m), shape=m.shape, dtype=float
-                    )
-                )
-
-            self._jtjdiag = array.vstack(futures).sum(axis=0).compute()
-
-        return self._jtjdiag
-
-    def residuals(self, m, f=None):
-        """
-        Compute the residual for the data misfit.
-        """
-        self.model = m
-
-        futures = []
-
-        delayed_call = delayed(_calc_residual)
-        for objfct in self.objfcts:
-            futures.append(delayed_call(objfct, m))
-
-        return compute(futures)[0]
-
-    @property
-    def model(self):
-        return self._model
-
-    @model.setter
-    def model(self, value):
-        # Only send the model to the internal simulations if it was updated.
-        if (
-            isinstance(value, np.ndarray)
-            and isinstance(self.model, np.ndarray)
-            and np.allclose(value, self.model)
-        ):
-            return
-
-        self._jtjdiag = None
-
-        stores = []
-        delayed_call = delayed(_store_model)
-        for objfct in self.objfcts:
-            stores.append(delayed_call(objfct, value))
-        compute(stores)
-        self._model = value