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

{pyMOTO-1.4.0.dist-info → pyMOTO-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyMOTO
-Version: 1.4.0
+Version: 1.5.0
 Summary: A modular approach for topology optimization
 Home-page: https://github.com/aatmdelissen/pyMOTO
 Author: Arnoud Delissen

pyMOTO-1.5.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+pymoto/__init__.py,sha256=YLMAiO2PZHAC6nYWXVh03rhZnZkc_Rc2z7SGQj1T8I4,2058
+pymoto/core_objects.py,sha256=88AOo041wrcRSPoLCRwBXUoYANGX-b2SAA0Nuf6sn2Y,25252
+pymoto/routines.py,sha256=yjvcQDcWU47ZM6ZpZoX8VwrJoN9JDO_25DSa9oVcKec,15582
+pymoto/utils.py,sha256=YJ-PNLJLc12Yx6TYCrEechS2aaBRx0o4mTM1soeeyz0,1122
+pymoto/common/domain.py,sha256=-eFuYRLehQ17Ai-cV59f4I9FbEM-DJAj6kjjVfj31X0,18120
+pymoto/common/dyadcarrier.py,sha256=VwMbqPr0NMDPfpsH0BwvXp8M1dmh8ijFDpF6yoyTmto,19394
+pymoto/common/mma.py,sha256=Pof3clOHA8PG51TmUjs11dkjSP96kovZjsPv62tI2Ec,24055
+pymoto/modules/aggregation.py,sha256=Oi17hIJ6dic4lOPw16zmjbdC72MjB6XK34H80bnbWAI,7580
+pymoto/modules/assembly.py,sha256=quuR8QpB2w-O0zly-xS6PK6wZQMY6S5TWh15Y9wuh14,22974
+pymoto/modules/autodiff.py,sha256=WAfoAOHBSozf7jbr9gQz9Vw4a_2G9wGJxLMMqUQP0Co,1684
+pymoto/modules/complex.py,sha256=B_Obk-ABdV66lEudZ5s8o6qG9NsmYlBsX-PbWvbphhc,4429
+pymoto/modules/filter.py,sha256=6X9FaQMWYZ_TpHVTFiEibzlmAwmSWbydYM93LFrJ0Wo,25490
+pymoto/modules/generic.py,sha256=YzsGZ8J0oLCORt78Bf2p0v4GuqpWRI77NLoCk7gqidw,10666
+pymoto/modules/io.py,sha256=LcFvJ-cPgg5ee-aag8kaxHw5RzQ-ggxOM5jk7PeJ1r8,13140
+pymoto/modules/linalg.py,sha256=BNkih4nvvkYuQpm4bG5U38dAjkfD5EFi3MjANpBEPPI,21927
+pymoto/modules/scaling.py,sha256=uq88HHW9rP16XLz7UGc3CNBBpY2Z1glo8yjYxZEnXUg,2327
+pymoto/solvers/__init__.py,sha256=9JUeD2SgZbkYFullA7s7s6SuAVv0onqAqJ8hFvNOs2g,1033
+pymoto/solvers/auto_determine.py,sha256=X8MEG7h6jLfAV1inpja45_-suG8qQFMfLMDfW2ryQqQ,5134
+pymoto/solvers/dense.py,sha256=9fKPCwNxRKAEk5k1A7fdLrr9ngeVssGlw-sbjWCm4iU,11235
+pymoto/solvers/iterative.py,sha256=CIxJHjGnCaIjXbtO2NxV60yeDpcCbSD6Bp0xR-7vOf0,12944
+pymoto/solvers/matrix_checks.py,sha256=bbrfjpTSWWnuQW3xY0_CYE8yrh5gA9K5b1LzHEOFAxI,1663
+pymoto/solvers/solvers.py,sha256=RwHjZYYlE3oA0U9k7ukla2gOdmq57rSSJQvHqjaM7JU,10626
+pymoto/solvers/sparse.py,sha256=w8XBlFBIfOpNnfRdLWhLzzqtD8YVxMnDBuhIabFfQQc,16664
+pyMOTO-1.5.0.dist-info/LICENSE,sha256=ZXMC2Txpzs-dBwz9Me4_1rQCSVl4P1B27MomNi43F30,1072
+pyMOTO-1.5.0.dist-info/METADATA,sha256=hC38SdgeKEK5NkNDh-gwc4Gz2JOFSymJB-eAMXl7HX4,5006
+pyMOTO-1.5.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+pyMOTO-1.5.0.dist-info/top_level.txt,sha256=EdvAUSmFMaiqhuEZW8jxANMiK-LdPtlmDWL6SfmCdUU,7
+pyMOTO-1.5.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pyMOTO-1.5.0.dist-info/RECORD,,

{pyMOTO-1.4.0.dist-info → pyMOTO-1.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.1.2)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pymoto/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '1.4.0'
+__version__ = '1.5.0'
 
 from .common.domain import DomainDefinition
 
@@ -14,12 +14,12 @@ from .core_objects import Signal, Module, Network, make_signals
 
 # Import modules
 from .modules.assembly import AssembleGeneral, AssembleStiffness, AssembleMass, AssemblePoisson
-from .modules.assembly import ElementOperation, Strain, Stress
+from .modules.assembly import ElementOperation, Strain, Stress, ElementAverage, NodalOperation, ThermoMechanical
 from .modules.autodiff import AutoMod
 from .modules.complex import MakeComplex, RealPart, ImagPart, ComplexNorm
 from .modules.filter import FilterConv, Filter, DensityFilter, OverhangFilter
 from .modules.generic import MathGeneral, EinSum, ConcatSignal
-from .modules.io import FigModule, PlotDomain, PlotGraph, PlotIter, WriteToVTI
+from .modules.io import FigModule, PlotDomain, PlotGraph, PlotIter, WriteToVTI, ScalarToFile
 from .modules.linalg import Inverse, LinSolve, EigenSolve, SystemOfEquations, StaticCondensation
 from .modules.aggregation import AggScaling, AggActiveSet, Aggregation, PNorm, SoftMinMax, KSFunction
 from .modules.scaling import Scaling
@@ -44,9 +44,9 @@ __all__ = [
     "MathGeneral", "EinSum", "ConcatSignal",
     "Inverse", "LinSolve", "EigenSolve", "SystemOfEquations", "StaticCondensation",
     "AssembleGeneral", "AssembleStiffness", "AssembleMass", "AssemblePoisson",
-    "ElementOperation", "Strain", "Stress",
+    "ElementOperation", "Strain", "Stress", "ElementAverage", "NodalOperation", "ThermoMechanical",
     "FilterConv", "Filter", "DensityFilter", "OverhangFilter",
-    "FigModule", "PlotDomain", "PlotGraph", "PlotIter", "WriteToVTI",
+    "FigModule", "PlotDomain", "PlotGraph", "PlotIter", "WriteToVTI", "ScalarToFile",
     "MakeComplex", "RealPart", "ImagPart", "ComplexNorm",
     "AutoMod",
     "Aggregation", "PNorm", "SoftMinMax", "KSFunction",

pymoto/common/domain.py

@@ -126,9 +126,10 @@ class DomainDefinition:
         self.conn[el, :] = self.get_elemconnectivity(elx, ely, elz)
 
         # Helper for element slicing
-        eli, elj, elk = np.meshgrid(np.arange(self.nelx), np.arange(self.nely), np.arange(self.nelz), indexing='ij')
+        eli, elj, elk = np.meshgrid(np.arange(self.nelx), np.arange(self.nely), np.arange(max(self.nelz, 1)), indexing='ij')
         self.elements = self.get_elemnumber(eli, elj, elk)
 
+        # Helper for node slicing
         ndi, ndj, ndk = np.meshgrid(np.arange(self.nelx+1), np.arange(self.nely+1), np.arange(self.nelz+1), indexing='ij')
         self.nodes = self.get_nodenumber(ndi, ndj, ndk)
 

pymoto/common/dyadcarrier.py

@@ -1,4 +1,4 @@
-from typing import Union, Iterable, List
+from typing import Union, Iterable, List, Tuple
 import warnings
 import numpy as np
 from numpy.typing import NDArray
@@ -37,19 +37,20 @@ class DyadCarrier(object):
     :math:`\mathbf{A} = \sum_k^N \mathbf{u}_k\otimes\mathbf{v}_k`
     or in index notation :math:`A_{ij} = \sum_k^N u_{ki} v_{kj}`. This saves a lot of memory for low :math:`N`.
 
-    Args:
-        u : (optional) List of vectors
-        v : (optional) List of vectors (if ``u`` is given and ``v`` not, a symmetric dyad is assumed with ``v = u``)
+    Keyword Args:
+        u: List of vectors
+        v: List of vectors (if ``u`` is given and ``v`` not, a symmetric dyad is assumed with ``v = u``)
+        shape: Shape of the matrix
     """
 
     __array_priority__ = 11.0  # For overriding numpy's ufuncs
     ndim = 2  # Number of dimensions
 
-    def __init__(self, u: Iterable = None, v: Iterable = None):
+    def __init__(self, u: Iterable = None, v: Iterable = None, shape: Tuple[int, int] = (-1, -1)):
         self.u = []
         self.v = []
-        self.ulen = -1
-        self.vlen = -1
+        self.ulen = shape[0]
+        self.vlen = shape[1]
         self.dtype = np.dtype('float64')  # Standard data type
         self.add_dyad(u, v)
 
@@ -66,6 +67,12 @@ class DyadCarrier(object):
         else:
             return self.ulen * self.vlen
 
+    @property
+    def n_dyads(self):
+        """ Number of dyads stored """
+        assert len(self.u) == len(self.v)
+        return len(self.u)
+
     def add_dyad(self, u: Iterable, v: Iterable = None, fac: float = None):
         r""" Adds a list of vectors to the dyad carrier
 
@@ -92,9 +99,7 @@ class DyadCarrier(object):
         if len(ulist) != len(vlist):
             raise TypeError("Number of vectors in u ({}) and v({}) should be equal".format(len(ulist), len(vlist)))
 
-        n = len(ulist)
-
-        for i, ui, vi in zip(range(n), ulist, vlist):
+        for i, (ui, vi) in enumerate(zip(ulist, vlist)):
             # Make sure they are numpy arrays
             if not isinstance(ui, np.ndarray):
                 ui = np.array(ui)
@@ -141,14 +146,22 @@ class DyadCarrier(object):
 
     def __getitem__(self, subscript):
         assert len(subscript) == self.ndim, "Invalid number of slices, must be 2"
-        usub = [ui[subscript[0]] for ui in self.u]
-        vsub = [vi[subscript[1]] for vi in self.v]
+        if self.shape[0] < 0 and self.shape[1] < 0:
+            return DyadCarrier()
+
+        usample = np.zeros(self.shape[0])[subscript[0]]
+        vsample = np.zeros(self.shape[1])[subscript[1]]
 
-        is_uni_slice = isscalarlike(usub[0]) or isscalarlike(vsub[0])
+        is_uni_slice = isscalarlike(usample) or isscalarlike(vsample)
         is_np_slice = isinstance(subscript[0], np.ndarray) and isinstance(subscript[1], np.ndarray)
+
         if is_np_slice and subscript[0].shape != subscript[1].shape:
             raise IndexError(f"shape mismatch: indexing arrays could not be broadcast together "
                              f"with shapes {subscript[0].shape} {subscript[1].shape}")
+
+        usub = [ui[subscript[0]] for ui in self.u]
+        vsub = [vi[subscript[1]] for vi in self.v]
+
         if is_uni_slice or is_np_slice:
             res = 0
             for (ui, vi) in zip(usub, vsub):
@@ -156,7 +169,7 @@ class DyadCarrier(object):
 
             return res
         else:
-            return DyadCarrier(usub, vsub)
+            return DyadCarrier(usub, vsub, shape=(np.size(usample), np.size(vsample)))
 
     def __setitem__(self, subscript, value):
         assert len(subscript) == self.ndim, "Invalid number of slices, must be 2"
@@ -171,10 +184,10 @@ class DyadCarrier(object):
                 vi[subscript[1]] = value
 
     def __pos__(self):
-        return DyadCarrier(self.u, self.v)
+        return self.copy()
 
     def __neg__(self):
-        return DyadCarrier([-uu for uu in self.u], self.v)
+        return DyadCarrier([-uu for uu in self.u], self.v, shape=self.shape)
 
     def __iadd__(self, other):
         self.add_dyad(other.u, other.v)
@@ -189,7 +202,7 @@ class DyadCarrier(object):
         elif isdyad(other):
             if other.shape != self.shape and (self.size > 0 and other.size > 0):
                 raise ValueError(f"Inconsistent shapes {self.shape} and {other.shape}")
-            return DyadCarrier(self.u, self.v).__iadd__(other)
+            return self.copy().__iadd__(other)
         elif isdense(other):
             other = np.broadcast_to(other, self.shape)
             return other + self.todense()
@@ -219,28 +232,44 @@ class DyadCarrier(object):
             return NotImplemented
 
     def __rmul__(self, other):  # other * self
-        return DyadCarrier([other*ui for ui in self.u], self.v)
+        return DyadCarrier([other*ui for ui in self.u], self.v, shape=self.shape)
 
     def __mul__(self, other):  # self * other
-        return DyadCarrier(self.u, [vi*other for vi in self.v])
+        return DyadCarrier(self.u, [vi*other for vi in self.v], shape=self.shape)
 
     def copy(self):
         """ Returns a deep copy of the DyadCarrier """
-        return DyadCarrier(self.u, self.v)
+        return DyadCarrier(self.u, self.v, shape=self.shape)
 
     def conj(self):
         """ Returns (a deep copied) complex conjugate of the DyadCarrier """
-        return DyadCarrier([u.conj() for u in self.u], [v.conj() for v in self.v])
+        return DyadCarrier([u.conj() for u in self.u], [v.conj() for v in self.v], shape=self.shape)
 
     @property
     def real(self):
         """ Returns a deep copy of the real part of the DyadCarrier """
-        return DyadCarrier([*[u.real for u in self.u], *[-u.imag for u in self.u]], [*[v.real for v in self.v], *[v.imag for v in self.v]])
+        return DyadCarrier([*[u.real for u in self.u], *[-u.imag for u in self.u]], [*[v.real for v in self.v], *[v.imag for v in self.v]], shape=self.shape)
 
     @property
     def imag(self):
         """ Returns a deep copy of the imaginary part of the DyadCarrier """
-        return DyadCarrier([*[u.real for u in self.u], *[u.imag for u in self.u]], [*[v.imag for v in self.v], *[v.real for v in self.v]])
+        return DyadCarrier([*[u.real for u in self.u], *[u.imag for u in self.u]], [*[v.imag for v in self.v], *[v.real for v in self.v]], shape=self.shape)
+
+    def min(self):
+        minval = 0.0
+        for u, v in zip(self.u, self.v):
+            minval += u.min() * v.min()
+        if len(self.u) >= 2:
+            warnings.warn("The minimum is an approximation")
+        return minval
+
+    def max(self):
+        maxval = 0.0
+        for u, v in zip(self.u, self.v):
+            maxval += u.max() * v.max()
+        if len(self.u) >= 2:
+            warnings.warn("The maximum is an approximation")
+        return maxval
 
     # flake8: noqa: C901
     def contract(self, mat: Union[NDArray, spmatrix] = None, rows: NDArray[int] = None, cols: NDArray[int] = None):
@@ -446,7 +475,7 @@ class DyadCarrier(object):
 
     def transpose(self):
         """ Returns a deep copy of the transposed DyadCarrier matrix"""
-        return DyadCarrier(self.v, self.u)
+        return DyadCarrier(self.v, self.u, shape=(self.shape[1], self.shape[0]))
 
     def dot(self, other):
         """ Inner product """
@@ -474,9 +503,9 @@ class DyadCarrier(object):
         if other.ndim == 1:
             return self.__dot__(other)
 
-        return DyadCarrier(self.u, [vi@other for vi in self.v])
+        return DyadCarrier(self.u, [vi@other for vi in self.v], shape=(self.shape[0], other.shape[1]))
 
     def __rmatmul__(self, other):  # other @ self
         if other.ndim == 1:
             return self.__rdot__(other)
-        return DyadCarrier([other@ui for ui in self.u], self.v)
+        return DyadCarrier([other@ui for ui in self.u], self.v, shape=(other.shape[0], self.shape[1]))

pymoto/common/mma.py

@@ -28,20 +28,50 @@ def residual(x, y, z, lam, xsi, eta, mu, zet, s, upp, low, P0, P1, Q0, Q1, epsi,
     ])
 
 
-def subsolv(epsimin, low, upp, alfa, beta, P, Q, a0, a, b, c, d):
-    """ This function subsolv solves the MMA subproblem
-    minimize   SUM[ p0j/(uppj-xj) + q0j/(xj-lowj) ] + a0*z +
-             + SUM[ ci*yi + 0.5*di*(yi)^2 ],
-    subject to SUM[ pij/(uppj-xj) + qij/(xj-lowj) ] - ai*z - yi <= bi,
-               alfaj <=  xj <=  betaj,  yi >= 0,  z >= 0.
-    Input:  m, n, low, upp, alfa, beta, p0, q0, P, Q, a0, a, b, c, d.
-    Output: xmma,ymma,zmma, slack variables and Lagrange multiplers.
+def subsolv(epsimin, low, upp, alfa, beta, P, Q, a0, a, b, c, d, x0=None):
+    r""" This function solves the MMA subproblem
+
+    minimize   f_0(\vec{x}) + a_0*z + \sum_i^m[ c_i*y_i + 1/2*d_i*y_i^2 ],
+    subject to f_i(\vec{x}) - a_i*z - y_i <= b_i,   for i = 1, ..., m
+               alfa_j <=  x_j <=  beta_j,  for j = 1, ..., n
+               y_i >= 0,  for i = 1, ..., m
+               z >= 0.
+
+    where:
+        MMA approximation: :math:`f_i(\vec{x}) = \sum_j\left( p_{ij}/(upp_j-x_j) + q_{ij}/(x_j-low_j) \right)`
+        m: The number of general constraints
+        n: The number of variables in :math:`\vec{x}`
+
+    Args:
+        epsimin: Solution tolerance on maximum residual
+        low: Column vector with the lower asymptotes
+        upp: Column vector with the upper asymptotes
+        alfa: Vector with the lower bounds for the variables :math:`\vec{x}`
+        beta: Vector with the upper bounds for the variables :math:`\vec{x}`
+        P: Upper asymptotic amplitudes
+        Q: Lower asymptotic amplitudes
+        a0: The constants :math:`a_0` in the term :math:`a_0\cdot z`
+        a: Vector with the constants :math:`a_i` in the terms :math:`a_i \cdot z`
+        c: Vector with the constants :math:`c_i` in the terms :math:`c_i \cdot y_i`
+        d: Vector with the constants :math:`d_i` in the terms :math:`0.5 \cdot d_i \cdot y_i^2`
+        x0 (optional): Initial guess, in case not given :math:`x_0 = (\alpha + \beta)/2` is used
+
+    Returns:
+        x: Vector with the optimal values of the variables :math:`\vec{x}` in the current MMA subproblem
+        y: Vector with the optimal values of the variables :math:`y_i` in the current MMA subproblem
+        z: Scalar with the optimal value of the variable :math:`z` in the current MMA subproblem
+        lam: Lagrange multipliers for the :math:`m` general MMA constraints
+        xsi: Lagrange multipliers for the :math:'n' constraints :math:`alfa_j - x_j <= 0`
+        eta: Lagrange multipliers for the :math:'n' constraints :math:`x_j - beta_j <= 0`
+        mu: Lagrange multipliers for the :math:`m` constraints :math:`-y_i <= 0`
+        zet: Lagrange multiplier for the single constraint :math:`-z <= 0`
+        s: Slack variables for the m general MMA constraints
     """
 
     n, m = len(alfa), len(a)
     epsi = 1.0
     maxittt = 400
-    x = 0.5 * (alfa + beta)
+    x = 0.5 * (alfa + beta) if x0 is None else np.clip(x0, alfa+1e-10, beta-1e-10)  # Design variables
     y = np.ones(m)
     z = 1.0
     lam = np.ones(m)
@@ -168,8 +198,7 @@ def subsolv(epsimin, low, upp, alfa, beta, P, Q, a0, a, b, c, d):
             sold = s.copy()
 
             # Do linesearch
-            itto = 0
-            while itto < maxittt:
+            for itto in range(maxittt):
                 # Find new set of variables with stepsize
                 x[:] = xold + steg * dx
                 y[:] = yold + steg * dy
@@ -184,14 +213,13 @@ def subsolv(epsimin, low, upp, alfa, beta, P, Q, a0, a, b, c, d):
                 residu = residual(x, y, z, lam, xsi, eta, mu, zet, s, upp, low, P0, P1, Q0, Q1, epsi, a0, a, b, c, d, alfa, beta)
                 if np.linalg.norm(residu) < residunorm:
                     break
-                itto += 1
                 steg /= 2  # Reduce stepsize
 
             residunorm = np.linalg.norm(residu)
             residumax = np.max(np.abs(residu))
 
         if ittt > maxittt - 2:
-            print(f"MMA Subsolver: itt = {ittt}, at epsi = {epsi}")
+            print(f"MMA Subsolver: itt = {ittt}, at epsi = {'%.3e'%epsi}")
         # decrease epsilon with factor 10
         epsi /= 10
 
@@ -200,8 +228,7 @@ def subsolv(epsimin, low, upp, alfa, beta, P, Q, a0, a, b, c, d):
 
 
 class MMA:
-    """
-    Block for the MMA algorithm
+    r""" Class for the MMA optimization algorithm
     The design variables are set by keyword <variables> accepting a list of variables.
     The responses are set by keyword <responses> accepting a list of signals.
     If none are given, the internal sig_in and sig_out are used.
@@ -251,19 +278,15 @@ class MMA:
 
         self.a0 = kwargs.get("a0", 1.0)
 
-        self.epsimin = kwargs.get("epsimin", 1e-7)  # Or 1e-7 ?? witout sqrt(m+n) or 1e-9
-        self.raa0 = kwargs.get("raa0", 1e-5)
-
+        self.epsimin = kwargs.get("epsimin", 1e-10)  # Or 1e-7 ?? witout sqrt(m+n) or 1e-9
         self.cCoef = kwargs.get("cCoef", 1e3)  # Svanberg uses 1e3 in example? Old code had 1e7
 
-        # Not used
-        self.dxmin = kwargs.get("dxmin", 1e-5)
-
         self.albefa = kwargs.get("albefa", 0.1)
         self.asyinit = kwargs.get("asyinit", 0.5)
         self.asyincr = kwargs.get("asyincr", 1.2)
         self.asydecr = kwargs.get("asydecr", 0.7)
         self.asybound = kwargs.get("asybound", 10.0)
+        self.mmaversion = kwargs.get("mmaversion", "Svanberg2007")  # Options are Svanberg1987, Svanberg2007
 
         self.ittomax = kwargs.get("ittomax", 400)
 
@@ -287,7 +310,6 @@ class MMA:
         self.d = np.ones(self.m)
         self.gold1 = np.zeros(self.m + 1)
         self.gold2 = self.gold1.copy()
-        self.rho = self.raa0 * np.ones(self.m + 1)
 
     def response(self):
         change = 1
@@ -352,7 +374,7 @@ class MMA:
             # Save response
             f = ()
             for s in self.responses:
-                if not np.isscalar(s.state):
+                if np.size(s.state) != 1:
                     raise TypeError("State of responses must be scalar.")
                 f += (s.state, )
 
@@ -443,57 +465,6 @@ class MMA:
         if self.offset is None:
             self.offset = self.asyinit * np.ones(self.n)
 
-        #      Minimize  f_0(x) + a_0*z + sum( c_i*y_i + 0.5*d_i*(y_i)^2 )
-        #    subject to  f_i(x) - a_i*z - y_i <= 0,  i = 1,...,m
-        #                xmin_j <= x_j <= xmax_j,    j = 1,...,n
-        #                z >= 0,   y_i >= 0,         i = 1,...,m
-        # *** INPUT:
-        #
-        #   m    = The number of general constraints.
-        #   n    = The number of variables x_j.
-        #  iter  = Current iteration number ( =1 the first time mmasub is called).
-        #  xval  = Column vector with the current values of the variables x_j.
-        #  xmin  = Column vector with the lower bounds for the variables x_j.
-        #  xmax  = Column vector with the upper bounds for the variables x_j.
-        #  xold1 = xval, one iteration ago (provided that iter>1).
-        #  xold2 = xval, two iterations ago (provided that iter>2).
-        #  f0val = The value of the objective function f_0 at xval.
-        #  df0dx = Column vector with the derivatives of the objective function
-        #          f_0 with respect to the variables x_j, calculated at xval.
-        #  fval  = Column vector with the values of the constraint functions f_i,
-        #          calculated at xval.
-        #  dfdx  = (m x n)-matrix with the derivatives of the constraint functions
-        #          f_i with respect to the variables x_j, calculated at xval.
-        #          dfdx(i,j) = the derivative of f_i with respect to x_j.
-        #  low   = Column vector with the lower asymptotes from the previous
-        #          iteration (provided that iter>1).
-        #  upp   = Column vector with the upper asymptotes from the previous
-        #          iteration (provided that iter>1).
-        #  a0    = The constants a_0 in the term a_0*z.
-        #  a     = Column vector with the constants a_i in the terms a_i*z.
-        #  c     = Column vector with the constants c_i in the terms c_i*y_i.
-        #  d     = Column vector with the constants d_i in the terms 0.5*d_i*(y_i)^2.
-        #
-
-        # *** OUTPUT:
-        #
-        #  xmma  = Column vector with the optimal values of the variables x_j
-        #          in the current MMA subproblem.
-        #  ymma  = Column vector with the optimal values of the variables y_i
-        #          in the current MMA subproblem.
-        #  zmma  = Scalar with the optimal value of the variable z
-        #          in the current MMA subproblem.
-        #  lam   = Lagrange multipliers for the m general MMA constraints.
-        #  xsi   = Lagrange multipliers for the n constraints alfa_j - x_j <= 0.
-        #  eta   = Lagrange multipliers for the n constraints x_j - beta_j <= 0.
-        #   mu   = Lagrange multipliers for the m constraints -y_i <= 0.
-        #  zet   = Lagrange multiplier for the single constraint -z <= 0.
-        #   s    = Slack variables for the m general MMA constraints.
-        #  low   = Column vector with the lower asymptotes, calculated and used
-        #          in the current MMA subproblem.
-        #  upp   = Column vector with the upper asymptotes, calculated and used
-        #          in the current MMA subproblem.
-
         # # ASYMPTOTES
         # Calculation of the asymptotes low and upp :
         # For iter = 1,2 the asymptotes are fixed depending on asyinit
@@ -536,16 +507,27 @@ class MMA:
         # # APPROXIMATE CONVEX SEPARABLE FUNCTIONS
         # Calculations of p0, q0, P, Q and b.
         # calculate the constant factor in calculations of pij and qij
+        # From: Svanberg(2007) - MMA and GCMMA, two methods for nonlinear optimization
+        dg_plus = np.maximum(+dg, 0)
+        dg_min = np.maximum(-dg, 0)
         dx2 = shift**2
-        P = dx2 * np.maximum(+dg, 0)
-        Q = dx2 * np.maximum(-dg, 0)
+        if '1987' in self.mmaversion:
+            # Original version
+            P = dx2 * dg_plus
+            Q = dx2 * dg_min
+        elif '2007' in self.mmaversion:
+            # Improved version -> Allows to use higher epsimin to get design variables closer to the bound.
+            P = dx2 * (1.001*dg_plus + 0.001*dg_min + 1e-5/self.dx)
+            Q = dx2 * (0.001*dg_plus + 1.001*dg_min + 1e-5/self.dx)
+        else:
+            raise ValueError("Only \"Svanberg1987\" or \"Svanberg2007\" are valid options")
 
         rhs = np.dot(P, 1 / shift) + np.dot(Q, 1 / shift) - g
         b = rhs[1:]
 
         # Solving the subproblem by a primal-dual Newton method
         epsimin_scaled = self.epsimin*np.sqrt(self.m + self.n)
-        xmma, ymma, zmma, lam, xsi, eta, mu, zet, s = subsolv(epsimin_scaled, self.low, self.upp, alfa, beta, P, Q, self.a0, self.a, b, self.c, self.d)
+        xmma, ymma, zmma, lam, xsi, eta, mu, zet, s = subsolv(epsimin_scaled, self.low, self.upp, alfa, beta, P, Q, self.a0, self.a, b, self.c, self.d, x0=xval)
 
         self.gold2, self.gold1 = self.gold1, g.copy()
         self.xold2, self.xold1 = self.xold1, xval.copy()
@@ -582,3 +564,4 @@ class MMA:
             print(f"  | Changes: {', '.join(change_msgs)}")
 
         return xmma, change
+      

pymoto/core_objects.py

@@ -107,6 +107,9 @@ class Signal:
                 return
             if self.sensitivity is None:
                 self.sensitivity = copy.deepcopy(ds)
+            elif hasattr(self.sensitivity, "add_sensitivity"):
+                # Allow user to implement a custom add_sensitivity function instead of __iadd__
+                self.sensitivity.add_sensitivity(ds)
             else:
                 self.sensitivity += ds
             return self
@@ -593,19 +596,24 @@ class Network(Module):
 
         self.print_timing = print_timing
 
-    def timefn(self, fn):
+    def timefn(self, fn, prefix='Evaluation'):
         start_t = time.time()
         fn()
-        print(f"Evaluating {fn} took {time.time() - start_t} s")
+        duration = time.time() - start_t
+        if duration > .5:
+            print(f"{prefix} {fn} took {time.time() - start_t} s")
 
     def response(self):
         if self.print_timing:
-            [self.timefn(b.response) for b in self.mods]
+            [self.timefn(b.response, prefix='Response') for b in self.mods]
         else:
             [b.response() for b in self.mods]
 
     def sensitivity(self):
-        [b.sensitivity() for b in reversed(self.mods)]
+        if self.print_timing:
+            [self.timefn(b.sensitivity, 'Sensitivity') for b in reversed(self.mods)]
+        else:
+            [b.sensitivity() for b in reversed(self.mods)]
 
     def reset(self):
         [b.reset() for b in reversed(self.mods)]

pymoto/modules/assembly.py

@@ -325,29 +325,47 @@ class ElementOperation(Module):
 
     :math:`y_e = \mathbf{B} \mathbf{u}_e`
 
+    This module is the reverse of :py:class:`pymoto.NodalOperation`.
+
     Input Signal:
-        - ``u``: Nodal vector of size ``(n_dof_per_element * #nodes)``
+        - ``u``: Nodal vector of size ``(#dofs_per_node * #nodes)``
 
     Output Signal:
-        - ``y``: Elemental output data of size ``(..., #elements)``
+        - ``y``: Elemental output data of size ``(..., #elements)`` or ``(#dofs, ..., #elements)``
 
     Args:
         domain: The domain defining element and nodal connectivity
-        element_matrix: The element operator matrix :math:`\mathbf{B}` of size ``(..., n_dof_per_element)``
+        element_matrix: The element operator matrix :math:`\mathbf{B}` of size ``(..., #dofs_per_element)`` or ``(..., #nodes_per_element)``
     """
     def _prepare(self, domain: DomainDefinition, element_matrix: np.ndarray):
         if element_matrix.shape[-1] % domain.elemnodes != 0:
-            raise IndexError("Size of last dimension of element operator matrix is not compatible with mesh. "
-                             "Must be dividable by the number of nodes.")
-
-        ndof = element_matrix.shape[-1] // domain.elemnodes
-
+            raise IndexError(
+                f"Size of last dimension of element operator matrix ({element_matrix.shape[-1]}) is not compatible "
+                f"with mesh. Must be dividable by the number of nodes per element ({domain.elemnodes})."
+            )
+        self.domain = domain
         self.element_matrix = element_matrix
-        self.dofconn = domain.get_dofconnectivity(ndof)
-        self.usiz = ndof * domain.nnodes
+        self.dofconn = None
 
     def _response(self, u):
-        assert u.size == self.usiz
+        if u.size % self.domain.nnodes != 0:
+            raise IndexError(f"Size of input vector ({u.size}) does not match number of nodes ({self.domain.nnodes})")
+        ndof = u.size // self.domain.nnodes
+
+        if self.element_matrix.shape[-1] != self.domain.elemnodes * ndof:
+            # Initialize only after first call to response(), because the number of dofs may not yet be known
+            em = self.element_matrix.copy()
+            assert em.shape[-1] == self.domain.elemnodes, f"Size of element matrix must match #dofs_per_element ({ndof*self.domain.elemnodes}) or #nodes_per_element ({self.domain.elemnodes})."
+
+            # Element matrix is repeated for each dof
+            self.element_matrix = np.zeros((ndof, *self.element_matrix.shape[:-1], ndof * self.domain.elemnodes))
+            for i in range(ndof):
+                self.element_matrix[i, ..., i::ndof] = em
+
+        if self.dofconn is None:
+            self.dofconn = self.domain.get_dofconnectivity(ndof)
+
+        assert self.element_matrix.shape[-1] == ndof * self.domain.elemnodes
         return einsum('...k, lk -> ...l', self.element_matrix, u[self.dofconn], optimize=True)
 
     def _sensitivity(self, dy):
@@ -372,10 +390,10 @@ class Strain(ElementOperation):
     in case ``voigt = True``, for which :math:`\gamma_{xy}=2\epsilon_{xy}`.
 
     Input Signal:
-       - ``u``: Nodal vector of size ``(#dof per element * #nodes)``
+       - ``u``: Nodal vector of size ``(#dofs_per_node * #nodes)``
 
     Output Signal:
-       - ``e``: Strain matrix of size ``(#strains per element, #elements)``
+       - ``e``: Strain matrix of size ``(#strains_per_element, #elements)``
 
     Args:
         domain: The domain defining element and nodal connectivity
@@ -408,10 +426,10 @@ class Stress(Strain):
     """ Calculate the average stresses per element
 
     Input Signal:
-       - ``u``: Nodal vector of size ``(#dof per element * #nodes)``
+       - ``u``: Nodal vector of size ``(#dofs_per_node * #nodes)``
 
     Output Signal:
-       - ``s``: Stress matrix of size ``(#stresses per element, #elements)``
+       - ``s``: Stress matrix of size ``(#stresses_per_element, #elements)``
 
     Args:
         domain: The domain defining element and nodal connectivity
@@ -431,3 +449,99 @@ class Stress(Strain):
         if domain.dim == 2:
             D *= domain.element_size[2]
         self.element_matrix = D @ self.element_matrix
+
+
+class ElementAverage(ElementOperation):
+    r""" Determine average value in element of input nodal values
+
+    Input Signal:
+       - ``v``: Nodal vector of size ``(#dofs_per_node * #nodes)``
+
+    Output Signal:
+       - ``v_el``: Elemental vector of size ``(#elements)`` or ``(#dofs, #elements)`` if ``#dofs_per_node>1``
+
+    Args:
+        domain: The domain defining element and nodal connectivity
+    """
+    def _prepare(self, domain: DomainDefinition):
+        shapefuns = domain.eval_shape_fun(pos=np.array([0, 0, 0]))
+        super()._prepare(domain, shapefuns)
+
+
+class NodalOperation(Module):
+    r""" Generic module for nodal operations based on elemental information
+
+    :math:`u_e = \mathbf{A} x_e`
+
+    This module is the reverse of :py:class:`pymoto.ElementOperation`.
+
+    Input Signal:
+        - ``x``: Elemental vector of size ``(#elements)``
+
+    Output Signal:
+        - ``u``: nodal output data of size ``(..., #dofs_per_node * #nodes)``
+
+    Args:
+        domain: The domain defining element and nodal connectivity
+        element_matrix: The element operator matrix :math:`\mathbf{A}` of size ``(..., #dofs_per_element)``
+    """
+    def _prepare(self, domain: DomainDefinition, element_matrix: np.ndarray):
+        if element_matrix.shape[-1] % domain.elemnodes != 0:
+            raise IndexError("Size of last dimension of element operator matrix is not compatible with mesh. "
+                             "Must be dividable by the number of nodes.")
+
+        ndof = element_matrix.shape[-1] // domain.elemnodes
+
+        self.element_matrix = element_matrix
+        self.dofconn = domain.get_dofconnectivity(ndof)
+        self.ndofs = ndof*domain.nnodes
+
+    def _response(self, x):
+        dofs_el = einsum('...k, ...l -> lk', self.element_matrix, x, optimize=True)
+        dofs = np.zeros(self.ndofs)
+        np.add.at(dofs, self.dofconn, dofs_el)
+        return dofs
+
+    def _sensitivity(self, dx):
+        return einsum('...k, lk -> ...l', self.element_matrix, dx[self.dofconn], optimize=True)
+
+
+class ThermoMechanical(NodalOperation):
+    r""" Determine equivalent thermo-mechanical load from design vector and elemental temperature difference
+
+    :math:`f_thermal = \mathbf{A} (x*t_delta)_e`
+
+    Input Signal:
+        - ``x*t_delta``: Elemental vector of size ``(#elements)`` containing elemental densities multiplied by
+                         elemental temperature difference
+
+    Output Signal:
+        - ``f_thermal``: nodal equivalent thermo-mechanical load of size ``(#dofs_per_node * #nodes)``
+
+    Args:
+        domain: The domain defining element and nodal connectivity
+        e_modulus (optional): Young's modulus
+        poisson_ratio (optional): Poisson ratio
+        alpha (optional): Coefficient of thermal expansion
+        plane (optional): Plane 'strain' or 'stress'
+    """
+    def _prepare(self, domain: DomainDefinition, e_modulus: float = 1.0, poisson_ratio: float = 0.3, alpha: float = 1e-6, plane: str = 'strain'):
+        dim = domain.dim
+        D = get_D(e_modulus, poisson_ratio, '3d' if dim == 3 else plane.lower())
+        if dim == 2:
+            Phi = np.array([1, 1, 0])
+            D *= domain.element_size[2]
+        elif dim == 3:
+            Phi = np.array([1, 1, 1, 0, 0, 0])
+
+        # Numerical integration
+        BDPhi = np.zeros(domain.elemnodes * dim)
+        siz = domain.element_size
+        w = np.prod(siz[:domain.dim] / 2)
+        for n in domain.node_numbering:
+            pos = n * (siz / 2) / np.sqrt(3)  # Sampling point
+            dN_dx = domain.eval_shape_fun_der(pos)
+            B = get_B(dN_dx)
+            BDPhi += w * B.T @ D @ Phi  # Add contribution
+
+        super()._prepare(domain, alpha*BDPhi)

pymoto/modules/io.py

@@ -255,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
@@ -282,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

@@ -9,7 +9,7 @@ import scipy.sparse.linalg as spsla
 
 from pymoto import Signal, Module, DyadCarrier
 from pymoto.solvers import auto_determine_solver
-from pymoto.solvers import matrix_is_hermitian, LDAWrapper
+from pymoto.solvers import matrix_is_sparse, matrix_is_complex, matrix_is_hermitian, LDAWrapper
 
 
 class StaticCondensation(Module):
@@ -251,8 +251,8 @@ class LinSolve(Module):
 
     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:
@@ -318,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)``
@@ -346,12 +343,14 @@ class EigenSolve(Module):
         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:
@@ -364,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):
@@ -380,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)
 
@@ -389,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
@@ -473,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,6 +1,7 @@
 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.
@@ -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

pymoto/routines.py

@@ -102,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]
@@ -171,6 +175,9 @@ 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
                 if issparse(fp):
@@ -227,6 +234,10 @@ 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
                     if issparse(fp):
                         df = (fp.toarray() - f0[Iout].toarray()) / (dx * 1j * sf)

pymoto/solvers/__init__.py

@@ -1,11 +1,11 @@
 from .solvers import LinearSolver, LDAWrapper
-from .matrix_checks import matrix_is_complex, matrix_is_diagonal, matrix_is_symmetric, matrix_is_hermitian
+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_complex', 'matrix_is_diagonal', 'matrix_is_symmetric', 'matrix_is_hermitian',
+__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',

pymoto/solvers/auto_determine.py

@@ -21,7 +21,7 @@ def auto_determine_solver(A, isdiagonal=None, islowertriangular=None, isuppertri
     :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
+    issparse = matrix_is_sparse(A)  # Check if the matrix is sparse
     issquare = A.shape[0] == A.shape[1]  # Check if the matrix is square
 
     if not issquare:

pymoto/solvers/matrix_checks.py

@@ -12,6 +12,10 @@ def is_cvxopt_spmatrix(A):
     return isinstance(A, cvxopt.spmatrix) if _has_cvxopt else False
 
 
+def matrix_is_sparse(A):
+    return sps.issparse(A)
+
+
 def matrix_is_complex(A):
     """ Checks if the matrix is complex """
     if is_cvxopt_spmatrix(A):
@@ -22,7 +26,7 @@ def matrix_is_complex(A):
 
 def matrix_is_diagonal(A):
     """ Checks if the matrix is diagonal"""
-    if sps.issparse(A):
+    if matrix_is_sparse(A):
         if isinstance(A, sps.dia_matrix):
             return len(A.offsets) == 1 and A.offsets[0] == 0
         else:
@@ -35,7 +39,7 @@ def matrix_is_diagonal(A):
 
 def matrix_is_symmetric(A):
     """ Checks whether a matrix is numerically symmetric """
-    if sps.issparse(A):
+    if matrix_is_sparse(A):
         return np.allclose((A-A.T).data, 0)
     elif is_cvxopt_spmatrix(A):
         return np.isclose(max(abs(A-A.T)), 0.0)
@@ -46,7 +50,7 @@ def matrix_is_symmetric(A):
 def matrix_is_hermitian(A):
     """ Checks whether a matrix is numerically Hermitian """
     if matrix_is_complex(A):
-        if sps.issparse(A):
+        if matrix_is_sparse(A):
             return np.allclose((A-A.T.conj()).data, 0)
         elif is_cvxopt_spmatrix(A):
             return np.isclose(max(abs(A-A.ctrans())), 0.0)

pymoto/solvers/sparse.py

@@ -126,6 +126,7 @@ class SolverSparsePardiso(LinearSolver):
             self._pardiso_solver = PyPardisoSolver(mtype=self._mtype)
 
         self._pardiso_solver.factorize(A)
+        self._pardiso_solver.set_phase(33)
 
     def solve(self, b, x0=None, trans='N'):
         """ solve Ax=b for x

pyMOTO-1.4.0.dist-info/RECORD

@@ -1,29 +0,0 @@
-pymoto/__init__.py,sha256=jsqGNDDpd3Tde1w46C5GqQCuAqfgN3faVjReYMQFiLw,1922
-pymoto/core_objects.py,sha256=mgn5etKHwAOINvu9qqTU89yLs0CDPvxi0anb7q76bNI,24798
-pymoto/routines.py,sha256=KlP6kgY-817i51Z9EotDclaRnOjrSD4SdymD0Rt7yX0,15186
-pymoto/utils.py,sha256=YJ-PNLJLc12Yx6TYCrEechS2aaBRx0o4mTM1soeeyz0,1122
-pymoto/common/domain.py,sha256=QJmdRXzexc1KbdLHNP6X6v5whZWtn0f8b4Rv_wlRBT8,18078
-pymoto/common/dyadcarrier.py,sha256=b8Ji8einZ4c0lMDuwxd4ZHwRckb2pkuZtAl4Sbg9q4w,18273
-pymoto/common/mma.py,sha256=sO4PzG2SBeanK82v-Lyw0c29uPmh2q40nXQVt2NCIBU,24838
-pymoto/modules/aggregation.py,sha256=Oi17hIJ6dic4lOPw16zmjbdC72MjB6XK34H80bnbWAI,7580
-pymoto/modules/assembly.py,sha256=UpTzp4KGKVcWruEpNarmNRK5lp6CK82QB-7d4Wk2xTg,18138
-pymoto/modules/autodiff.py,sha256=WAfoAOHBSozf7jbr9gQz9Vw4a_2G9wGJxLMMqUQP0Co,1684
-pymoto/modules/complex.py,sha256=B_Obk-ABdV66lEudZ5s8o6qG9NsmYlBsX-PbWvbphhc,4429
-pymoto/modules/filter.py,sha256=6X9FaQMWYZ_TpHVTFiEibzlmAwmSWbydYM93LFrJ0Wo,25490
-pymoto/modules/generic.py,sha256=YzsGZ8J0oLCORt78Bf2p0v4GuqpWRI77NLoCk7gqidw,10666
-pymoto/modules/io.py,sha256=huqF2A54Tk0f36WRDLaRR7_CdeahmQc25OfvqqQ2hT4,11012
-pymoto/modules/linalg.py,sha256=kvfPTblFXGANWzCxEliTMi8qKxgKiejh2zGp_60iL_Q,19358
-pymoto/modules/scaling.py,sha256=FN6WsqJME-bkJ5nhoKziS_utFCserpRmRDKlJ8F3MEo,2326
-pymoto/solvers/__init__.py,sha256=CuEJMqnZ2QWgj96n4mB18LWonT4D3cq7FgnubrZsxXg,995
-pymoto/solvers/auto_determine.py,sha256=Q4TcTT49SYmPLVG0LMmzOx2Tnly--fLXAQVVYjDzGG0,5130
-pymoto/solvers/dense.py,sha256=9fKPCwNxRKAEk5k1A7fdLrr9ngeVssGlw-sbjWCm4iU,11235
-pymoto/solvers/iterative.py,sha256=CIxJHjGnCaIjXbtO2NxV60yeDpcCbSD6Bp0xR-7vOf0,12944
-pymoto/solvers/matrix_checks.py,sha256=gmq7vwFQaXjH3QG-2bW5LcMJF0abTejzw1vEVXCfLPc,1597
-pymoto/solvers/solvers.py,sha256=RwHjZYYlE3oA0U9k7ukla2gOdmq57rSSJQvHqjaM7JU,10626
-pymoto/solvers/sparse.py,sha256=VtAdscg7USR8oG_RlS21k64J7VQDa5Rk0ByJ9fzvb_0,16621
-pyMOTO-1.4.0.dist-info/LICENSE,sha256=ZXMC2Txpzs-dBwz9Me4_1rQCSVl4P1B27MomNi43F30,1072
-pyMOTO-1.4.0.dist-info/METADATA,sha256=JpafKYREI7mIGlwLQ3v5sFyskvPYPTJBt9u7H-mIhi8,5006
-pyMOTO-1.4.0.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
-pyMOTO-1.4.0.dist-info/top_level.txt,sha256=EdvAUSmFMaiqhuEZW8jxANMiK-LdPtlmDWL6SfmCdUU,7
-pyMOTO-1.4.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-pyMOTO-1.4.0.dist-info/RECORD,,