pyMOTO 1.1.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

{pyMOTO-1.1.0.dist-info → pyMOTO-1.2.1.dist-info}/METADATA

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

{pyMOTO-1.1.0.dist-info → pyMOTO-1.2.1.dist-info}/RECORD

@@ -1,24 +1,24 @@
-pymoto/__init__.py,sha256=ax6tQsXkt19zyUhq3aSsHltR1_Yqg0r1pFWhENsRhw4,2119
+pymoto/__init__.py,sha256=V3OzqL_4NDy7lzIv_8tvu6s-8qS4bUwczd6XoH75M3s,2196
 pymoto/core_objects.py,sha256=9TjGunvGVwa-LqM2tmE1XlWnqHDscZLeqbKFBZ7ZroU,25111
 pymoto/routines.py,sha256=pMJlEFXa413XbqvbJuw3bZTNGQJ4Al-BRdAy_Es_M2g,14360
 pymoto/utils.py,sha256=YJ-PNLJLc12Yx6TYCrEechS2aaBRx0o4mTM1soeeyz0,1122
-pymoto/common/domain.py,sha256=Bo5Qqnben3Ih0IuprnoO2CmG09shEVUWt1hyiVFnB9U,15136
+pymoto/common/domain.py,sha256=_VWgm0sjMDsan_GiKnwmpJqZcuksgDU6UTdZYMTSi98,15153
 pymoto/common/dyadcarrier.py,sha256=VwLJnOq1omfMX2udG6DMHOkD3AsIB05LTpDY7veYXcc,17136
 pymoto/common/mma.py,sha256=W1Z0h5f3a9BP8nFIlCdahDCIHT4XrcDcDyE6Y1Brq3k,23318
 pymoto/common/solvers.py,sha256=U7XNMSyHhp0fiZ8ASo1guUb-CHGygik7A4lfLOnh07c,8316
 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/assembly.py,sha256=i0zwigijmsJRR3aHZXSIzlDcYMbCWxKW4fe3NqjW8ew,11540
 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=27EuDMfUtWkkwEqkfbHMCRlHkt6wcV40aUQKfhL2xKI,9783
 pymoto/modules/io.py,sha256=4k5S-YQHKhw_HwmqOoYQWFEzdcL5nMJ5fVD2FJFqpFg,10532
-pymoto/modules/linalg.py,sha256=99GvUfPAScQxfvcuajWyqWUcOZTtFRNQG8xMxALxPiE,21050
+pymoto/modules/linalg.py,sha256=j8bZfjo5Il_vbdEHr2BhWB3e7OssYVovieoN54zygx8,24266
 pymoto/modules/scaling.py,sha256=hK3sfCoAoseabjqdn5VXe6aGA_fV-MRmMtiv4uIg_I4,2252
-pyMOTO-1.1.0.dist-info/LICENSE,sha256=ZXMC2Txpzs-dBwz9Me4_1rQCSVl4P1B27MomNi43F30,1072
-pyMOTO-1.1.0.dist-info/METADATA,sha256=am9fTat6g_-KNqBIQppkJmZgLKQ1MLXfX7MJW2SrNF8,4907
-pyMOTO-1.1.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-pyMOTO-1.1.0.dist-info/top_level.txt,sha256=EdvAUSmFMaiqhuEZW8jxANMiK-LdPtlmDWL6SfmCdUU,7
-pyMOTO-1.1.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-pyMOTO-1.1.0.dist-info/RECORD,,
+pyMOTO-1.2.1.dist-info/LICENSE,sha256=ZXMC2Txpzs-dBwz9Me4_1rQCSVl4P1B27MomNi43F30,1072
+pyMOTO-1.2.1.dist-info/METADATA,sha256=YKmcOzqRFlAObECUODa5oZgcIG9r7GRhjn86x12_8fk,4907
+pyMOTO-1.2.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+pyMOTO-1.2.1.dist-info/top_level.txt,sha256=EdvAUSmFMaiqhuEZW8jxANMiK-LdPtlmDWL6SfmCdUU,7
+pyMOTO-1.2.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pyMOTO-1.2.1.dist-info/RECORD,,

{pyMOTO-1.1.0.dist-info → pyMOTO-1.2.1.dist-info}/WHEEL

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

