pyMOTO 1.3.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

pymoto/modules/io.py

@@ -14,7 +14,7 @@ from pymoto import Module
 from .assembly import DomainDefinition
 
 
-class _FigModule(Module):
+class FigModule(Module):
     """ Abstract base class for any module which produces a figure
 
     Keyword Args:
@@ -55,7 +55,7 @@ class _FigModule(Module):
         plt.close(self.fig)
 
 
-class PlotDomain(_FigModule):
+class PlotDomain(FigModule):
     """ Plots the densities of a domain (2D or 3D)
 
     Input Signal:
@@ -96,10 +96,16 @@ class PlotDomain(_FigModule):
             self.im.set_data(data)
         else:
             ax = self.fig.add_subplot(111)
-            self.im = ax.imshow(data, origin='lower', cmap=self.cmap)
+            Lx = self.domain.nelx * self.domain.unitx
+            Ly = self.domain.nely * self.domain.unity
+            self.im = ax.imshow(data, cmap=self.cmap, origin='lower', extent=(0.0, Lx, 0.0, Ly))
             self.cbar = self.fig.colorbar(self.im, orientation='horizontal')
             ax.set(xlabel='x', ylabel='y')
-        clim = [np.min(data), np.max(data)] if self.clim is None else self.clim
+        vmin, vmax = np.min(data), np.max(data)
+        if vmin < 0:
+            vabs = max(abs(vmin), abs(vmax))
+            vmin, vmax = -vabs, vabs
+        clim = [vmin, vmax] if self.clim is None else self.clim
         self.im.set_clim(vmin=clim[0], vmax=clim[1])
 
     def _plot_3d(self, x):
@@ -138,7 +144,7 @@ class PlotDomain(_FigModule):
         self.fac = ax.voxels(sel, facecolors=colors, linewidth=0.5, edgecolors='k')
 
 
-class PlotGraph(_FigModule):
+class PlotGraph(FigModule):
     """ Plot an X-Y graph
 
     Input Signals:
@@ -175,14 +181,15 @@ class PlotGraph(_FigModule):
         for i, y in enumerate(ys):
             self.line[i].set_xdata(x)
             self.line[i].set_ydata(y)
-            ymin, ymax = min(ymin, min(y)), max(ymax, max(y))
-        self.ax.set_xlim([min(x), max(x)])
-        self.ax.set_ylim([ymin, ymax])
+            ymin, ymax = min(ymin, np.min(y)), max(ymax, np.max(y))
+        self.ax.set_xlim([np.min(x), np.max(x)])
+        dy = ymax - ymin
+        self.ax.set_ylim([ymin-0.05*dy, ymax+0.05*dy])
 
         self._update_fig()
 
 
-class PlotIter(_FigModule):
+class PlotIter(FigModule):
     """ Plot iteration history of one or more variables
 
     Input Signals:
@@ -193,10 +200,12 @@ class PlotIter(_FigModule):
         overwrite (bool): Overwrite saved image every time the figure is updated, else prefix ``_0000`` is added to the
           filename (default = ``False``)
         show (bool): Show the figure on the screen
