pyMOTO 1.0.1__py3-none-any.whl → 1.0.2rc1__py3-none-any.whl

{pyMOTO-1.0.1.dist-info → pyMOTO-1.0.2rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyMOTO
-Version: 1.0.1
+Version: 1.0.2rc1
 Summary: Example package description
 Home-page: https://github.com/aatmdelissen/pyMOTO
 Author: Arnoud Delissen
@@ -25,6 +25,8 @@ Requires-Dist: scikit-sparse ; extra == 'dev'
 Requires-Dist: pypardiso ; extra == 'dev'
 Requires-Dist: jax[cpu] ; extra == 'dev'
 
+[![10.5281/zenodo.7708738](https://zenodo.org/badge/DOI/10.5281/zenodo.7708738.svg)](https://doi.org/10.5281/zenodo.7708738)
+
 # pyMOTO
 
 * [Link to Documentation](https://pymoto.readthedocs.io)
@@ -64,35 +66,19 @@ A local installation for development in `pyMOTO` can be done by first downloadin
 * **SymPy** - Symbolic differentiation for `MathGeneral` module
 * **Matplotlib** - Plotting and visualisation
 * (optional) **SAO** - Sequential approximated optimizers
-* (optional) **opt_einsum** - Optimized function for `EinSum` module
+* (optional) [**opt_einsum**](https://optimized-einsum.readthedocs.io/en/stable/install.html) - Optimized function for `EinSum` module
 
 For fast linear solvers for sparse matrices:
-* (optional) **scikit-umfpack** - Fast LU linear solver based on UMFPACK
-* (optional) **sksparse** - Fast Cholesky solver based on CHOLMOD
-* (optional) **CVXopt** - Another fast Cholesky solver based on CHOLMOD
-* (optional) **Intel OneAPI** - Non-python library with a fast PARDISO solver
+* (optional) [**pypardiso**](https://github.com/haasad/PyPardisoProject) - Uses the Intel OneAPI PARDISO solver (recommended)
+* (optional) [**scikit-umfpack**](https://scikit-umfpack.github.io/scikit-umfpack/install.html) - Fast LU linear solver based on UMFPACK
+* (optional) [**scikit-sparse**](https://github.com/scikit-sparse/scikit-sparse) - Fast Cholesky solver based on CHOLMOD
+* (optional) [**cvxopt**](https://cvxopt.org/install/index.html) - Another fast Cholesky solver based on CHOLMOD
 
 __Note on linear solvers for sparse matrices:__ Scipy implements a version of LU which is quite slow. To increase the 
-speed of the optimization, `Intel OneAPI` is recommended as it contains a very robust and flexible solver for symmetric 
+speed of the optimization, `pypardiso` is recommended as it contains a very robust and flexible solver for symmetric 
 and asymmetric matrices. An alternative is `scikit-umfpack` which provides a fast LU factorization. For symmetric 
 matrices a Cholesky factorization is recommended (not provided with Scipy), which can be used by either installing 
-`sksparse` or `cvxopt`.
-
-
-## How to make Python fast with Intel OneAPI
-Intel provides a toolkit with many fast math operations and solvers called OneAPI (basekit). 
-It can easily be installed on Linux by for instance following the steps described in https://www.intel.com/content/www/us/en/develop/documentation/installation-guide-for-intel-oneapi-toolkits-linux/top/installation/install-using-package-managers/apt.html
-For other OSes installation can be found in https://www.intel.com/content/www/us/en/developer/articles/guide/installation-guide-for-oneapi-toolkits.html
-
-The nice thing about OneAPI is that it also includes an optimized version of Python. To use it follow the next steps (Linux)
-
-1. `source <intel install location>/intel/oneapi/setvars.sh` (usually installed in `/opt/intel` or `/opt/ud/intel`). This loads the Intel OneAPI package.
-2. `conda create --name <venv_name> --clone base` to create a new conda virtual environment to work in.
-3. `conda activate <venv_name>` to activate the virtual environment.
-
-### Usage of multi-thread linear solvers
-Intel has a Pardiso type linear solver for fast solution of large systems.
-To use it.....
+`scikit-sparse` or `cvxopt`.
 
 # License
 pyMOTO is available under te [MIT License](https://opensource.org/licenses/MIT).

pyMOTO-1.0.2rc1.dist-info/RECORD

@@ -0,0 +1,23 @@
+pymoto/__init__.py,sha256=owmlGqvdF7Gc00pZRuSX5G_lt05F34xtgsVWP4QijPA,2031
+pymoto/core_objects.py,sha256=V870S_G8xTArGoIM9VjMGCEXzeaolCJ_HJ2lbFzLE58,23491
+pymoto/routines.py,sha256=WHOeTu5NF6kCiVYIT2pmACUyP_rCxdRU5dF9I8VyQWQ,13972
+pymoto/utils.py,sha256=YJ-PNLJLc12Yx6TYCrEechS2aaBRx0o4mTM1soeeyz0,1122
+pymoto/common/domain.py,sha256=Bo5Qqnben3Ih0IuprnoO2CmG09shEVUWt1hyiVFnB9U,15136
+pymoto/common/dyadcarrier.py,sha256=iszzJMLiHbnLn4_UoCa8PkhdEQPKytLlDxXWsGCmze8,17206
+pymoto/common/mma.py,sha256=7KhJJM48taB0EkTpQWPXNSPNL4tqFNdQhI4qwf1LNgE,23304
+pymoto/common/solvers.py,sha256=92brZkAXc-8jNM3YfL24CCV99uuz0u4weIgyrn8__aw,8143
+pymoto/common/solvers_dense.py,sha256=vuBUp3y4qJLwmsXbFQ_tEb-7LqqCEemFunTn1z_Qu0U,9901
+pymoto/common/solvers_sparse.py,sha256=QVbGTwGtbhOqRUyg2gHmY-K5haiPbskGA6uj_g-dKz8,15776
+pymoto/modules/assembly.py,sha256=j5m-Qq9wKbvKauhWpwtGKHDElStMIbXacZxxapWMj6I,11313
+pymoto/modules/autodiff.py,sha256=WAfoAOHBSozf7jbr9gQz9Vw4a_2G9wGJxLMMqUQP0Co,1684
+pymoto/modules/complex.py,sha256=vwzqRo5W319mVf_RqbB7LpYe7jXruVxa3ZV560Iq39k,4421
+pymoto/modules/filter.py,sha256=8A-dmWSFEqFyQcutjFv__pfgAwszCVZeZgLxuG9hi0g,18840
+pymoto/modules/generic.py,sha256=UsTIYeRINjQUyLKieian1lYHSsigTNFDdPSPIK-p8PA,9386
+pymoto/modules/io.py,sha256=4k5S-YQHKhw_HwmqOoYQWFEzdcL5nMJ5fVD2FJFqpFg,10532
+pymoto/modules/linalg.py,sha256=afB_NHfX2hvkVHI2U2DCEvg4kgfu3QwzlgUeV3DoR1o,16185
+pyMOTO-1.0.2rc1.dist-info/LICENSE,sha256=ZXMC2Txpzs-dBwz9Me4_1rQCSVl4P1B27MomNi43F30,1072
+pyMOTO-1.0.2rc1.dist-info/METADATA,sha256=YIavv2fQxY2fz79TPmAaWzlxmbo6uzx3Dswg0kQUjgc,4471
+pyMOTO-1.0.2rc1.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+pyMOTO-1.0.2rc1.dist-info/top_level.txt,sha256=EdvAUSmFMaiqhuEZW8jxANMiK-LdPtlmDWL6SfmCdUU,7
+pyMOTO-1.0.2rc1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pyMOTO-1.0.2rc1.dist-info/RECORD,,

{pyMOTO-1.0.1.dist-info → pyMOTO-1.0.2rc1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.38.4)
+Generator: bdist_wheel (0.40.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pymoto/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '1.0.1'
+__version__ = '1.0.2-rc1'
 
 from .core_objects import Signal, Module, Network, make_signals
 from .routines import finite_difference, minimize_oc, minimize_mma
@@ -6,13 +6,14 @@ from .routines import finite_difference, minimize_oc, minimize_mma
 # Imports from common
 from .common.dyadcarrier import DyadCarrier
 from .common.domain import DomainDefinition
+from .common.mma import MMA
 from .common.solvers import matrix_is_complex, matrix_is_diagonal, matrix_is_symmetric, matrix_is_hermitian, \
     LinearSolver, LDAWrapper
 from .common.solvers_dense import SolverDiagonal, SolverDenseQR, SolverDenseLU, SolverDenseCholesky, SolverDenseLDL
 from .common.solvers_sparse import SolverSparsePardiso, SolverSparseLU, SolverSparseCholeskyScikit, SolverSparseCholeskyCVXOPT
 
 # Import from modules
-from .modules.generic import MathGeneral, EinSum
+from .modules.generic import MathGeneral, EinSum, ConcatSignal
 from .modules.linalg import Inverse, LinSolve, EigenSolve
 from .modules.assembly import AssembleGeneral, AssembleStiffness, AssembleMass
 from .modules.filter import FilterConv, Filter, DensityFilter, OverhangFilter
@@ -24,6 +25,7 @@ __all__ = [
     'Signal', 'Module', 'Network', 'make_signals',
     'finite_difference', 'minimize_oc', 'minimize_mma',
     # Common
+    'MMA',
     'DyadCarrier',
     'DomainDefinition',
     'matrix_is_complex', 'matrix_is_diagonal', 'matrix_is_symmetric', 'matrix_is_hermitian',
@@ -31,7 +33,7 @@ __all__ = [
     'SolverDiagonal', 'SolverDenseQR', 'SolverDenseLU', 'SolverDenseCholesky', 'SolverDenseLDL',
     'SolverSparsePardiso', 'SolverSparseLU', 'SolverSparseCholeskyScikit', 'SolverSparseCholeskyCVXOPT',
     # Modules
-    "MathGeneral", "EinSum",
+    "MathGeneral", "EinSum", "ConcatSignal",
     "Inverse", "LinSolve", "EigenSolve",
     "AssembleGeneral", "AssembleStiffness", "AssembleMass",
     "FilterConv", "Filter", "DensityFilter", "OverhangFilter",

pymoto/common/mma.py

@@ -0,0 +1,554 @@
+import numpy as np
+from pymoto.utils import _parse_to_list, _concatenate_to_array
+
+
+def residual(x, y, z, lam, xsi, eta, mu, zet, s, upp, low, P0, P1, Q0, Q1, epsi, a0, a, b, c, d, alfa, beta):
+    # upcoming lines determine the left hand sides, i.e. the resiudals of all constraints
+    ux1 = upp - x
+    xl1 = x - low
+
+    plam = P0 + np.dot(lam, P1)
+    qlam = Q0 + np.dot(lam, Q1)
+    gvec = np.dot(P1, 1/ux1) + np.dot(Q1, 1/xl1)
+
+    # gradient of approximation function wrt x
+    dpsidx = plam / (ux1**2) - qlam / (xl1**2)
+
+    # put all residuals in one line
+    return np.concatenate([
+        dpsidx - xsi + eta,  # rex [n]
+        c + d * y - mu - lam,  # rey [m]
+        np.array([a0 - zet - np.dot(a, lam)]),  # rez [1]
+        gvec - a * z - y + s - b,  # relam [m]
+        xsi * (x - alfa) - epsi,  # rexsi [n]
+        eta * (beta - x) - epsi,  # reeta [n]
+        mu * y - epsi,  # remu [m]
+        np.array([zet * z - epsi]),  # rezet [1]
+        lam * s - epsi,  # res [m]
+    ])
+
+
+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.
+    """
+
+    n, m = len(alfa), len(a)
+    epsi = 1.0
+    maxittt = 400
+    x = 0.5 * (alfa + beta)
+    y = np.ones(m)
+    z = 1.0
+    lam = np.ones(m)
+    GG = np.empty((m, n))
+    xsi = np.maximum((1.0 / (x - alfa)), 1)
+    eta = np.maximum((1.0 / (beta - x)), 1)
+    mu = np.maximum(1, 0.5 * c)
+    zet = 1.0
+    s = np.ones(m)
+    bb = np.empty(m+1)
+    AA = np.empty((m+1, m+1))
+
+    P0 = np.ascontiguousarray(P[0, :])
+    Q0 = np.ascontiguousarray(Q[0, :])
+    P1 = np.ascontiguousarray(P[1:, :])
+    Q1 = np.ascontiguousarray(Q[1:, :])
+
+    itera = 0
+    while epsi > epsimin:
+        # main loop + 1
+        itera = itera + 1
+
+        # upcoming lines determine the left hand sides, i.e. the resiudals of all constraints
+        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)
+        residunorm = np.linalg.norm(residu)
+        residumax = np.max(np.abs(residu))
+
+        ittt = 0
+        # the algorithm is terminated when the maximum residual has become smaller than 0.9*epsilon
+        # and epsilon has become sufficiently small (and not too many iterations are used)
+        while residumax > 0.9 * epsi and ittt < maxittt:
+            ittt = ittt + 1
+
+            # Newton's method: first create the variable steps
+
+            # precalculations for PSIjj (or diagx)
+            ux1 = upp - x
+            xl1 = x - low
+            ux2 = ux1 ** 2
+            xl2 = xl1 ** 2
+            ux3 = ux1 * ux2
+            xl3 = xl1 * xl2
+
+            uxinv1 = 1.0 / ux1
+            xlinv1 = 1.0 / xl1
+            uxinv2 = 1.0 / ux2
+            xlinv2 = 1.0 / xl2
+
+            plam = P0 + np.dot(lam, P1)
+            qlam = Q0 + np.dot(lam, Q1)
+            gvec = np.dot(P1, uxinv1) + np.dot(Q1, xlinv1)
+
+            # CG is an m x n matrix with values equal to partial derivative of constraints wrt variables
+            GG[:, :] = P1 * uxinv2 - Q1 * xlinv2
+
+            # derivative of PSI wrt x
+            dpsidx = plam / ux2 - qlam / xl2
+
+            # calculation of right hand sides dx, dy, dz, dlam
+            delx = dpsidx - epsi / (x - alfa) + epsi / (beta - x)
+            dely = c + d * y - lam - epsi / y
+            delz = a0 - np.dot(a, lam) - epsi / z
+            dellam = gvec - a * z - y - b + epsi / lam
+
+            # calculation of diagonal matrices Dx Dy Dlam
+            diagx = 2 * (plam / ux3 + qlam / xl3) + xsi / (x - alfa) + eta / (beta - x)
+            diagy = d + mu / y
+
+            diaglam = s / lam
+            diaglamyi = diaglam + 1.0 / diagy
+
+            # different options depending on the number of constraints
+            # considering the fact I will probably not use local constraints I removed the option
+
+            # normally here is a statement if m < n
+            bb[:-1] = dellam + dely / diagy - np.dot(GG, (delx / diagx))
+            bb[-1] = delz
+
+            AA[:-1, :-1] = np.diag(diaglamyi) + np.dot((GG / diagx), GG.T)
+            AA[-1, :-1] = a
+            AA[:-1, -1] = a
+            AA[-1, -1] = -zet/z
+            # solve system for delta lambda and delta z
+            solut = np.linalg.solve(AA, bb)
+
+            # solution of delta vars
+            dlam = solut[0:m]
+            dz = solut[m]
+            dx = -delx / diagx - np.dot(dlam, GG) / diagx
+            dy = -dely / diagy + dlam / diagy
+            dxsi = -xsi + epsi / (x - alfa) - (xsi * dx) / (x - alfa)
+            deta = -eta + epsi / (beta - x) + (eta * dx) / (beta - x)
+            dmu = -mu + epsi / y - (mu * dy) / y
+            dzet = -zet + epsi / z - zet * dz / z
+            ds = -s + epsi / lam - (s * dlam) / lam
+
+            # calculate the step size
+            stmy = -1.01*np.min(dy/y)
+            stmz = -1.01 * dz / z
+            stmlam = -1.01*np.min(dlam / lam)
+            stmxsi = -1.01*np.min(dxsi / xsi)
+            stmeta = -1.01 * np.min(deta / eta)
+            stmmu = -1.01 * np.min(dmu / mu)
+            stmzet = -1.01 * dzet / zet
+            stms = -1.01 * np.min(ds / s)
+            stmxx = max(stmy, stmz, stmlam, stmxsi, stmeta, stmmu, stmzet, stms)
+
+            # put variables and accompanying changes in alist
+            stmalfa = -1.01 * np.min(dx / (x - alfa))
+            stmbeta = 1.01 * np.max(dx / (beta - x))
+
+            # Initial step size
+            steg = 1.0 / max(stmalfa, stmbeta, stmxx, 1.0)
+
+            # set old variables
+            xold = x.copy()
+            yold = y.copy()
+            zold = z
+            lamold = lam.copy()
+            xsiold = xsi.copy()
+            etaold = eta.copy()
+            muold = mu.copy()
+            zetold = zet
+            sold = s.copy()
+
+            # Do linesearch
+            itto = 0
+            while itto < maxittt:
+                # Find new set of variables with stepsize
+                x[:] = xold + steg * dx
+                y[:] = yold + steg * dy
+                z = zold + steg * dz
+                lam[:] = lamold + steg * dlam
+                xsi[:] = xsiold + steg * dxsi
+                eta[:] = etaold + steg * deta
+                mu[:] = muold + steg * dmu
+                zet = zetold + steg * dzet
+                s[:] = sold + steg * ds
+
+                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}")
+        # decrease epsilon with factor 10
+        epsi /= 10
+
+    # ## END OF SUBSOLVE
+    return x, y, z, lam, xsi, eta, mu, zet, s
+
+
+class MMA:
+    """
+    Block for the MMA 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.
+
+    Args:
+        function: The Network defining the optimization problem
+        variables: The Signals defining the design variables
+        responses: A list of Signals, where the first is to be minimized and the others are constraints.
+
+    Keyword Args:
+        tolx: Stopping criterium for relative design change
+        tolf: Stopping criterium for relative objective change
+        maxit: Maximum number of iteration
+        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)
+        fn_callback: A function that is called just before calling the response() in each iteration
+        verbosity: 0 - No prints, 1 - Only convergence message, 2 - Convergence and iteration info, 3 - Extended info
+
+    """
+
+    def __init__(self, function, variables, responses, tolx=1e-4, tolf=0.0, move=0.1, maxit=100, xmin=0.0, xmax=1.0, fn_callback=None, verbosity=0, **kwargs):
+        self.funbl = function
+        self.verbosity = verbosity
+
+        self.variables = _parse_to_list(variables)
+        self.responses = _parse_to_list(responses)
+
+        self.iter = 0
+
+        # Convergence options
+        self.tolX = tolx
+        self.tolf = tolf
+        self.maxIt = maxit
+
+        # Operational options
+        self.xmax = xmax
+        self.xmin = xmin
+        self.move = move
+
+        self.pijconst = kwargs.get("pijconst", 1e-3)
+
+        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.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.ittomax = kwargs.get("ittomax", 400)
+
+        self.iterinitial = kwargs.get("iterinitial", 2.5)
+
+        self.fn_callback = fn_callback
+
+        # Numbers
+        self.n = None  # len(x0)
+        self.dx = None
+        self.xold1 = None
+        self.xold2 = None
+        self.low = None
+        self.upp = None
+        self.offset = None
+
+        # Setting up for constriants
+        self.m = len(self.responses) - 1
+        self.a = np.zeros(self.m)
+        self.c = self.cCoef * np.ones(self.m)
+        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
+
+        # Save initial state
+        xval, self.cumlens = _concatenate_to_array([s.state for s in self.variables])
+        self.n = len(xval)
+
+        # Set outer bounds
+        if not hasattr(self.xmin, '__len__'):
+            self.xmin = self.xmin * np.ones_like(xval)
+        elif len(self.xmin) == len(self.variables):
+            xminvals = self.xmin
+            self.xmin = np.zeros_like(xval)
+            for i in range(len(xminvals)):
+                self.xmin[self.cumlens[i]:self.cumlens[i+1]] = xminvals[i]
+
+        if len(self.xmin) != self.n:
+            raise RuntimeError(
+                "Length of the xmin vector not correct ({} != {})".format(len(self.xmin), self.n))
+
+        if not hasattr(self.xmax, '__len__'):
+            self.xmax = self.xmax * np.ones_like(xval)
+        elif len(self.xmax) == len(self.variables):
+            xmaxvals = self.xmax
+            self.xmax = np.zeros_like(xval)
+            for i in range(len(xmaxvals)):
+                self.xmax[self.cumlens[i]:self.cumlens[i + 1]] = xmaxvals[i]
+
+        if len(self.xmax) != self.n:
+            raise RuntimeError("Length of the xmax vector not correct ({} != {})".format(len(self.xmax), self.n))
+
+        # Set movelimit in case of multiple
+        if hasattr(self.move, '__len__'):
+            if len(self.move) == len(self.variables):
+                movevals = self.move
+                self.move = np.zeros_like(xval)
+                for i in range(len(movevals)):
+                    self.move[self.cumlens[i]:self.cumlens[i + 1]] = movevals[i]
+            elif len(self.move) != self.n:
+                raise RuntimeError("Length of the move vector not correct ({} != {})".format(len(self.move), self.n))
+
+        fcur = 0.0
+        while self.iter < self.maxIt:
+            # Reset all signals in function block
+            self.funbl.reset()
+
+            # Set the new states
+            for i, s in enumerate(self.variables):
+                if self.cumlens[i+1]-self.cumlens[i] == 1:
+                    try:
+                        s.state[:] = xval[self.cumlens[i]]
+                    except TypeError:
+                        s.state = xval[self.cumlens[i]]
+                else:
+                    s.state[:] = xval[self.cumlens[i]:self.cumlens[i+1]]
+
+            if self.fn_callback is not None:
+                self.fn_callback()
+
+            # Calculate response
+            self.funbl.response()
+
+            # Update the states
+            for i, s in enumerate(self.variables):
+                if self.cumlens[i+1]-self.cumlens[i] == 1:
+                    try:
+                        xval[self.cumlens[i]] = s.state[:]
+                    except TypeError:
+                        xval[self.cumlens[i]] = s.state
+                else:
+                    xval[self.cumlens[i]:self.cumlens[i+1]] = s.state[:]
+
+            # Save response
+            f = ()
+            for s in self.responses:
+                f += (s.state, )
+
+            # Check function change convergence criterion
+            fprev, fcur = fcur, self.responses[0].state
+            rel_fchange = abs(fcur-fprev)/abs(fcur)
+            if rel_fchange < self.tolf:
+                if self.verbosity >= 1:
+                    print(f"MMA converged: Relative function change |Δf|/|f| ({rel_fchange}) below tolerance ({self.tolf})")
+                break
+
+            # Calculate and save sensitivities
+            df = ()
+            for i, s_out in enumerate(self.responses):
+                for s in self.responses:
+                    s.reset()
+
+                s_out.sensitivity = s_out.state*0 + 1.0
+
+                self.funbl.sensitivity()
+
+                sens_list = []
+                for v in self.variables:
+                    sens_list.append(v.sensitivity if v.sensitivity is not None else 0*v.state)
+                dff, _ = _concatenate_to_array(sens_list)
+                df += (dff, )
+
+                # Reset sensitivities for the next response
+                self.funbl.reset()
+
+            # Display info on variables
+            if self.verbosity >= 3:
+                for i, s in enumerate(self.variables):
+                    isscal = self.cumlens[i + 1] - self.cumlens[i] == 1
+                    msg = "{0:>10s} = ".format(s.tag)
+                    if isscal:
+                        try:
+                            msg += "         {0: .3e}         ".format(s.state)
+                        except TypeError:
+                            msg += "         {0: .3e}         ".format(s.state[0])
+                    else:
+                        msg += "[{0: .3e} ... {1: .3e}] ".format(min(s.state), max(s.state))
+                    for j, s_out in enumerate(self.responses):
+                        msg += "| {0:>10s}/{1:10s} = ".format("d"+s_out.tag, "d"+s.tag)
+                        if isscal:
+                            msg += "         {0: .3e}         ".format(df[j][self.cumlens[i]])
+                        else:
+                            msg += "[{0: .3e} ... {1: .3e}] ".format(min(df[j][self.cumlens[i]:self.cumlens[i+1]]), max(df[j][self.cumlens[i]:self.cumlens[i+1]]))
+                    print(msg)
+
+            self.iter += 1
+            xnew, change = self.mmasub(xval.copy(), np.hstack(f), np.vstack(df))
+
+            # Stopping criteria on step size
+            rel_stepsize = np.linalg.norm((xval - xnew)/self.dx) / np.linalg.norm(xval/self.dx)
+            if rel_stepsize < self.tolX:
+                if self.verbosity >= 1:
+                    print(f"MMA converged: Relative stepsize |Δx|/|x| ({rel_stepsize}) below tolerance ({self.tolX})")
+                break
+
+            xval = xnew
+
+    def mmasub(self, xval, g, dg):
+        if self.dx is None:
+            self.dx = self.xmax - self.xmin
+        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
+        if self.xold1 is not None and self.xold2 is not None:
+            # depending on if the signs of xval - xold and xold - xold2 are opposite, indicating an oscillation
+            # in the variable xi
+            # if the signs are equal the asymptotes are slowing down the convergence and should be relaxed
+
+            # check for oscillations in variables
+            # if zzz positive no oscillations, if negative --> oscillations
+            zzz = (xval - self.xold1) * (self.xold1 - self.xold2)
+            # decrease those variables that are oscillating equal to asydecr
+            self.offset[zzz > 0] *= self.asyincr
+            self.offset[zzz < 0] *= self.asydecr
+
+            # check with minimum and maximum bounds of asymptotes, as they cannot be to close or far from the variable
+            # give boundaries for upper and lower asymptotes
+            self.offset = np.clip(self.offset, 1/(self.asybound**2), self.asybound)
+
+        # Update asymptotes
+        shift = self.offset * self.dx
+        self.low = xval - shift
+        self.upp = xval + shift
+
+        # # VARIABLE BOUNDS
+        # Calculation of the bounds alfa and beta :
+        # use albefa to limit the maximum change of variables wrt the lower and upper asymptotes
+        # as it should remain within both asymptotes
+        zzl1 = self.low + self.albefa * shift
+        # use movelimit to limit the maximum change of variables
+        zzl2 = xval - self.move * self.dx
+        # minimum variable bounds
+        alfa = np.maximum.reduce([zzl1, zzl2, self.xmin])
+
+        zzu1 = self.upp - self.albefa * shift
+        zzu2 = xval + self.move * self.dx
+        # maximum variable bounds
+        beta = np.minimum.reduce([zzu1, zzu2, self.xmax])
+
+        # # APPROXIMATE CONVEX SEPARABLE FUNCTIONS
+        # Calculations of p0, q0, P, Q and b.
+        # calculate the constant factor in calculations of pij and qij
+        dx2 = shift**2
+        P = dx2 * np.maximum(+dg, 0)
+        Q = dx2 * np.maximum(-dg, 0)
+
+        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)
+
+        self.gold2, self.gold1 = self.gold1, g.copy()
+        self.xold2, self.xold1 = self.xold1, xval.copy()
+        change = np.average(abs(xval - xmma))
+
+        if self.verbosity >= 2:
+            msgs = ["g{0:d}({1:s}): {2:+.4e}".format(i, s.tag, g[i]) for i, s in enumerate(self.responses)]
+            print("It. {0: 4d}, {1}".format(self.iter, ", ".join(msgs)))
+
+        if self.verbosity >=3:
+            # Print changes
+            printstr = "Changes: "
+            for i, s in enumerate(self.variables):
+                isscal = self.cumlens[i + 1] - self.cumlens[i] == 1
+                if isscal:
+                    chg = abs(xval[self.cumlens[i]] - xmma[self.cumlens[i]])
+                else:
+                    chg = np.average(abs(xval[self.cumlens[i]:self.cumlens[i + 1]] - xmma[self.cumlens[i]:self.cumlens[i + 1]]))
+
+                printstr += "{0:s} = {1:.3e}   ".format("Δ_"+s.tag, chg)
+            print(printstr)
+
+        return xmma, change

pymoto/core_objects.py

@@ -2,7 +2,7 @@ from typing import Union, List, Any
 import warnings
 import inspect
 import time
-from .utils import _parse_to_list
+from .utils import _parse_to_list, _concatenate_to_array, _split_from_array
 from abc import ABC, abstractmethod
 
 
@@ -35,7 +35,7 @@ def get_init_loc():
             frame = fr
             break
     if frame is None:
-        return ""
+        return "N/A", "N/A", "N/A"
     _, filename, line, func, _, _ = frame
     return filename, line, func
 
@@ -145,6 +145,10 @@ class Signal:
 
 
 class SignalSlice(Signal):
+    """ Slice operator for a Signal
+    The sliced values are referenced to their original source Signal, such that they can be used and updated in modules.
+    This means that updating the values in this SignalSlice changes the data in its source Signal.
+    """
     def __init__(self, orig_signal, sl, tag=None):
         self.orig_signal = orig_signal
         self.slice = sl
@@ -165,7 +169,7 @@ class SignalSlice(Signal):
             return None if self.orig_signal.state is None else self.orig_signal.state[self.slice]
         except Exception as e:
             # Possibilities: Unslicable object (TypeError) or Wrong dimensions or out of range (IndexError)
-            raise type(e)("Get state - " + e.args[0] + self._err_str(), *e.args[1:]) from None
+            raise type(e)("SignalSlice.state (getter)" + self._err_str()) from e
 
     @state.setter
     def state(self, new_state):
@@ -173,7 +177,7 @@ class SignalSlice(Signal):
             self.orig_signal.state[self.slice] = new_state
         except Exception as e:
             # Possibilities: Unslicable object (TypeError) or Wrong dimensions or out of range (IndexError)
-            raise type(e)("Set state - " + e.args[0] + self._err_str(), *e.args[1:]) from None
+            raise type(e)("SignalSlice.state (setter)" + self._err_str()) from e
 
     @property
     def sensitivity(self):
@@ -181,29 +185,29 @@ class SignalSlice(Signal):
             return None if self.orig_signal.sensitivity is None else self.orig_signal.sensitivity[self.slice]
         except Exception as e:
             # Possibilities: Unslicable object (TypeError) or Wrong dimensions or out of range (IndexError)
-            raise type(e)("Get sensitivity - " + e.args[0] + self._err_str(), *e.args[1:]) from None
+            raise type(e)("SignalSlice.sensitivity (getter)" + self._err_str()) from e
 
     @sensitivity.setter
     def sensitivity(self, new_sens):
-        if self.orig_signal.sensitivity is None:
-            if new_sens is None:
-                return  # Sensitivity doesn't need to be initialized when it is set to None
-            try:
-                self.orig_signal.sensitivity = self.orig_signal.state*0  # Make a new copy with 0 values
-            except TypeError:
-                if self.orig_signal.state is None:
-                    raise TypeError("Could not initialize sensitivity because state is not set" + self._err_str()) from None
-                else:
-                    raise TypeError(f"Could not initialize sensitivity for type \'{type(self.orig_signal.state).__name__}\'" + self._err_str()) from None
+        try:
+            if self.orig_signal.sensitivity is None:
+                if new_sens is None:
+                    return  # Sensitivity doesn't need to be initialized when it is set to None
+                try:
+                    self.orig_signal.sensitivity = self.orig_signal.state * 0  # Make a new copy with 0 values
+                except TypeError:
+                    if self.orig_signal.state is None:
+                        raise TypeError("Could not initialize sensitivity because state is not set" + self._err_str())
+                    else:
+                        raise TypeError(f"Could not initialize sensitivity for type \'{type(self.orig_signal.state).__name__}\'")
 
-        if new_sens is None:
-            new_sens = 0  # reset() uses this
+            if new_sens is None:
+                new_sens = 0  # reset() uses this
 
-        try:
             self.orig_signal.sensitivity[self.slice] = new_sens
         except Exception as e:
             # Possibilities: Unslicable object (TypeError) or Wrong dimensions or out of range (IndexError)
-            raise type(e)("Set sensitivity - " + e.args[0] + self._err_str(), *e.args[1:]) from None
+            raise type(e)("SignalSlice.sensitivity (setter)" + self._err_str()) from e
 
 
 def make_signals(*args):

pymoto/modules/assembly.py

@@ -237,14 +237,26 @@ class AssembleMass(AssembleGeneral):
         # 1/36 Mass of one element
         mel = rho * np.prod(domain.element_size)
 
-        # Consistent mass matrix
-        ME = mel / 36 * np.array([[4.0, 0.0, 2.0, 0.0, 2.0, 0.0, 1.0, 0.0],
-                                  [0.0, 4.0, 0.0, 2.0, 0.0, 2.0, 0.0, 1.0],
-                                  [2.0, 0.0, 4.0, 0.0, 1.0, 0.0, 2.0, 0.0],
-                                  [0.0, 2.0, 0.0, 4.0, 0.0, 1.0, 0.0, 2.0],
-                                  [2.0, 0.0, 1.0, 0.0, 4.0, 0.0, 2.0, 0.0],
-                                  [0.0, 2.0, 0.0, 1.0, 0.0, 4.0, 0.0, 2.0],
-                                  [1.0, 0.0, 2.0, 0.0, 2.0, 0.0, 4.0, 0.0],
-                                  [0.0, 1.0, 0.0, 2.0, 0.0, 2.0, 0.0, 4.0]])
-
+        if domain.dim == 2:
+            # Consistent mass matrix
+            ME = mel / 36 * np.array([[4.0, 0.0, 2.0, 0.0, 2.0, 0.0, 1.0, 0.0],
+                                      [0.0, 4.0, 0.0, 2.0, 0.0, 2.0, 0.0, 1.0],
+                                      [2.0, 0.0, 4.0, 0.0, 1.0, 0.0, 2.0, 0.0],
+                                      [0.0, 2.0, 0.0, 4.0, 0.0, 1.0, 0.0, 2.0],
+                                      [2.0, 0.0, 1.0, 0.0, 4.0, 0.0, 2.0, 0.0],
+                                      [0.0, 2.0, 0.0, 1.0, 0.0, 4.0, 0.0, 2.0],
+                                      [1.0, 0.0, 2.0, 0.0, 2.0, 0.0, 4.0, 0.0],
+                                      [0.0, 1.0, 0.0, 2.0, 0.0, 2.0, 0.0, 4.0]])
+        elif domain.dim == 3:
+            ME = np.zeros((domain.elemnodes*domain.dim, domain.elemnodes*domain.dim))
+            weights = np.array([8.0, 4.0, 2.0, 1.0])
+            for n1 in range(domain.elemnodes):
+                for n2 in range(domain.elemnodes):
+                    dist = round(np.sum(abs(np.array(domain.node_numbering[n1]) - np.array(domain.node_numbering[n2])))/2)
+                    ME[n1*domain.dim+np.arange(domain.dim), n2*domain.dim+np.arange(domain.dim)] = weights[dist]
+
+            ME *= mel / 216
+        else:
+            raise RuntimeError("Only for 2D and 3D")
         super()._prepare(domain, ME, *args, bcdiagval=bcdiagval, **kwargs)
+

pymoto/modules/generic.py

@@ -1,6 +1,7 @@
 """ Generic modules, valid for general mathematical operations """
 import numpy as np
 from pymoto.core_objects import Module
+from pymoto.utils import _concatenate_to_array, _split_from_array
 try:
     from opt_einsum import contract as einsum  # Faster einsum
 except ModuleNotFoundError:
@@ -200,3 +201,23 @@ class EinSum(Module):
             einsum(op, df_in, *arg_in, out=da_i)
             df_out.append(da_i)
         return df_out
+
+
+class ConcatSignal(Module):
+    """ Concatenates data of multiple signals into one big vector """
+    def _response(self, *args):
+        state, self.cumlens = _concatenate_to_array(list(args))
+        return state
+
+    def _sensitivity(self, dy):
+        dsens = [np.zeros_like(s.state) for s in self.sig_in]
+        dx = _split_from_array(dy, self.cumlens)
+        for i, s in enumerate(self.sig_in):
+            if not isinstance(dsens[i], type(s.state)):
+                dsens[i] = type(s.state)(dx[i])
+                continue
+            try:
+                dsens[i][...] = dx[i]
+            except TypeError:
+                dsens[i] = type(s.state)(dx[i])
+        return dsens

pymoto/modules/linalg.py

@@ -9,6 +9,7 @@ from inspect import currentframe, getframeinfo
 from pymoto import Module, DyadCarrier, LDAWrapper
 import numpy as np
 import scipy.sparse as sps
+import scipy.sparse.linalg as spsla
 import scipy.linalg as spla  # Dense matrix solvers
 
 from pymoto import SolverDenseLU, SolverDenseLDL, SolverDenseCholesky, SolverDiagonal, SolverDenseQR
@@ -242,22 +243,34 @@ class EigenSolve(Module):
         sorting_func: Sorting function to sort the eigenvalues, which must have signature ``func(λ,Q)``
           (default = ``numpy.argsort``)
         hermitian: Flag to omit the automatic detection for Hermitian matrix, saves some work for large matrices
+        nmodes: Number of modes to calculate (only for sparse matrices, default = ``0``)
+        sigma: Shift value for the eigenvalue problem (only for sparse matrices). Eigenvalues around the shift are
+          calculated first (default = ``0.0``)
     """
-    def _prepare(self, sorting_func=lambda W, Q: np.argsort(W), hermitian=None):
+    def _prepare(self, sorting_func=lambda W, Q: np.argsort(W), hermitian=None, nmodes=None, sigma=None):
         self.sorting_fn = sorting_func
         self.is_hermitian = hermitian
+        self.nmodes = nmodes
+        self.sigma = sigma
+        self.Ainv = None
+
 
     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)))
-        W, Q = spla.eigh(A, b=B) if self.is_hermitian else spla.eig(A, b=B)
+        self.is_sparse = sps.issparse(A) and (B is None or sps.issparse(B))
+        if self.is_sparse:
+            W, Q = self._sparse_eigs(A, B=B)
+        else:
+            W, Q = spla.eigh(A, b=B) if self.is_hermitian else spla.eig(A, b=B)
+
         isort = self.sorting_fn(W, Q)
         W = W[isort]
         Q = Q[:, isort]
         for i in range(W.size):
             qi, wi = Q[:, i], W[i]
-            qi *= np.sign(np.real(qi[0]))
+            qi *= np.sign(np.real(qi[np.argmax(abs(qi)>0)]))
             Bqi = qi if B is None else B@qi
             qi /= np.sqrt(qi@Bqi)
             assert (abs(qi@(qi if B is None else B@qi) - 1.0) < 1e-5)
@@ -267,6 +280,49 @@ class EigenSolve(Module):
     def _sensitivity(self, dW, dQ):
         A = self.sig_in[0].state
         B = self.sig_in[1].state if len(self.sig_in) > 1 else np.eye(*A.shape)
+        dA, dB = None, None
+        if not self.is_sparse:
+            dA, dB = self._dense_sens(A, B, dW, dQ)
+        else:
+            if dQ is not None:
+                raise NotImplementedError('Sparse eigenvector sensitivities not implemented')
+            elif dW is not None:
+                dA, dB = self._sparse_eigval_sens(A, B, dW)
+
+        if len(self.sig_in) == 1:
+            return dA
+        elif len(self.sig_in) == 2:
+            return dA, dB
+
+
+    def _sparse_eigs(self, A, B=None):
+        if self.nmodes is None:
+            self.nmodes = 6
+        if self.sigma is None:
+            self.sigma = 0.0
+
+        if self.sigma == 0.0:  # No shift
+            mat_shifted = A
+        else:
+            if B is None:  # If no B is given, use identity to shift
+                B = sps.eye(*A.shape)
+            mat_shifted = A - self.sigma * B
+
+        # 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)
+
+        AinvOp = spsla.LinearOperator(mat_shifted.shape, matvec=self.Ainv.solve, rmatvec=self.Ainv.adjoint)
+
+        if self.is_hermitian:
+            return spsla.eigsh(A, M=B, k=self.nmodes, OPinv=AinvOp, sigma=self.sigma)
+        else:
+            # TODO
+            raise NotImplementedError('Non-Hermitian sparse matrix not supported')
+
+    def _dense_sens(self, A, B, dW, dQ):
+        """ Calculates all (eigenvector and eigenvalue) sensitivities for dense matrix """
         dA = np.zeros_like(A)
         dB = np.zeros_like(B) if len(self.sig_in) > 1 else None
         W, Q = [s.state for s in self.sig_out]
@@ -281,17 +337,39 @@ class EigenSolve(Module):
                 continue
             qi, wi = Q[:, i], W[i]
 
-            P = np.block([[(A - wi*B).T, -((B + B.T)/2)@qi[..., np.newaxis]], [-B@qi.T, 0]])
+            P = np.block([[(A - wi * B).T, -((B + B.T) / 2) @ qi[..., np.newaxis]], [-B @ qi.T, 0]])
             adj = np.linalg.solve(P, np.block([dqi, dwi]))  # Adjoint solve Lee(1999)
             nu = adj[:-1]
             alpha = adj[-1]
             dAi = np.outer(-nu, qi)
             dA += dAi if np.iscomplexobj(A) else np.real(dAi)
             if dB is not None:
-                dBi = np.outer(wi*nu + alpha/2*qi, qi)
+                dBi = np.outer(wi * nu + alpha / 2 * qi, qi)
                 dB += dBi if np.iscomplexobj(B) else np.real(dBi)
+        return dA, dB
+
+    def _sparse_eigval_sens(self, A, B, dW):
+        if dW is None:
+            return None, None
+        W, Q = [s.state for s in self.sig_out]
+        dA, dB = DyadCarrier(), None if B is None else DyadCarrier()
+        for i in range(W.size):
+            wi, dwi = W[i], dW[i]
+            if dwi == 0:
+                continue
+            qi = Q[:, i]
+            qmq = qi@qi if B is None else qi @ (B @ qi)
+            dA_u = (dwi/qmq) * qi
+            if np.isrealobj(A):
+                dA += DyadCarrier([np.real(dA_u), -np.imag(dA_u)], [np.real(qi), np.imag(qi)])
+            else:
+                dA += DyadCarrier(dA_u, qi)
+
+            if dB is not None:
+                dB_u = (wi*dwi/qmq) * qi
+                if np.isrealobj(B):
+                    dB -= DyadCarrier([np.real(dB_u), -np.imag(dB_u)], [np.real(qi), np.imag(qi)])
+                else:
+                    dB -= DyadCarrier(dB_u, qi)
+        return dA, dB
 
-        if len(self.sig_in) == 1:
-            return dA
-        elif len(self.sig_in) == 2:
-            return dA, dB

pymoto/routines.py

@@ -1,6 +1,7 @@
 import numpy as np
 from .utils import _parse_to_list, _concatenate_to_array
 from .core_objects import Signal, Module, Network
+from .common.mma import MMA
 from typing import List, Iterable, Union, Callable
 
 
@@ -271,7 +272,7 @@ def obtain_sensitivities(signals: Iterable[Signal]) -> List:
 
 def minimize_oc(function, variables, objective: Signal,
                 tolx=1e-4, tolf=1e-4, maxit=100, xmin=0.0, xmax=1.0, move=0.2,
-                l1init=0, l2init=100000, l1l2tol=1e-4, maxvol=None):
+                l1init=0, l2init=100000, l1l2tol=1e-4, maxvol=None, verbosity=2):
     """ Execute minimization using the OC-method
 
     Args:
@@ -289,7 +290,10 @@ def minimize_oc(function, variables, objective: Signal,
         l1init: OC internal parameter
         l2init: OC internal parameter
         l1l2tol: OC internal parameter
+        verbosity: 0 - No prints, 1 - Only convergence message, 2 - Convergence and iteration info
+
     """
+    variables = _parse_to_list(variables)
     xval, cumlens = _concatenate_to_array([s.state for s in variables])
 
     if maxvol is None:
@@ -302,16 +306,21 @@ def minimize_oc(function, variables, objective: Signal,
         fprev, f = f, objective.state
         rel_fchange = abs(f-fprev)/abs(f)
         if rel_fchange < tolf:
-            print(f"OC converged: Relative function change |Δf|/|f| ({rel_fchange}) below tolerance ({tolf})")
+            if verbosity >= 1:
+                print(f"OC converged: Relative function change |Δf|/|f| ({rel_fchange}) below tolerance ({tolf})")
             break
 
-        print("It. {0: 4d}, f0 = {1: .2e}, Δf = {2: .2e}".format(it, f, f-fprev))
+        if verbosity >= 2:
+            print("It. {0: 4d}, f0 = {1: .2e}, Δf = {2: .2e}".format(it, f, f-fprev))
 
         # Calculate sensitivity of the objective
         function.reset()
         objective.sensitivity = 1.0
         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}")
 
         # Do OC update
         l1, l2 = l1init, l2init
@@ -323,7 +332,8 @@ def minimize_oc(function, variables, objective: Signal,
         # Stopping criteria on step size
         rel_stepsize = np.linalg.norm(xval - xnew)/np.linalg.norm(xval)
         if rel_stepsize < tolx:
-            print(f"OC converged: Relative stepsize |Δx|/|x| ({rel_stepsize}) below tolerance ({tolx})")
+            if verbosity >= 1:
+                print(f"OC converged: Relative stepsize |Δx|/|x| ({rel_stepsize}) below tolerance ({tolx})")
             break
 
         xval = xnew
@@ -332,13 +342,9 @@ def minimize_oc(function, variables, objective: Signal,
             s.state = xnew[cumlens[i]:cumlens[i + 1]]
 
 
-def minimize_mma(function, variables, responses, tolx=1e-4, tolf=1e-4, maxit=1000, xmin=0.0, xmax=1.0):
+def minimize_mma(function, variables, responses, tolx=1e-4, tolf=1e-4, maxit=1000, move=0.1, xmin=0.0, xmax=1.0, verbosity=2):
     """ Execute minimization using the MMA-method
-
-    Uses the ``nlopt`` version of MMA.
-
-    Todo:
-        Improve the MMA implementation as the ``nlopt`` version is not very good
+    Svanberg (1987), The method of moving asymptotes - a new method for structural optimization
 
     Args:
         function: The Network defining the optimization problem
@@ -349,59 +355,12 @@ def minimize_mma(function, variables, responses, tolx=1e-4, tolf=1e-4, maxit=100
         tolx: Stopping criterium for relative design change
         tolf: Stopping criterium for relative objective change
         maxit: Maximum number of iteration
+        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
+
     """
     # Save initial state
-    xval, cumlens = _concatenate_to_array([s.state for s in variables])
-    n = len(xval)
-
-    def fi(_, grad, i):
-
-        if grad.size > 0:
-            # Calculate sensitivities
-            function.reset()
-
-            responses[i].sensitivity = 1.0
-
-            function.sensitivity()
-
-            grad[:], _ = _concatenate_to_array(obtain_sensitivities(variables))
-
-        return responses[i].state
-
-    global it
-    it = 0
-
-    # Objective function
-    def f0(x, grad):
-        global it
-        # Set the new states
-        for i, s in enumerate(variables):
-            s.state = x[cumlens[i]:cumlens[i + 1]]
-
-        # Calculate response
-        function.response()
-
-        print("It. {0: 4d}, f0 = {1: .2e}, f1 = {2: .2e}".format(it, responses[0].state, responses[1].state))
-        it += 1
-
-        return fi(x, grad, 0)
-
-    # Create optimization
-    import nlopt
-
-    opt = nlopt.opt(nlopt.LD_MMA, n)
-
-    opt.set_min_objective(f0)
-    for ri in range(1, len(responses)):
-        opt.add_inequality_constraint(lambda x, grad: fi(x, grad, ri))
-
-    opt.set_lower_bounds(np.ones_like(xval) * xmin)
-    opt.set_upper_bounds(np.ones_like(xval) * xmax)
-
-    opt.set_maxeval(maxit)
-    opt.set_xtol_rel(tolx)
-    opt.set_ftol_rel(tolf)
-
-    opt.optimize(xval)
+    mma = MMA(function, variables, responses, tolx=tolx, move=move, maxit=maxit, xmin=xmin, xmax=xmax, verbosity=verbosity)
+    mma.response()

pymoto/utils.py

@@ -32,3 +32,11 @@ def _concatenate_to_array(var_list: list):
         cumulative_inds[i+1] = len(values)
 
     return values, cumulative_inds
+
+
+def _split_from_array(values: np.ndarray, cumulative_inds: np.ndarray):
+    assert cumulative_inds[-1] == values.size, "Size of the array does not match the indices"
+    var_list = list()
+    for i in range(cumulative_inds.size-1):
+        var_list.append(values[cumulative_inds[i]:cumulative_inds[i+1]])
+    return var_list

pyMOTO-1.0.1.dist-info/RECORD

@@ -1,22 +0,0 @@
-pymoto/__init__.py,sha256=djteoo_1T-w76W-FH4xo_-t1qbfkNTA6AixYkZVOfws,1958
-pymoto/core_objects.py,sha256=iOgJSjJYAiY2vOJzQPSIgtgZv5XtSUOV90l0KoXnzmo,23212
-pymoto/routines.py,sha256=NJur-TG4hHuY7Vm8X7BqQ9t8PIwmZaYvv_awRDNs7zo,14490
-pymoto/utils.py,sha256=wsqK7CQhqVBzyYRKDa-yIFTN_2ldeHSvy8TzaLMomjo,795
-pymoto/common/domain.py,sha256=Bo5Qqnben3Ih0IuprnoO2CmG09shEVUWt1hyiVFnB9U,15136
-pymoto/common/dyadcarrier.py,sha256=iszzJMLiHbnLn4_UoCa8PkhdEQPKytLlDxXWsGCmze8,17206
-pymoto/common/solvers.py,sha256=92brZkAXc-8jNM3YfL24CCV99uuz0u4weIgyrn8__aw,8143
-pymoto/common/solvers_dense.py,sha256=vuBUp3y4qJLwmsXbFQ_tEb-7LqqCEemFunTn1z_Qu0U,9901
-pymoto/common/solvers_sparse.py,sha256=QVbGTwGtbhOqRUyg2gHmY-K5haiPbskGA6uj_g-dKz8,15776
-pymoto/modules/assembly.py,sha256=0jjzrIhMpvrIll2Fy0QLTBNVxYX2fr2FdqqHtib3D8A,10650
-pymoto/modules/autodiff.py,sha256=WAfoAOHBSozf7jbr9gQz9Vw4a_2G9wGJxLMMqUQP0Co,1684
-pymoto/modules/complex.py,sha256=vwzqRo5W319mVf_RqbB7LpYe7jXruVxa3ZV560Iq39k,4421
-pymoto/modules/filter.py,sha256=8A-dmWSFEqFyQcutjFv__pfgAwszCVZeZgLxuG9hi0g,18840
-pymoto/modules/generic.py,sha256=mqSHf0CMc0UwitzRgcDtybnk4tuR0obeiO6QB7iEv-o,8632
-pymoto/modules/io.py,sha256=4k5S-YQHKhw_HwmqOoYQWFEzdcL5nMJ5fVD2FJFqpFg,10532
-pymoto/modules/linalg.py,sha256=D_gwWPl3nrR3zFW1i9d4WobQ9YoUkkPEM_05kiixuEs,13201
-pyMOTO-1.0.1.dist-info/LICENSE,sha256=ZXMC2Txpzs-dBwz9Me4_1rQCSVl4P1B27MomNi43F30,1072
-pyMOTO-1.0.1.dist-info/METADATA,sha256=k1ImayKsQwlx4ZDnERCrZZJUUCkZLfNTgKWZyJ638VM,5201
-pyMOTO-1.0.1.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pyMOTO-1.0.1.dist-info/top_level.txt,sha256=EdvAUSmFMaiqhuEZW8jxANMiK-LdPtlmDWL6SfmCdUU,7
-pyMOTO-1.0.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-pyMOTO-1.0.1.dist-info/RECORD,,