pymoto/__init__.py

@@ -1,27 +1,30 @@
-__version__ = '1.1.0'
+__version__ = '1.2.1'
 
-from .core_objects import Signal, Module, Network, make_signals
-from .routines import finite_difference, minimize_oc, minimize_mma
+from .common.domain import DomainDefinition
 
 # 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 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, ConcatSignal
-from .modules.linalg import Inverse, LinSolve, EigenSolve, SystemOfEquations
+# Modular inports
+from .core_objects import Signal, Module, Network, make_signals
+
+# Import modules
 from .modules.assembly import AssembleGeneral, AssembleStiffness, AssembleMass
+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 PlotDomain, PlotGraph, PlotIter, WriteToVTI
-from .modules.complex import MakeComplex, RealPart, ImagPart, ComplexNorm
-from .modules.autodiff import AutoMod
+from .modules.linalg import Inverse, LinSolve, EigenSolve, SystemOfEquations, StaticCondensation
 from .modules.scaling import Scaling
 
+# Further helper routines
+from .routines import finite_difference, minimize_oc, minimize_mma
+
 __all__ = [
     'Signal', 'Module', 'Network', 'make_signals',
     'finite_difference', 'minimize_oc', 'minimize_mma',
@@ -35,7 +38,7 @@ __all__ = [
     'SolverSparsePardiso', 'SolverSparseLU', 'SolverSparseCholeskyScikit', 'SolverSparseCholeskyCVXOPT',
     # Modules
     "MathGeneral", "EinSum", "ConcatSignal",
-    "Inverse", "LinSolve", "EigenSolve", "SystemOfEquations",
+    "Inverse", "LinSolve", "EigenSolve", "SystemOfEquations", "StaticCondensation",
     "AssembleGeneral", "AssembleStiffness", "AssembleMass",
     "FilterConv", "Filter", "DensityFilter", "OverhangFilter",
     "PlotDomain", "PlotGraph", "PlotIter", "WriteToVTI",

pymoto/common/domain.py

@@ -184,10 +184,10 @@ class DomainDefinition:
         """
         v = np.prod(self.element_size[:self.dim])
         assert v > 0.0, 'Element volume needs to be positive'
-        ret = np.ones(self.nnodes)/v
+        shapefn = np.ones(self.elemnodes)/v
         for i in range(self.dim):
-            ret *= np.array([self.element_size[i] + n[i]*pos[i] for n in self.node_numbering])
-        return ret
+            shapefn *= np.array([self.element_size[i]/2 + n[i]*pos[i] for n in self.node_numbering])
+        return shapefn
 
     def eval_shape_fun_der(self, pos: np.ndarray):
         """ Evaluates the shape function derivatives in x, y, and optionally z-direction.

pymoto/modules/assembly.py

@@ -1,9 +1,12 @@
 """ Assembly modules for finite element analysis """
 import sys
-from pymoto import Module, DyadCarrier, DomainDefinition
+from typing import Union
+
 import numpy as np
 from scipy.sparse import csc_matrix
-from typing import Union
+
+from pymoto import Module, DyadCarrier, DomainDefinition
+
 try:
     from opt_einsum import contract as einsum
 except ModuleNotFoundError:
@@ -33,8 +36,11 @@ class AssembleGeneral(Module):
         bcdiagval (optional): Value to put on the diagonal of the matrix at dofs where boundary conditions are active.
         matrix_type (optional): The matrix type to construct. This is a constructor which must accept the arguments
           ``matrix_type((vals, (row_idx, col_idx)), shape=(n, n))``
+        add_constant (optional): A constant (e.g. matrix) to add.
     """
-    def _prepare(self, domain: DomainDefinition, element_matrix: np.ndarray, bc=None, bcdiagval=None, matrix_type=csc_matrix):
+
+    def _prepare(self, domain: DomainDefinition, element_matrix: np.ndarray, bc=None, bcdiagval=None,
+                 matrix_type=csc_matrix, add_constant=None):
         self.elmat = element_matrix
         self.ndof = self.elmat.shape[-1] // domain.elemnodes  # Number of dofs per node
         self.n = self.ndof * domain.nnodes  # Matrix size
@@ -59,6 +65,8 @@ class AssembleGeneral(Module):
         else:
             self.bcselect = None
 
+        self.add_constant = add_constant
+
     def _response(self, xscale: np.ndarray):
         scaled_el = ((self.elmat.flatten()[np.newaxis]).T * xscale).flatten(order='F')
 
@@ -76,6 +84,8 @@ class AssembleGeneral(Module):
                                    "scipy.sparse.csrmatrix are supported"
                           .format(self.matrix_type)).with_traceback(sys.exc_info()[2]) from None
 
+        if self.add_constant is not None:
+            mat += self.add_constant
         return mat
 
     def _sensitivity(self, dgdmat: Union[DyadCarrier, np.ndarray]):
@@ -232,6 +242,7 @@ class AssembleMass(AssembleGeneral):
         bcdiagval: The value to put on the diagonal in case of boundary conditions (bc)
         **kwargs : Other keyword-arguments are passed to AssembleGeneral
     """
+
     def _prepare(self, domain: DomainDefinition, *args, rho: float = 1.0, bcdiagval=0.0, **kwargs):
         # Element mass matrix
         # 1/36 Mass of one element
@@ -259,4 +270,3 @@ class AssembleMass(AssembleGeneral):
         else:
             raise RuntimeError("Only for 2D and 3D")
         super()._prepare(domain, ME, *args, bcdiagval=bcdiagval, **kwargs)
-

pymoto/modules/linalg.py

@@ -13,6 +13,71 @@ from pymoto import SolverSparseLU, SolverSparseCholeskyCVXOPT, SolverSparsePardi
 from pymoto import matrix_is_symmetric, matrix_is_hermitian, matrix_is_diagonal
 
 
+class StaticCondensation(Module):
+    r"""Static condensation of a linear system of equations
+
+    The partitioned system of equations
+
+    :math:`\begin{bmatrix} \mathbf{A}_\text{mm} & \mathbf{A}_\text{ms} \\ \mathbf{A}_\text{sm} & \mathbf{A}_\text{ss}
+    \end{bmatrix}
+    \begin{bmatrix} \mathbf{x}_\text{m} \\ \mathbf{x}_\text{s} \end{bmatrix} =
+    \begin{bmatrix} \mathbf{b}_\text{m} \\ \mathbf{b}_\text{s} \end{bmatrix}
+    ,`
+    with subscripts ``(m)`` and ``(s)`` referring to the main and secondary dofs, respectively.
+
+    The system is solved in two steps:
+
+    :math:`\begin{aligned}
+    \mathbf{A}_\text{ss} \mathbf{x}_\text{sm} &= \mathbf{A}_\text{sm} \\
+    \tilde{\mathbf{A}} &= \mathbf{A}_\text{mm} - \mathbf{A}_\text{ms} \mathbf{x}_\text{sm}.
+    \end{aligned}`
+
+    Assumptions:
+        (i) It is assumed the prescribed DOFs (all dof - main dof - free dof) are prescribed to zero.
+        (ii) It is assumed the applied load on the free DOFs is zero; there is no reduced load.
+
+    Implemented by @artofscience (s.koppen@tudelft.nl).
+
+    References:
+
+    Koppen, S., Langelaar, M., & van Keulen, F. (2022).
+    Efficient multi-partition topology optimization.
+    Computer Methods in Applied Mechanics and Engineering, 393, 114829.
+    DOI: https://doi.org/10.1016/j.cma.2022.114829
+
+    Input Signals:
+      - ``A`` (`dense or sparse matrix`): The system matrix :math:`\mathbf{A}` of size ``(n, n)``
+
+    Output Signal:
+      - ``Ared`` (`dense or sparse matrix`): The reduced system matrix :math:`\tilde{\mathbf{A}}` of size ``(m, m)``
+
+    Args:
+        free: The indices corresponding to the free degrees of freedom
+        main: The indices corresponding to the main degrees of freedom
+        **kwargs: See `pymoto.LinSolve`, as they are directly passed into the `LinSolve` module
+    """
+
+    def _prepare(self, main, free, **kwargs):
+        self.module_LinSolve = LinSolve([self.sig_in[0], Signal()], **kwargs)
+        self.module_LinSolve.use_lda_solver = False
+        self.m = main
+        self.f = free
+
+    def _response(self, A):
+        self.n = np.shape(A)[0]
+        self.module_LinSolve.sig_in[0].state = A[self.f, ...][..., self.f]
+        self.module_LinSolve.sig_in[1].state = A[self.f, ...][..., self.m].todense()
+        self.module_LinSolve.response()
+        self.X = self.module_LinSolve.sig_out[0].state
+        return A[self.m, ...][..., self.m] - A[self.m, ...][..., self.f] @ self.X
+
+    def _sensitivity(self, dfdB):
+        C = np.zeros((self.n, len(self.m)), dtype=float)
+        C[self.m, ...] = np.eye(len(self.m))
+        C[self.f, ...] = -self.X
+        return C @ dfdB @ C.T if isinstance(dfdB, DyadCarrier) else DyadCarrier(list(C.T), list(np.asarray(dfdB @ C.T)))
+
+
 class SystemOfEquations(Module):
     r""" Solve a partitioned linear system of equations
 
@@ -63,6 +128,7 @@ class SystemOfEquations(Module):
         assert bf.shape[0] + xp.shape[0] == A.shape[0], "Dimensions of applied force and displacement must match matrix"
         assert bf.ndim == xp.ndim, "Number of loadcases for applied force and displacement must match"
         self.n = np.shape(A)[0]
+        self.dim = xp.ndim
 
         if self.f is None:
             all_dofs = np.arange(self.n)
@@ -73,7 +139,8 @@ class SystemOfEquations(Module):
         assert self.f.size + self.p.size == self.n, "Size of free and prescribed indices must match the matrix size"
 
         # create empty output
-        self.x = np.zeros((self.n, *bf.shape[1:]), dtype=float)
+        self.x = np.zeros((self.n, *bf.shape[1:]), dtype=complex) if np.iscomplexobj(A) else np.zeros(
+            (self.n, *bf.shape[1:]), dtype=float)
         self.x[self.p, ...] = xp
 
         b = np.zeros_like(self.x)
@@ -97,13 +164,19 @@ class SystemOfEquations(Module):
         return self.x, b
 
     def _sensitivity(self, dgdx, dgdb):
-        adjoint_load = dgdx[self.f, ...] + self.Afp * dgdb[self.p, ...]
+        adjoint_load = np.zeros_like(self.x[self.f, ...])
+
+        if dgdx is not None:
+            adjoint_load += dgdx[self.f, ...]
+        if dgdb is not None:
+            adjoint_load += self.Afp * dgdb[self.p, ...]
 
-        # adjoint equation
         lam = np.zeros_like(self.x)
         lamf = -1.0 * self.module_LinSolve.solver.adjoint(adjoint_load)
         lam[self.f, ...] = lamf
-        lam[self.p, ...] = dgdb[self.p, ...]
+
+        if dgdb is not None:
+            lam[self.p, ...] = dgdb[self.p, ...]
 
         # sensitivities to system matrix
         if self.x.ndim > 1:
@@ -112,10 +185,19 @@ class SystemOfEquations(Module):
             dgdA = DyadCarrier(lam, self.x)
 
         # sensitivities to applied load and prescribed state
-        dgdff = dgdb[self.f, ...] - lam[self.f, ...]
-        dgdup = dgdx[self.p, ...] + self.App * dgdb[self.p, ...] + self.Afp.T * lam[self.f, ...]
+        dgdbf = np.zeros_like(adjoint_load)
+        dgdup = np.zeros_like(self.x[self.p, ...])
+        dgdbf -= lam[self.f, ...]
+        dgdup += self.Afp.T * lam[self.f, ...]
+
+        if dgdx is not None:
+            dgdup += dgdx[self.p, ...]
 
-        return dgdA, dgdff, dgdup
+        if dgdb is not None:
+            dgdbf += dgdb[self.f, ...]
+            dgdup += self.App * dgdb[self.p, ...]
+
+        return dgdA, dgdbf, dgdup
 
 
 class Inverse(Module):
@@ -257,6 +339,7 @@ class LinSolve(Module):
     Attributes:
         use_lda_solver: Use the linear-dependency-aware solver :class:`LDAWrapper` to prevent redundant computations
     """
+
     use_lda_solver = True
 
     def _prepare(self, dep_tol=1e-5, hermitian=None, symmetric=None, solver=None):