+        ylim: Provide y-axis limits for the plot
     """
-    def _prepare(self):
+    def _prepare(self, ylim=None):
         self.minlim = 1e+200
         self.maxlim = -1e+200
+        self.ylim = ylim
 
     def _response(self, *args):
         if not hasattr(self, 'ax'):
@@ -227,7 +236,9 @@ class PlotIter(_FigModule):
         dy = max((self.maxlim - self.minlim)*0.05, sys.float_info.min)
 
         self.ax.set_xlim([-0.5, self.iter+0.5])
-        if np.isfinite(self.minlim) and np.isfinite(self.maxlim):
+        if self.ylim is not None:
+            self.ax.set_ylim(self.ylim)
+        elif np.isfinite(self.minlim) and np.isfinite(self.maxlim):
             self.ax.set_ylim([self.minlim - dy, self.maxlim + dy])
 
         self._update_fig()
@@ -244,7 +255,7 @@ class WriteToVTI(Module):
     accepted, which get the suffixed as ``_00``.
 
     Input Signals:
-      - ``*args`` (`numpy.ndarary`): Vectors to write to VTI. The signal tags are used as name.
+      - ``*args`` (`numpy.ndarray`): Vectors to write to VTI. The signal tags are used as name.
 
     Args:
         domain: The domain layout
@@ -271,3 +282,65 @@ class WriteToVTI(Module):
             filen = pth[0] + '.{0:04d}'.format(self.iter) + pth[1]
         self.domain.write_to_vti(data, filename=filen, scale=self.scale)
         self.iter += 1
+
+
+class ScalarToFile(Module):
+    """ Writes iteration data to a log file
+
+    This function can also handle small vectors of scalars, i.e. eigenfrequencies or multiple constraints.
+
+    Input Signals:
+      - ``*args`` (`Numeric` or `np.ndarray`): Values to write to file. The signal tags are used as name.
+
+    Args:
+        saveto: Location to save the log file, supports .txt or .csv
+        fmt (optional): Value format (e.g. 'e', 'f', '.3e', '.5g', '.3f')
+        separator (optional): Value separator, .csv files will automatically use a comma
+    """
+    def _prepare(self, saveto: str, fmt: str = '.10e', separator: str = '\t'):
+        self.saveto = saveto
+        Path(saveto).parent.mkdir(parents=True, exist_ok=True)
+        self.iter = 0
+
+        # Test the format
+        3.14.__format__(fmt)
+        self.format = fmt
+
+        self.separator = "," if ".csv" in self.saveto else separator
+
+    def _response(self, *args):
+        tags = [] if self.iter == 0 else None
+
+        # Add iteration as first column
+        dat = [self.iter.__format__('d')]
+        if tags is not None:
+            tags.append('Iteration')
+
+        # Add all signals
+        for s in self.sig_in:
+            if np.size(np.asarray(s.state)) > 1:
+                it = np.nditer(s.state, flags=['multi_index'])
+                while not it.finished:
+                    dat.append(it.value.__format__(self.format))
+                    if tags is not None:
+                        tags.append(f"{s.tag}{list(it.multi_index)}")
+                    it.iternext()
+            else:
+                dat.append(s.state.__format__(self.format))
+                if tags is not None:
+                    tags.append(s.tag)
+
+        # Write to file
+        if tags is not None:
+            assert len(tags) == len(dat)
+            with open(self.saveto, "w+") as f:
+                # Write header line
+                f.write(self.separator.join(tags))
+                f.write("\n")
+
+        with open(self.saveto, "a+") as f:
+            # Write data
+            f.write(self.separator.join(dat))
+            f.write("\n")
+
+        self.iter += 1

pymoto/modules/linalg.py

@@ -7,10 +7,9 @@ import scipy.linalg as spla  # Dense matrix solvers
 import scipy.sparse as sps
 import scipy.sparse.linalg as spsla
 
-from pymoto import Signal, Module, DyadCarrier, LDAWrapper
-from pymoto import SolverDenseLU, SolverDenseLDL, SolverDenseCholesky, SolverDiagonal, SolverDenseQR
-from pymoto import SolverSparseLU, SolverSparseCholeskyCVXOPT, SolverSparsePardiso, SolverSparseCholeskyScikit
-from pymoto import matrix_is_symmetric, matrix_is_hermitian, matrix_is_diagonal
+from pymoto import Signal, Module, DyadCarrier
+from pymoto.solvers import auto_determine_solver
+from pymoto.solvers import matrix_is_sparse, matrix_is_complex, matrix_is_hermitian, LDAWrapper
 
 
 class StaticCondensation(Module):
@@ -172,7 +171,7 @@ class SystemOfEquations(Module):
             adjoint_load += self.Afp * dgdb[self.p, ...]
 
         lam = np.zeros_like(self.x)
-        lamf = -1.0 * self.module_LinSolve.solver.adjoint(adjoint_load)
+        lamf = -1.0 * self.module_LinSolve.solver.solve(adjoint_load, trans='T')
         lam[self.f, ...] = lamf
 
         if dgdb is not None:
@@ -219,105 +218,6 @@ class Inverse(Module):
         return dA if np.iscomplexobj(A) else np.real(dA)
 
 
-# flake8: noqa: C901
-def auto_determine_solver(A, isdiagonal=None, islowertriangular=None, isuppertriangular=None,
-                          ishermitian=None, issymmetric=None, ispositivedefinite=None):
-    """
-    Uses parts of Matlab's scheme https://nl.mathworks.com/help/matlab/ref/mldivide.html
-    :param A: The matrix
-    :param isdiagonal: Manual override for diagonal matrix
-    :param islowertriangular: Override for lower triangular matrix
-    :param isuppertriangular: Override for upper triangular matrix
-    :param ishermitian: Override for hermitian matrix (prevents check)
-    :param issymmetric: Override for symmetric matrix (prevents check). Is the same as hermitian for a real matrix
-    :param ispositivedefinite: Manual override for positive definiteness
-    :return: LinearSolver which should be 'best' for the matrix
-    """
-    issparse = sps.issparse(A)  # Check if the matrix is sparse
-    issquare = A.shape[0] == A.shape[1]  # Check if the matrix is square
-
-    if not issquare:
-        if issparse:
-            sps.SparseEfficiencyWarning("Only a dense version of QR solver is available")  # TODO
-        return SolverDenseQR()
-
-    # l_bw, u_bw = spla.bandwidth(A) # TODO Get bandwidth (implemented in scipy version > 1.8.0)
-
-    if isdiagonal is None:  # Check if matrix is diagonal
-        # TODO: This could be improved to check other sparse matrix types as well
-        isdiagonal = matrix_is_diagonal(A)
-    if isdiagonal:
-        return SolverDiagonal()
-
-    # Check if the matrix is triangular
-    # TODO Currently only for dense matrices
-    if islowertriangular is None:  # Check if matrix is lower triangular
-        islowertriangular = False if issparse else np.allclose(A, np.tril(A))
-    if islowertriangular:
-        warnings.WarningMessage("Lower triangular solver not implemented",
-                                UserWarning, getframeinfo(currentframe()).filename, getframeinfo(currentframe()).lineno)
-
-    if isuppertriangular is None:  # Check if matrix is upper triangular
-        isuppertriangular = False if issparse else np.allclose(A, np.triu(A))
-    if isuppertriangular:
-        warnings.WarningMessage("Upper triangular solver not implemented",
-                                UserWarning, getframeinfo(currentframe()).filename, getframeinfo(currentframe()).lineno)
-
-    ispermutedtriangular = False
-    if ispermutedtriangular:
-        warnings.WarningMessage("Permuted triangular solver not implemented",
-                                UserWarning, getframeinfo(currentframe()).filename, getframeinfo(currentframe()).lineno)
-
-    # Check if the matrix is complex-valued
-    iscomplex = np.iscomplexobj(A)
-    if iscomplex:
-        # Detect if the matrix is hermitian and/or symmetric
-        if ishermitian is None:
-            ishermitian = matrix_is_hermitian(A)
-        if issymmetric is None:
-            issymmetric = matrix_is_symmetric(A)
-    else:
-        if ishermitian is None and issymmetric is None:
-            # Detect if the matrix is symmetric
-            issymmetric = matrix_is_symmetric(A)
-            ishermitian = issymmetric
-        elif ishermitian is not None and issymmetric is not None:
-            assert ishermitian == issymmetric, "For real-valued matrices, symmetry and hermitian must be equal"
-        elif ishermitian is None:
-            ishermitian = issymmetric
-        elif issymmetric is None:
-            issymmetric = ishermitian
-
-    if issparse:
-        # Prefer Intel Pardiso solver as it can solve any matrix TODO: Check for complex matrix
-        if SolverSparsePardiso.defined and not iscomplex:
-            # TODO check for positive definiteness?  np.all(A.diagonal() > 0) or np.all(A.diagonal() < 0)
-            return SolverSparsePardiso(symmetric=issymmetric, hermitian=ishermitian, positive_definite=ispositivedefinite)
-
-        if ishermitian:
-            # Check if diagonal is all positive or all negative -> Cholesky
-            if np.all(A.diagonal() > 0) or np.all(A.diagonal() < 0):  # TODO what about the complex case?
-                if SolverSparseCholeskyScikit.defined:
-                    return SolverSparseCholeskyScikit()
-                if SolverSparseCholeskyCVXOPT.defined:
-                    return SolverSparseCholeskyCVXOPT()
-
-        return SolverSparseLU()  # Default to LU, which should be possible for any non-singular square matrix
-
-    else:  # Dense branch
-        if ishermitian:
-            # Check if diagonal is all positive or all negative
-            if np.all(A.diagonal() > 0) or np.all(A.diagonal() < 0):
-                return SolverDenseCholesky()
-            else:
-                return SolverDenseLDL(hermitian=ishermitian)
-        elif issymmetric:
-            return SolverDenseLDL(hermitian=ishermitian)
-        else:
-            # TODO: Detect if the matrix is Hessenberg
-            return SolverDenseLU()
-
-
 class LinSolve(Module):
     r""" Solves linear system of equations :math:`\mathbf{A}\mathbf{x}=\mathbf{b}`
 
