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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyMOTO
-Version: 1.4.0
+Version: 1.5.1
 Summary: A modular approach for topology optimization
 Home-page: https://github.com/aatmdelissen/pyMOTO
 Author: Arnoud Delissen
@@ -51,7 +51,7 @@ automatically calculated.
 
 # Quick start installation
 1. Make sure you have Python running in some kind of virtual environment (e.g. 
-[conda](https://docs.conda.io/projects/conda/en/stable/), [miniconda](https://docs.conda.io/en/latest/miniconda.html),
+[uv](https://docs.astral.sh/uv/guides/install-python/), [conda](https://docs.conda.io/projects/conda/en/stable/), [miniconda](https://docs.conda.io/en/latest/miniconda.html),
 [venv](https://realpython.com/python-virtual-environments-a-primer/))
 2. Install the pymoto Python package (and its dependencies)
    - Option A (conda): If you are working with Conda, install by `conda install -c aatmdelissen pymoto`

pyMOTO-1.5.1.dist-info/RECORD

@@ -0,0 +1,29 @@
+pymoto/__init__.py,sha256=i4B3bc954raAJs0lh0vycgWQ3n6FQCL5oKllmaHtt8M,2058
+pymoto/core_objects.py,sha256=JDY5OBnzSnmXp35-gY_Gqawjh6C2x8dL1cEV8KAW944,27343
+pymoto/routines.py,sha256=inz5GbSnvmbD3WKmaNKATTc_SthKsAMPuRc8Jaub4xs,15568
+pymoto/utils.py,sha256=YJ-PNLJLc12Yx6TYCrEechS2aaBRx0o4mTM1soeeyz0,1122
+pymoto/common/domain.py,sha256=1peaQJuePBZCWjW2oMhRxlhOl1FuhthEE1aWW9dMumk,18168
+pymoto/common/dyadcarrier.py,sha256=Q0MCIP4b-W_RuYxynvY-voCHfeZ4oF12ykAuVUnmLq4,19433
+pymoto/common/mma.py,sha256=SaFdZhpL5uoQRLWxQrElcjRMzGG4CL3BcPc77z3eMVE,24612
+pymoto/modules/aggregation.py,sha256=Oi17hIJ6dic4lOPw16zmjbdC72MjB6XK34H80bnbWAI,7580
+pymoto/modules/assembly.py,sha256=o_HZ4bcyK6cMNWVsrmxvv2z6oDgQcrBmB6dquQCWGC8,23216
+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=BHJgS5IvFTiYYH4cXqRwSid1bfB58HOQs_jhFeLbb3A,13639
+pymoto/modules/linalg.py,sha256=GIMqcIfVsMib5nIwrhx4sPT6-auLiHBJjbKCAdulLLE,22005
+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=hfMRw2LChupr4sQf8qUKG6OHjhpeVAp6C9N7M4-845M,13179
+pymoto/solvers/matrix_checks.py,sha256=bbrfjpTSWWnuQW3xY0_CYE8yrh5gA9K5b1LzHEOFAxI,1663
+pymoto/solvers/solvers.py,sha256=Srn44oRonZIjJq-XVpJY9KoTWV0R7zBWFaSmXKWsUCw,11870
+pymoto/solvers/sparse.py,sha256=BPw-2Q4lgbmtjCl8eLEmDdWhjqD7RSLrVYy_kQN_LdU,17144
+pyMOTO-1.5.1.dist-info/LICENSE,sha256=ZXMC2Txpzs-dBwz9Me4_1rQCSVl4P1B27MomNi43F30,1072
+pyMOTO-1.5.1.dist-info/METADATA,sha256=_ZZ3mHjsLTWtdHuM2k8VcO2t3xF6gt67gFVFHibXMJ8,5062
+pyMOTO-1.5.1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+pyMOTO-1.5.1.dist-info/top_level.txt,sha256=EdvAUSmFMaiqhuEZW8jxANMiK-LdPtlmDWL6SfmCdUU,7
+pyMOTO-1.5.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pyMOTO-1.5.1.dist-info/RECORD,,

{pyMOTO-1.4.0.dist-info → pyMOTO-1.5.1.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.1'
 
 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

@@ -91,6 +91,7 @@ class DomainDefinition:
         if self.nelz is None:
             self.nelz = 0
         self.unitx, self.unity, self.unitz = unitx, unity, unitz
+        self.origin = np.array([0.0, 0.0, 0.0])
 
         self.dim = 1 if (self.nelz == 0 and self.nely == 0) else (2 if self.nelz == 0 else 3)
 
@@ -126,9 +127,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):
@@ -364,7 +393,7 @@ class DyadCarrier(object):
         exprvars = (rowvar, colvar) if mat is None else (rowvar, matvar, colvar)
         expr = ','.join(exprvars) + '->' + batchvar
 
-        val = 0.0 if batchsize is None else np.zeros(batchsize)
+        val = 0.0 if batchsize is None else np.zeros(batchsize, dtype=np.result_type(mat, self.dtype))
         for ui, vi in zip(self.u, self.v):
             uarg = ui if rows is None else ui[rows]
             varg = vi if cols is None else vi[cols]
@@ -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)
 
@@ -282,12 +305,15 @@ class MMA:
 
         # 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.a = kwargs.get("a", np.zeros(self.m))
+        if len(self.a) != self.m:
+            raise RuntimeError(f"Length of the a vector ({len(self.a)}) should be equal to # constraints ({self.m}).")
+        self.c = kwargs.get("c", np.full(self.m, self.cCoef, dtype=float))
+        if len(self.c) != self.m:
+            raise RuntimeError(f"Length of the c vector ({len(self.c)}) should be equal to # constraints ({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
@@ -349,11 +375,15 @@ class MMA:
             # Calculate response
             self.funbl.response()
 
+            xval, _ = _concatenate_to_array([s.state for s in self.variables])
+
             # 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.")
+                if np.iscomplexobj(s.state):
+                    raise TypeError("Responses must be real-valued.")
                 f += (s.state, )
 
             # Check function change convergence criterion
@@ -443,57 +473,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 +515,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 +572,4 @@ class MMA:
             print(f"  | Changes: {', '.join(change_msgs)}")
 
         return xmma, change
+