@@ -347,11 +247,12 @@ class LinSolve(Module):
         self.ishermitian = hermitian
         self.issymmetric = symmetric
         self.solver = solver
+        self.u = None  # Solution storage
 
     def _response(self, mat, rhs):
         # Do some detections on the matrix type
-        self.issparse = sps.issparse(mat)  # Check if it is a sparse matrix
-        self.iscomplex = np.iscomplexobj(mat)  # Check if it is a complex-valued matrix
+        self.issparse = matrix_is_sparse(mat)  # Check if it is a sparse matrix
+        self.iscomplex = matrix_is_complex(mat)  # Check if it is a complex-valued matrix
         if not self.iscomplex and self.issymmetric is not None:
             self.ishermitian = self.issymmetric
         if self.ishermitian is None:
@@ -365,19 +266,23 @@ class LinSolve(Module):
         if self.solver is None:
             self.solver = auto_determine_solver(mat, ishermitian=self.ishermitian)
         if not isinstance(self.solver, LDAWrapper) and self.use_lda_solver:
-            self.solver = LDAWrapper(self.solver, hermitian=self.ishermitian, symmetric=self.issymmetric)
+            lda_kwargs = dict(hermitian=self.ishermitian, symmetric=self.issymmetric)
+            if hasattr(self.solver, 'tol'):
+                lda_kwargs['tol'] = self.solver.tol * 2
+            self.solver = LDAWrapper(self.solver, **lda_kwargs)
 
         # Update solver with new matrix
         self.solver.update(mat)
 
         # Solution
-        self.u = self.solver.solve(rhs)
+        self.u = self.solver.solve(rhs, x0=self.u)
 
         return self.u
 
     def _sensitivity(self, dfdv):
         mat, rhs = [s.state for s in self.sig_in]
-        lam = self.solver.adjoint(dfdv.conj()).conj()
+        # lam = self.solver.solve(dfdv.conj(), trans='H').conj()
+        lam = self.solver.solve(dfdv, trans='T')
 
         if self.issparse:
             if self.u.ndim > 1:
@@ -413,9 +318,6 @@ class EigenSolve(Module):
     Mode tracking algorithms can be implemented by the user by providing the argument ``sorting_func``, which is a
     function with arguments (``λ``, ``Q``).
 
-    Todo:
-        Support for sparse matrix
-
     Input Signal(s):
       - ``A`` (`dense matrix`): The system matrix of size ``(n, n)``
       - ``B`` (`dense matrix, optional`): Second system matrix (must be positive-definite) of size ``(n, n)``
@@ -440,12 +342,15 @@ class EigenSolve(Module):
         self.sigma = sigma
         self.mode = mode
         self.Ainv = None
+        self.do_solve = False
+        self.adjoint_solvers_need_update = True
 
     def _response(self, A, *args):
         B = args[0] if len(args) > 0 else None
         if self.is_hermitian is None:
             self.is_hermitian = (matrix_is_hermitian(A) and (B is None or matrix_is_hermitian(B)))
-        self.is_sparse = sps.issparse(A) and (B is None or sps.issparse(B))
+        self.is_sparse = matrix_is_sparse(A) and (B is None or matrix_is_sparse(B))
+        self.adjoint_solvers_need_update = True
 
         # Solve the eigenvalue problem
         if self.is_sparse:
@@ -458,12 +363,18 @@ class EigenSolve(Module):
         W = W[isort]
         Q = Q[:, isort]
 
-        # Normalize the eigenvectors
+        # Normalize the eigenvectors with the following conditions:
+        # 1) Flip sign such that the average (real) value is positive
+        # 2) Normalize the eigenvector v⋅v or v⋅Bv to unity
         for i in range(W.size):
             qi, wi = Q[:, i], W[i]
-            qi *= np.sign(np.real(qi[np.argmax(abs(qi) > 0)]))  # Set first value positive for orientation
             Bqi = qi if B is None else B@qi
-            qi /= np.sqrt(qi@Bqi)  # Normalize
+
+            normval = np.sqrt(qi @ Bqi)
+            avgval = np.average(qi)/normval
+
+            sf = np.sign(np.real(avgval)) / normval
+            qi *= sf
         return W, Q
 
     def _sensitivity(self, dW, dQ):
@@ -474,7 +385,8 @@ class EigenSolve(Module):
             dA, dB = self._dense_sens(A, B, dW, dQ)
         else:
             if dQ is not None:
-                raise NotImplementedError('Sparse eigenvector sensitivities not implemented')
+                # raise NotImplementedError('Sparse eigenvector sensitivities not implemented')
+                dA, dB = self._sparse_eigvec_sens(A, B, dW, dQ)
             elif dW is not None:
                 dA, dB = self._sparse_eigval_sens(A, B, dW)
 
@@ -483,7 +395,6 @@ class EigenSolve(Module):
         elif len(self.sig_in) == 2:
             return dA, dB
 
-
     def _sparse_eigs(self, A, B=None):
         if self.nmodes is None:
             self.nmodes = 6
@@ -500,9 +411,14 @@ class EigenSolve(Module):
         # Use shift-and-invert, so make inverse operator
         if self.Ainv is None:
             self.Ainv = auto_determine_solver(mat_shifted, ishermitian=self.is_hermitian)
-        self.Ainv.update(mat_shifted)
+            self.do_solve = True
+        if self.sigma != 0:
+            self.do_solve = True
+        if self.do_solve:
+            self.Ainv.update(mat_shifted)
 
-        AinvOp = spsla.LinearOperator(mat_shifted.shape, matvec=self.Ainv.solve, rmatvec=self.Ainv.adjoint)
+        AinvOp = spsla.LinearOperator(mat_shifted.shape, matvec=self.Ainv.solve,
+                                      rmatvec=lambda b: self.Ainv.solve(b, trans='H'))
 
         if self.is_hermitian:
             return spsla.eigsh(A, M=B, k=self.nmodes, OPinv=AinvOp, sigma=self.sigma, mode=self.mode)
@@ -562,3 +478,59 @@ class EigenSolve(Module):
                     dB -= DyadCarrier(dB_u, qi)
         return dA, dB
 
+    def _sparse_eigvec_sens(self, A, B, dW, dQ):
+        """ Calculate eigenvector sensitivities for a sparse eigenvalue problem
+        References:
+             Delissen (2022), Topology optimization for dynamic and controlled systems,
+               doi: https://doi.org/10.4233/uuid:c9ed8f61-efe1-4dc8-bb56-e353546cf247
+
+        Args:
+            A: System matrix
+            B: Mass matrix
+            dW: Adjoint eigenvalue sensitivities
+            dQ: Adjoint eigenvector sensitivities
+
+        Returns:
+            dA: Adjoint system matrix sensitivities
+            dB: Adjoint mass matrix sensitivities
+        """
+        if dQ is None:
+            return self._sparse_eigval_sens(A, B, dW)
+        W, Q = [s.state for s in self.sig_out]
+        if dW is not None:
+            dA, dB = self._sparse_eigval_sens(A, B, dW)
+        else:
+            dA, dB = DyadCarrier(), None if B is None else DyadCarrier()
+        for i in range(W.size):
+            phi = Q[:, i]
+            dphi = dQ[:, i]
+            if dphi.min() == dphi.max() == 0.0:
+                continue
+            lam = W[i]
+
+            alpha = - phi @ dphi
+            r = dphi + alpha * B.T @ phi
+
+            # Solve particular solution
+            if self.adjoint_solvers_need_update or self.solvers[i] is None:
+                Z = A - lam * B
+                if not hasattr(self, 'solvers'):
+                    self.solvers = [None for _ in range(W.size)]
+                if self.solvers[i] is None:  # Solver must be able to solve indefinite system
+                    self.solvers[i] = auto_determine_solver(Z, ispositivedefinite=False)
+                if self.adjoint_solvers_need_update:
+                    self.solvers[i].update(Z)
+
+            vp = self.solvers[i].solve(r, trans='T')
+
+            # Calculate total ajoint by adding homogeneous solution
+            c = - vp @ B @ phi
+            v = vp + c * phi
+
+            # Add to mass and stiffness matrix
+            dAi = - DyadCarrier(v, phi)
+            dA += np.real(dAi) if np.isrealobj(A) else dAi
+            if B is not None:
+                dBi = DyadCarrier(alpha / 2 * phi + lam * v, phi)
+                dB += np.real(dBi) if np.isrealobj(B) else dBi
+        return dA, dB

pymoto/modules/scaling.py

@@ -1,12 +1,13 @@
 from pymoto import Module
+import numpy as np
 
 
 class Scaling(Module):
     r""" Scales (scalar) input for different response functions in optimization (objective / constraints).
     This is useful, for instance, for MMA where the objective must be scaled in a certain way for good convergence.
 
-    Objective scaling (`minval` and `maxval` are both undefined):
-    :math:`y^{(i)} = s \frac{x^{(i)}}{x^{(0)}}`
+    Objective scaling using absolute value or vector norm (`minval` and `maxval` are both undefined):
+    :math:`y^{(i)} = s \frac{x^{(i)}}{||x^{(0)}||}`
 
     For the constraints, the negative null-form convention is used, which means the constraint is :math:`y(x) \leq 0`.
 
@@ -25,7 +26,7 @@ class Scaling(Module):
     Keyword Args:
         scaling: Value :math:`s` to scale with
         minval: Minimum value :math:`x_\text{min}` for negative-null-form constraint
-        minval: Maximum value :math:`x_\text{max}` for negative-null-form constraint
+        maxval: Maximum value :math:`x_\text{max}` for negative-null-form constraint
     """
     def _prepare(self, scaling: float = 100.0, minval: float = None, maxval: float = None):
         self.minval = minval
@@ -39,7 +40,7 @@ class Scaling(Module):
 
     def _response(self, x):
         if not hasattr(self, 'sf'):
-            self.sf = self.scaling/x
+            self.sf = self.scaling/np.linalg.norm(x)
         if self.minval is not None:
             g = 1 - x/self.minval
         elif self.maxval is not None:

pymoto/routines.py

@@ -1,8 +1,10 @@
+import warnings
 import numpy as np
 from .utils import _parse_to_list, _concatenate_to_array
 from .core_objects import Signal, SignalSlice, Module, Network
 from .common.mma import MMA
 from typing import List, Iterable, Union, Callable
+from scipy.sparse import issparse
 
 
 def _has_signal_overlap(sig1: List[Signal], sig2: List[Signal]):
@@ -84,15 +86,15 @@ def finite_difference(blk: Module, fromsig: Union[Signal, Iterable[Signal]] = No
     blk.response()
 
     print("Outputs:")
-    if not verbose:
+    if verbose:
+        [print("{}\t{} = {}".format(i, s.tag, s.state)) for i, s in enumerate(outps)]
+    else:
         print(", ".join([s.tag for s in outps]))
 
     # Get analytical response and sensitivities, by looping over all outputs
     for Iout, Sout in enumerate(outps):
         # Obtain the output state
         output = Sout.state
-        if verbose:
-            print("{}\t{} = {}".format(Iout, Sout.tag, output))
 
         # Store the output value
         f0[Iout] = (output.copy() if hasattr(output, "copy") else output)
@@ -100,6 +102,10 @@ def finite_difference(blk: Module, fromsig: Union[Signal, Iterable[Signal]] = No
         # Get the output state shape
         shape = (output.shape if hasattr(output, "shape") else ())
 
+        if output is None:
+            warnings.warn(f"Output {Iout} of {Sout.tag} is None")
+            continue
+
         # Generate a (random) sensitivity for output signal
         if use_df is not None:
             df_an[Iout] = use_df[Iout]
@@ -169,9 +175,15 @@ def finite_difference(blk: Module, fromsig: Union[Signal, Iterable[Signal]] = No
             for Iout, Sout in enumerate(outps):
                 # Obtain perturbed response
                 fp = Sout.state
+                if fp is None:
+                    warnings.warn(f"Output {Iout} of {Sout.tag} is None")
+                    continue
 
                 # Finite difference sensitivity
-                df = (fp - f0[Iout])/(dx*sf)
+                if issparse(fp):
+                    df = (fp.toarray() - f0[Iout].toarray()) / (dx * sf)
+                else:
+                    df = (fp - f0[Iout])/(dx*sf)
 
                 dgdx_fd = np.real(np.sum(df*df_an[Iout]))
 
@@ -183,7 +195,7 @@ def finite_difference(blk: Module, fromsig: Union[Signal, Iterable[Signal]] = No
                 else:
                     dgdx_an = 0.0
 
-                if abs(dgdx_an) < tol:
+                if abs(dgdx_an) == 0:
                     error = abs(dgdx_fd - dgdx_an)
                 else:
                     error = abs(dgdx_fd - dgdx_an)/max(abs(dgdx_fd), abs(dgdx_an))
@@ -222,8 +234,15 @@ def finite_difference(blk: Module, fromsig: Union[Signal, Iterable[Signal]] = No
                     # Obtain perturbed response
                     fp = Sout.state
 
+                    if fp is None:
+                        warnings.warn(f"Output {Iout} of {Sout.tag} is None")
+                        continue
+
                     # Finite difference sensitivity
-                    df = (fp - f0[Iout])/(dx*1j*sf)
+                    if issparse(fp):
+                        df = (fp.toarray() - f0[Iout].toarray()) / (dx * 1j * sf)
+                    else:
+                        df = (fp - f0[Iout])/(dx*1j*sf)
                     dgdx_fd = np.imag(np.sum(df*df_an[Iout]))
 
                     if dx_an[Iout][Iin] is not None:
@@ -335,8 +354,9 @@ def minimize_oc(function, variables, objective: Signal,
         function.sensitivity()
         dfdx, _ = _concatenate_to_array(obtain_sensitivities(variables))
         maxdfdx = max(dfdx)
-        if maxdfdx > 0:
-            raise RuntimeError(f"OC only works for negative sensitivities: max(dfdx) = {maxdfdx}")
+        if maxdfdx > 1e-15:
+            warnings.warn(f"OC only works for negative sensitivities: max(dfdx) = {maxdfdx}. Clipping positive values.")
+        dfdx = np.minimum(dfdx, 0)
 
         # Do OC update
         l1, l2 = l1init, l2init
@@ -374,7 +394,12 @@ def minimize_mma(function, variables, responses, **kwargs):
         move: Move limit on relative variable change per iteration
         xmin: Minimum design variable (can be a vector)
         xmax: Maximum design variable (can be a vector)
-        verbosity: 0 - No prints, 1 - Only convergence message, 2 - Convergence and iteration info, 3 - Extended info
+        verbosity: Level of information to print
+          0 - No prints
+          1 - Only convergence message
+          2 - Convergence and iteration info (default)
+          3 - Additional info on variables
+          4 - Additional info on sensitivity information
 
     """
     # Save initial state

pymoto/solvers/__init__.py

@@ -0,0 +1,14 @@
+from .solvers import LinearSolver, LDAWrapper
+from .matrix_checks import matrix_is_sparse, matrix_is_complex, matrix_is_diagonal, matrix_is_symmetric, matrix_is_hermitian
+from .dense import SolverDiagonal, SolverDenseQR, SolverDenseLU, SolverDenseCholesky, SolverDenseLDL
+from .sparse import SolverSparsePardiso, SolverSparseLU, SolverSparseCholeskyScikit, SolverSparseCholeskyCVXOPT
+from .iterative import Preconditioner, CG, DampedJacobi, SOR, ILU, GeometricMultigrid
+from .auto_determine import auto_determine_solver
+
+__all__ = ['matrix_is_sparse', 'matrix_is_complex', 'matrix_is_diagonal', 'matrix_is_symmetric', 'matrix_is_hermitian',
+           'LinearSolver', 'LDAWrapper',
+           'SolverDiagonal', 'SolverDenseQR', 'SolverDenseLU', 'SolverDenseCholesky', 'SolverDenseLDL',
+           'SolverSparsePardiso', 'SolverSparseLU', 'SolverSparseCholeskyScikit', 'SolverSparseCholeskyCVXOPT',
+           'Preconditioner', 'CG', 'DampedJacobi', 'SOR', 'ILU', 'GeometricMultigrid',
+           'auto_determine_solver',
+           ]