pyMOTO 1.1.0__tar.gz → 1.2.1__tar.gz

{pyMOTO-1.1.0 → pyMOTO-1.2.1}/PKG-INFO

@@ -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 → pyMOTO-1.2.1}/pyMOTO.egg-info/PKG-INFO

@@ -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 → pyMOTO-1.2.1}/pyMOTO.egg-info/SOURCES.txt

@@ -26,14 +26,17 @@ pymoto/modules/generic.py
 pymoto/modules/io.py
 pymoto/modules/linalg.py
 pymoto/modules/scaling.py
+tests/test_assembly.py
 tests/test_automod.py
 tests/test_complex.py
 tests/test_core.py
 tests/test_dyadcarrier.py
+tests/test_linsolve_sparse.py
 tests/test_module_concatsignal.py
 tests/test_module_eigensolve.py
 tests/test_module_einsum.py
 tests/test_module_mathgeneral.py
 tests/test_scaling.py
 tests/test_solvers_dense.py
-tests/test_solvers_sparse.py
+tests/test_solvers_sparse.py
+tests/test_static_condenstation.py

{pyMOTO-1.1.0 → pyMOTO-1.2.1}/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-1.1.0 → pyMOTO-1.2.1}/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-1.1.0 → pyMOTO-1.2.1}/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-1.1.0 → pyMOTO-1.2.1}/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):

pyMOTO-1.2.1/tests/test_assembly.py

@@ -0,0 +1,91 @@
+import unittest
+import numpy as np
+import pymoto as pym
+import numpy.testing as npt
+
+
+class TestAssembleStiffness(unittest.TestCase):
+    def test_FEA_pure_tensile_2d_one_element(self):
+        Lx, Ly, Lz = 0.1, 0.2, 0.3
+        domain = pym.DomainDefinition(1, 1, unitx=Lx, unity=Ly, unitz=Lz)
+        nodidx_left = domain.get_nodenumber(0, np.arange(domain.nely + 1))
+        # Fixed at bottom, roller at the top in y-direction
+        nodidx_right = domain.get_nodenumber(domain.nelx, np.arange(domain.nely + 1))
+        dofidx_left = np.concatenate([nodidx_left*2, np.array([nodidx_left[0]*2 + 1])])
+
+        E, nu = 210e+9, 0.3
+
+        s_x = pym.Signal('x', state=np.ones(domain.nel))
+
+        # Assemble stiffness matrix
+        m_K = pym.AssembleStiffness(s_x, domain=domain, bc=dofidx_left, e_modulus=E, poisson_ratio=nu, plane='stress')
+        s_K = m_K.sig_out[0]
+
+        m_K.response()
+        F = 1.5
+        f = np.zeros(domain.nnodes*2)
+        f[nodidx_right * 2] = F/nodidx_right.size
+        x = np.linalg.solve(s_K.state.toarray(), f)
+
+        # Bottom y displacement should be zero
+        npt.assert_allclose(x[nodidx_right[0]*2+1], 0, atol=1e-10)
+
+        # Analytical axial displacement using stiffness k = EA/L
+        ux_chk = F * Lx / (E * Ly * Lz)
+        npt.assert_allclose(x[nodidx_right*2], ux_chk, rtol=1e-10)
+
+        # Transverse displacement using Poisson's effect
+        e_xx = ux_chk / Lx  # Strain in x-direction
+        e_yy = - nu * e_xx
+        uy_chk = e_yy * Ly
+        npt.assert_allclose(x[nodidx_right[1]*2+1], uy_chk, rtol=1e-10)
+
+    def test_FEA_pure_tensile_3d_one_element(self):
+        Lx, Ly, Lz = 0.1, 0.2, 0.3
+        domain = pym.DomainDefinition(1, 1, 1, unitx=Lx, unity=Ly, unitz=Lz)
+        nodidx_left = domain.get_nodenumber(*np.meshgrid(0, range(domain.nely + 1), range(domain.nelz + 1))).flatten()
+        # Fixed at (0,0,0), roller in z-direction at (0, 1, 0), roller in y-direction at (0, 0, 1)
+        nod_00 = domain.get_nodenumber(0, 0, 0)
+        nod_10 = domain.get_nodenumber(0, 1, 0)
+        nod_01 = domain.get_nodenumber(0, 0, 1)
+        dofidx_left = np.concatenate([nodidx_left * 3, np.array([nod_00, nod_01]) * 3 + 1, np.array([nod_00, nod_10]) * 3 + 2])
+        nodidx_right = domain.get_nodenumber(*np.meshgrid(1, range(domain.nely + 1), range(domain.nelz + 1))).flatten()
+
+        E, nu = 210e+9, 0.3
+
+        s_x = pym.Signal('x', state=np.ones(domain.nel))
+
+        # Assemble stiffness matrix
+        m_K = pym.AssembleStiffness(s_x, domain=domain, bc=dofidx_left, e_modulus=E, poisson_ratio=nu)
+        s_K = m_K.sig_out[0]
+
+        m_K.response()
+        F = 1.5e+3
+        f = np.zeros(domain.nnodes * 3)
+        f[nodidx_right * 3] = F / nodidx_right.size
+        x = np.linalg.solve(s_K.state.toarray(), f)
+
+        # y and z displacements at (1, 0, 0) should be zero
+        npt.assert_allclose(x[domain.get_nodenumber(1, 0, 0) * 3 + 1], 0, atol=1e-10)
+        npt.assert_allclose(x[domain.get_nodenumber(1, 0, 0) * 3 + 2], 0, atol=1e-10)
+
+        # Z displacement at (1, 1, 0) should be zero
+        npt.assert_allclose(x[domain.get_nodenumber(1, 1, 0) * 3 + 2], 0, atol=1e-10)
+
+        # Y displacement at (1, 0, 1) should be zero
+        npt.assert_allclose(x[domain.get_nodenumber(1, 0, 1) * 3 + 1], 0, atol=1e-10)
+
+        # Analytical axial displacement using stiffness k = EA/L
+        ux_chk = F * Lx / (E * Ly * Lz)
+        npt.assert_allclose(x[nodidx_right * 3], ux_chk, rtol=1e-10)
+
+        # Transverse displacement using Poisson's effect
+        e_xx = ux_chk / Lx  # Strain in x-direction
+        e_trans = - nu * e_xx
+        uy_chk = e_trans * Ly
+        npt.assert_allclose(x[domain.get_nodenumber(1, 1, 0) * 3 + 1], uy_chk, rtol=1e-10)
+        npt.assert_allclose(x[domain.get_nodenumber(1, 1, 1) * 3 + 1], uy_chk, rtol=1e-10)
+
+        uz_chk = e_trans * Lz
+        npt.assert_allclose(x[domain.get_nodenumber(1, 0, 1) * 3 + 2], uz_chk, rtol=1e-10)
+        npt.assert_allclose(x[domain.get_nodenumber(1, 1, 1) * 3 + 2], uz_chk, rtol=1e-10)

{pyMOTO-1.1.0 → pyMOTO-1.2.1}/tests/test_automod.py

@@ -6,10 +6,10 @@ import pymoto as pym
 class TestAutoMod(unittest.TestCase):
     @classmethod
     def setUpClass(cls) -> None:
-        """ Skip test if no function is given """
-        import importlib.util
-        jax_spec = importlib.util.find_spec("jax")
-        if jax_spec is None:
+        """ Skip test if JAX is not installed """
+        try:
+            import jax
+        except ImportError:
             raise unittest.SkipTest(f"Skipping test {cls}")
 
     def test_automod_scalar(self):

pyMOTO-1.2.1/tests/test_linsolve_sparse.py

@@ -0,0 +1,479 @@
+import unittest
+import numpy as np
+import pymoto as pym
+import numpy.testing as npt
+from scipy.sparse import csc_matrix
+
+
+class DynamicMatrix(pym.Module):
+    alpha = 0.5
+    beta = 0.5
+
+    def _response(self, K, M, omega):
+        return K + 1j * omega * (self.alpha * M + self.beta * K) - omega ** 2 * M
+
+    def _sensitivity(self, dZ):
+        K, M, omega = [s.state for s in self.sig_in]
+        dK = np.real(dZ) - (omega * self.beta) * np.imag(dZ)
+        dM = (-omega ** 2) * np.real(dZ) - (omega * self.alpha) * np.imag(dZ)
+        dZrM = np.real(dZ).contract(M)
+        dZiK = np.imag(dZ).contract(K)
+        dZiM = np.imag(dZ).contract(M)
+        domega = -self.beta * dZiK - self.alpha * dZiM - 2 * omega * dZrM
+        return dK, dM, domega
+
+
+class TestLinSolveModuleSparse(unittest.TestCase):
+    # # ------------- Symmetric -------------
+    def test_symmetric_real_compliance2d(self):
+        """ Test symmetric real sparse matrix (compliance in 2D)"""
+        N = 10  # Number of elements
+        dom = pym.DomainDefinition(N, N)
+        sx = pym.Signal('x', np.random.rand(dom.nel))
+        fixed_nodes = dom.get_nodenumber(0, np.arange(0, N+1))
+        bc = np.concatenate((fixed_nodes*2, fixed_nodes*2+1))
+        # Setup different rhs types
+        iforce_x = dom.get_nodenumber(N, np.arange(0, N + 1)) * 2  # Force in x-direction
+        iforce_y = dom.get_nodenumber(N, np.arange(0, N + 1)) * 2 + 1  # Force in y-direction
+
+        force_vecs = dict()
+
+        # Single force
+        f = np.zeros(dom.nnodes*2)
+        f[iforce_x] = 1.0
+        force_vecs['single_real'] = f
+
+        # Multiple rhs
+        f = np.zeros((dom.nnodes * 2, 2))
+        f[iforce_x, 0] = 1.0
+        f[iforce_y, 1] = 1.0
+        force_vecs['multiple_real'] = f
+
+        for k, f in force_vecs.items():
+            with self.subTest(f"RHS-{k}"):
+                sf = pym.Signal('f', f)
+
+                fn = pym.Network()
+                sK = fn.append(pym.AssembleStiffness(sx, pym.Signal('K'), dom, bc=bc))
+                su = fn.append(pym.LinSolve([sK, sf], pym.Signal('u')))
+
+                fn.response()
+
+                self.assertTrue(np.allclose(sK.state@su.state, sf.state))  # Check residual
+                # Check finite difference
+                # def tfn(x0, dx, df_an, df_fd): np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5)
+                def tfn(x0, dx, df_an, df_fd): self.assertTrue(np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5))
+                pym.finite_difference(fn, [sx, sf], su, test_fn=tfn, dx=1e-5, tol=1e-4, verbose=False)
+
+    def test_symmetric_real_compliance3d(self):
+        """ Test symmetric real sparse matrix (compliance in 3D)"""
+        N = 3  # Number of elements
+        dom = pym.DomainDefinition(N, N, N)
+        sx = pym.Signal('x', np.random.rand(dom.nel))
+        jfix, kfix = np.meshgrid(np.arange(0, N+1), np.arange(0, N+1), indexing='ij')
+        fixed_nodes = dom.get_nodenumber(0, jfix, kfix).flatten()
+        bc = np.concatenate((fixed_nodes*3, fixed_nodes*3+1, fixed_nodes*3+2))
+        iforce = dom.get_nodenumber(N, np.arange(0, N+1), np.arange(0, N+1))*3 + 1
+        sf = pym.Signal('f', np.zeros(dom.nnodes*3))
+        sf.state[iforce] = 1.0
+
+        fn = pym.Network()
+        sK = fn.append(pym.AssembleStiffness(sx, pym.Signal('K'), dom, bc=bc))
+        su = fn.append(pym.LinSolve([sK, sf], pym.Signal('u')))
+
+        fn.response()
+
+        self.assertTrue(np.allclose(sK.state@su.state, sf.state))  # Check residual
+        # Check finite difference
+        # def tfn(x0, dx, df_an, df_fd): np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5)
+        def tfn(x0, dx, df_an, df_fd): self.assertTrue(np.allclose(df_an, df_fd, rtol=2e-3, atol=1e-5))
+        pym.finite_difference(fn, [sx, sf], su, test_fn=tfn, dx=1e-5, tol=1e-4, verbose=False)
+
+    def test_symmetric_complex_dyncompliance2d(self):
+        """ Test symmetric complex sparse matrix (dynamic compliance in 2D)"""
+        N = 5  # Number of elements
+        dom = pym.DomainDefinition(N, N)
+        sx = pym.Signal('x', np.random.rand(dom.nel))
+        fixed_nodes = dom.get_nodenumber(0, np.arange(0, N+1))
+        bc = np.concatenate((fixed_nodes*2, fixed_nodes*2+1))
+        iforce = dom.get_nodenumber(N, np.arange(0, N+1))*2 + 1
+        sf = pym.Signal('f', np.zeros(dom.nnodes*2))
+        sf.state[iforce] = 1.0
+
+        sOmega = pym.Signal('omega', 0.1)
+        fn = pym.Network()
+        sK = fn.append(pym.AssembleStiffness(sx, pym.Signal('K'), dom, bc=bc))
+        sM = fn.append(pym.AssembleMass(sx, pym.Signal('M'), dom, bc=bc))
+        sZ = fn.append(DynamicMatrix([sK, sM, sOmega], pym.Signal('Z')))
+
+        su = fn.append(pym.LinSolve([sZ, sf], pym.Signal('u')))
+
+        fn.response()
+
+        # spspla.eigsh(sK.state, M=sM.state, k=6, sigma=0.0)
+
+        self.assertTrue(np.allclose(sZ.state@su.state, sf.state))  # Check residual
+        # Check finite difference
+        # def tfn(x0, dx, df_an, df_fd): np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5)
+        def tfn(x0, dx, df_an, df_fd): self.assertTrue(np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5))
+        pym.finite_difference(fn, [sx, sf, sOmega], su, test_fn=tfn, dx=1e-7, tol=1e-4, verbose=False)
+
+
+class TestAssemblyAddValues(unittest.TestCase):
+    def test_finite_difference(self):
+        N = 2
+        # Set up the domain
+        domain = pym.DomainDefinition(N, N)
+        nodes_left = domain.get_nodenumber(0, np.arange(N + 1))
+        nodes_right = domain.get_nodenumber(N, np.arange(N + 1))
+
+        dofs_left = np.repeat(nodes_left * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
+        dofs_right = np.repeat(nodes_right * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
+        dofs_left_x = dofs_left[0::2]
+        dofs_left_y = dofs_left[1::2]
+        dof_input = dofs_left_y[0]  # Input dofs for mechanism
+        dof_output = dofs_left_y[-1]  # Output dofs for mechanism
+
+        prescribed_dofs = np.union1d(dofs_left_x, dofs_right)
+
+        # Setup rhs for two loadcases
+        f = np.zeros(domain.nnodes * 2, dtype=float)
+        f[dof_input] = 1.0
+
+        # Initial design
+        sx = pym.Signal('x', np.random.rand(domain.nel))
+        signal_force = pym.Signal('f', state=f)
+        # Setup optimization problem
+        network = pym.Network()
+
+        # Assembly
+        istiff = np.array([dof_input, dof_output])
+        sstiff = np.array([10.0, 10.0])
+
+        K_const = csc_matrix((sstiff, (istiff, istiff)), shape=(domain.nnodes * 2, domain.nnodes * 2))
+        signal_stiffness = network.append(pym.AssembleStiffness(sx, domain=domain, bc=prescribed_dofs, add_constant=K_const))
+        su = network.append(pym.LinSolve([signal_stiffness, signal_force], pym.Signal('u')))
+        sc = network.append(pym.EinSum(su, expression='i->'))
+        network.response()
+
+        def tfn(x0, dx, df_an, df_fd): self.assertTrue(np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5))
+
+        pym.finite_difference(network, [sx], sc, test_fn=tfn, dx=1e-5, tol=1e-4, verbose=False)
+
+    def test_added_stiffness_on_ground(self):
+        N = 2
+        # Set up the domain
+        domain = pym.DomainDefinition(N, N)
+        nodes_left = domain.get_nodenumber(0, np.arange(N + 1))
+        nodes_right = domain.get_nodenumber(N, np.arange(N + 1))
+
+        dofs_left = np.repeat(nodes_left * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
+        dofs_right = np.repeat(nodes_right * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
+        dofs_left_x = dofs_left[0::2]
+        dofs_left_y = dofs_left[1::2]
+        dof_input = dofs_left_y[0]  # Input dofs for mechanism
+        dof_output = dofs_left_y[-1]  # Output dofs for mechanism
+
+        prescribed_dofs = np.union1d(dofs_left_x, dofs_right)
+
+        # Setup rhs for two loadcases
+        f = np.zeros(domain.nnodes * 2, dtype=float)
+        f[dof_input] = 1.0
+
+        # Initial design
+        sx = pym.Signal('x', np.random.rand(domain.nel))
+        signal_force = pym.Signal('f', state=f)
+        # Setup optimization problem
+        network = pym.Network()
+
+        # Assembly
+        istiff = np.array([dof_input, dof_output])
+        sstiff = np.array([10.0, 10.0])
+
+        K_const = csc_matrix((sstiff, (istiff, istiff)), shape=(domain.nnodes * 2, domain.nnodes * 2))
+        signal_stiffness = network.append(
+            pym.AssembleStiffness(sx, domain=domain, bc=prescribed_dofs, add_constant=K_const))
+        su = network.append(pym.LinSolve([signal_stiffness, signal_force], pym.Signal('u')))
+        sc = network.append(pym.EinSum(su, expression='i->'))
+
+        network.response()
+
+        network2 = pym.Network()
+        # Assembly
+        istiff = np.array([dof_input, dof_output, 4, 5])
+        sstiff = np.array([10.0, 10.0, 100.0, 100.0])
+
+        K_const1 = csc_matrix((sstiff, (istiff, istiff)), shape=(domain.nnodes * 2, domain.nnodes * 2))
+        signal_stiffness = network2.append(
+            pym.AssembleStiffness(sx, domain=domain, bc=prescribed_dofs, add_constant=K_const1))
+        su = network2.append(pym.LinSolve([signal_stiffness, signal_force], pym.Signal('u')))
+        sc2 = network2.append(pym.EinSum(su, expression='i->'))
+
+        network2.response()
+
+        npt.assert_allclose(sc.state, sc2.state)
+
+
+class TestSystemOfEquations(unittest.TestCase):
+    def test_sparse_symmetric_real_compliance2d_single_load(self):
+        """ Test symmetric real sparse matrix (compliance in 2D)"""
+        N=10
+        # Set up the domain
+        domain = pym.DomainDefinition(N, N)
+
+        # node groups
+        nodes_left = domain.get_nodenumber(0, np.arange(N + 1))
+        nodes_right = domain.get_nodenumber(N, np.arange(N + 1))
+
+        # dof groups
+        dofs_left = np.repeat(nodes_left * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
+        dofs_right = np.repeat(nodes_right * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
+        dofs_left_horizontal = dofs_left[0::2]
+        dofs_left_vertical = dofs_left[1::2]
+
+        # free and prescribed dofs
+        all_dofs = np.arange(0, 2 * domain.nnodes)
+        prescribed_dofs = np.unique(np.hstack([dofs_left_horizontal, dofs_right, dofs_left_vertical]))
+        free_dofs = np.setdiff1d(all_dofs, prescribed_dofs)
+
+        # Setup solution vectors and rhs
+        ff = np.zeros_like(free_dofs, dtype=float)
+        ff[:] = np.random.rand(len(free_dofs))
+        u = np.zeros_like(all_dofs, dtype=float)
+
+        u[dofs_left_vertical] = np.random.rand(len(dofs_left_vertical))
+        up = u[prescribed_dofs]
+
+        sff = pym.Signal('ff', ff)
+        sup = pym.Signal('up', up)
+
+        fn = pym.Network()
+        sx = pym.Signal('x', np.random.rand(domain.nel))
+        sK = fn.append(pym.AssembleStiffness(sx, pym.Signal('K'), domain))
+        su = fn.append(pym.SystemOfEquations([sK, sff, sup], free=free_dofs, prescribed=prescribed_dofs))
+        sc = fn.append(pym.EinSum([su[0], su[1]], expression='i,i->'))
+        fn.response()
+        def tfn(x0, dx, df_an, df_fd): self.assertTrue(np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5))
+        pym.finite_difference(fn, [sx, sff, sup], sc, test_fn=tfn, dx=1e-5, tol=1e-4, verbose=False)
+
+    def test_sparse_symmetric_real_compliance2d_single_load_u(self):
+        """ Test symmetric real sparse matrix (compliance in 2D)"""
+        N = 10
+        # Set up the domain
+        domain = pym.DomainDefinition(N, N)
+
+        # node groups
+        nodes_left = domain.get_nodenumber(0, np.arange(N + 1))
+        nodes_right = domain.get_nodenumber(N, np.arange(N + 1))
+
+        # dof groups
+        dofs_left = np.repeat(nodes_left * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
+        dofs_right = np.repeat(nodes_right * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
+        dofs_left_horizontal = dofs_left[0::2]
+        dofs_left_vertical = dofs_left[1::2]
+
+        # free and prescribed dofs
+        all_dofs = np.arange(0, 2 * domain.nnodes)
+        prescribed_dofs = np.unique(np.hstack([dofs_left_horizontal, dofs_right, dofs_left_vertical]))
+        free_dofs = np.setdiff1d(all_dofs, prescribed_dofs)
+
+        # Setup solution vectors and rhs
+        ff = np.zeros_like(free_dofs, dtype=float)
+        ff[:] = np.random.rand(len(free_dofs))
+        u = np.zeros_like(all_dofs, dtype=float)
+
+        u[dofs_left_vertical] = np.random.rand(len(dofs_left_vertical))
+        up = u[prescribed_dofs]
+
+        sff = pym.Signal('ff', ff)
+        sup = pym.Signal('up', up)
+
+        fn = pym.Network()
+        sx = pym.Signal('x', np.random.rand(domain.nel))
+        sK = fn.append(pym.AssembleStiffness(sx, pym.Signal('K'), domain))
+        su = fn.append(pym.SystemOfEquations([sK, sff, sup], free=free_dofs, prescribed=prescribed_dofs))
+        sc = fn.append(pym.EinSum([su[0]], expression='i->'))
+        fn.response()
+
+        def tfn(x0, dx, df_an, df_fd): self.assertTrue(np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5))
+
+        pym.finite_difference(fn, [sx, sff, sup], sc, test_fn=tfn, dx=1e-5, tol=1e-4, verbose=False)
+
+    def test_sparse_symmetric_real_compliance2d_single_load_f(self):
+        """ Test symmetric real sparse matrix (compliance in 2D)"""
+        N = 10
+        # Set up the domain
+        domain = pym.DomainDefinition(N, N)
+
+        # node groups
+        nodes_left = domain.get_nodenumber(0, np.arange(N + 1))
+        nodes_right = domain.get_nodenumber(N, np.arange(N + 1))
+
+        # dof groups
+        dofs_left = np.repeat(nodes_left * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
+        dofs_right = np.repeat(nodes_right * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
+        dofs_left_horizontal = dofs_left[0::2]
+        dofs_left_vertical = dofs_left[1::2]
+
+        # free and prescribed dofs
+        all_dofs = np.arange(0, 2 * domain.nnodes)
+        prescribed_dofs = np.unique(np.hstack([dofs_left_horizontal, dofs_right, dofs_left_vertical]))
+        free_dofs = np.setdiff1d(all_dofs, prescribed_dofs)
+
+        # Setup solution vectors and rhs
+        ff = np.zeros_like(free_dofs, dtype=float)
+        ff[:] = np.random.rand(len(free_dofs))
+        u = np.zeros_like(all_dofs, dtype=float)
+
+        u[dofs_left_vertical] = np.random.rand(len(dofs_left_vertical))
+        up = u[prescribed_dofs]
+
+        sff = pym.Signal('ff', ff)
+        sup = pym.Signal('up', up)
+
+        fn = pym.Network()
+        sx = pym.Signal('x', np.random.rand(domain.nel))
+        sK = fn.append(pym.AssembleStiffness(sx, pym.Signal('K'), domain))
+        su = fn.append(pym.SystemOfEquations([sK, sff, sup], free=free_dofs, prescribed=prescribed_dofs))
+        sc = fn.append(pym.EinSum([su[1]], expression='i->'))
+        fn.response()
+
+        def tfn(x0, dx, df_an, df_fd): self.assertTrue(np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5))
+
+        pym.finite_difference(fn, [sx, sff, sup], sc, test_fn=tfn, dx=1e-5, tol=1e-4, verbose=False)
+
+    def test_sparse_symmetric_real_compliance2d_single_multi_load(self):
+        """ Test symmetric real sparse matrix (compliance in 2D)"""
+        N=10
+        # Set up the domain
+        domain = pym.DomainDefinition(N, N)
+
+        # node groups
+        nodes_left = domain.get_nodenumber(0, np.arange(N + 1))
+        nodes_right = domain.get_nodenumber(N, np.arange(N + 1))
+
+        # dof groups
+        dofs_left = np.repeat(nodes_left * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
+        dofs_right = np.repeat(nodes_right * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
+        dofs_left_horizontal = dofs_left[0::2]
+        dofs_left_vertical = dofs_left[1::2]
+
+        # free and prescribed dofs
+        all_dofs = np.arange(0, 2 * domain.nnodes)
+        prescribed_dofs = np.unique(np.hstack([dofs_left_horizontal, dofs_right, dofs_left_vertical]))
+        free_dofs = np.setdiff1d(all_dofs, prescribed_dofs)
+
+        # Setup solution vectors and rhs
+        ff = np.zeros((len(free_dofs), 2), dtype=float)
+        ff[:, :] = np.random.rand(np.shape(ff)[0], np.shape(ff)[1])
+        u = np.zeros((len(all_dofs), 2), dtype=float)
+
+        u[dofs_left_vertical, 0] = np.random.rand(len(dofs_left_vertical))
+        u[dofs_left_horizontal, 1] = np.random.rand(len(dofs_left_vertical))
+        up = u[prescribed_dofs, :]
+
+        sff = pym.Signal('ff', ff)
+        sup = pym.Signal('up', up)
+
+        fn = pym.Network()
+        sx = pym.Signal('x', np.random.rand(domain.nel))
+        sK = fn.append(pym.AssembleStiffness(sx, pym.Signal('K'), domain))
+        su = fn.append(pym.SystemOfEquations([sK, sff, sup], free=free_dofs, prescribed=prescribed_dofs))
+        sc1 = fn.append(pym.EinSum([su[0][:, 0], su[1][:, 0]], expression='i,i->'))
+        sc2 = fn.append(pym.EinSum([su[0][:, 1], su[1][:, 1]], expression='i,i->'))
+        sc = fn.append(pym.MathGeneral([sc1, sc2], expression='inp0 + inp1'))
+        fn.response()
+        def tfn(x0, dx, df_an, df_fd): self.assertTrue(np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5))
+        pym.finite_difference(fn, [sx, sff, sup], sc, test_fn=tfn, dx=1e-5, tol=1e-4, verbose=False)
+
+    def test_sparse_symmetric_real_compliance2d_single_multi_load_u(self):
+        """ Test symmetric real sparse matrix (compliance in 2D)"""
+        N = 10
+        # Set up the domain
+        domain = pym.DomainDefinition(N, N)
+
+        # node groups
+        nodes_left = domain.get_nodenumber(0, np.arange(N + 1))
+        nodes_right = domain.get_nodenumber(N, np.arange(N + 1))
+
+        # dof groups
+        dofs_left = np.repeat(nodes_left * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
+        dofs_right = np.repeat(nodes_right * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
+        dofs_left_horizontal = dofs_left[0::2]
+        dofs_left_vertical = dofs_left[1::2]
+
+        # free and prescribed dofs
+        all_dofs = np.arange(0, 2 * domain.nnodes)
+        prescribed_dofs = np.unique(np.hstack([dofs_left_horizontal, dofs_right, dofs_left_vertical]))
+        free_dofs = np.setdiff1d(all_dofs, prescribed_dofs)
+
+        # Setup solution vectors and rhs
+        ff = np.zeros((len(free_dofs), 2), dtype=float)
+        ff[:, :] = np.random.rand(np.shape(ff)[0], np.shape(ff)[1])
+        u = np.zeros((len(all_dofs), 2), dtype=float)
+
+        u[dofs_left_vertical, 0] = np.random.rand(len(dofs_left_vertical))
+        u[dofs_left_horizontal, 1] = np.random.rand(len(dofs_left_vertical))
+        up = u[prescribed_dofs, :]
+
+        sff = pym.Signal('ff', ff)
+        sup = pym.Signal('up', up)
+
+        fn = pym.Network()
+        sx = pym.Signal('x', np.random.rand(domain.nel))
+        sK = fn.append(pym.AssembleStiffness(sx, pym.Signal('K'), domain))
+        su = fn.append(pym.SystemOfEquations([sK, sff, sup], free=free_dofs, prescribed=prescribed_dofs))
+        sc = fn.append(pym.EinSum(su[0], expression='ij->'))
+        fn.response()
+
+        def tfn(x0, dx, df_an, df_fd): self.assertTrue(np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5))
+
+        pym.finite_difference(fn, [sx, sff, sup], sc, test_fn=tfn, dx=1e-5, tol=1e-4, verbose=False)
+
+    def test_sparse_symmetric_real_compliance2d_single_multi_load_f(self):
+        """ Test symmetric real sparse matrix (compliance in 2D)"""
+        N = 10
+        # Set up the domain
+        domain = pym.DomainDefinition(N, N)
+
+        # node groups
+        nodes_left = domain.get_nodenumber(0, np.arange(N + 1))
+        nodes_right = domain.get_nodenumber(N, np.arange(N + 1))
+
+        # dof groups
+        dofs_left = np.repeat(nodes_left * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
+        dofs_right = np.repeat(nodes_right * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
+        dofs_left_horizontal = dofs_left[0::2]
+        dofs_left_vertical = dofs_left[1::2]
+
+        # free and prescribed dofs
+        all_dofs = np.arange(0, 2 * domain.nnodes)
+        prescribed_dofs = np.unique(np.hstack([dofs_left_horizontal, dofs_right, dofs_left_vertical]))
+        free_dofs = np.setdiff1d(all_dofs, prescribed_dofs)
+
+        # Setup solution vectors and rhs
+        ff = np.zeros((len(free_dofs), 2), dtype=float)
+        ff[:, :] = np.random.rand(np.shape(ff)[0], np.shape(ff)[1])
+        u = np.zeros((len(all_dofs), 2), dtype=float)
+
+        u[dofs_left_vertical, 0] = np.random.rand(len(dofs_left_vertical))
+        u[dofs_left_horizontal, 1] = np.random.rand(len(dofs_left_vertical))
+        up = u[prescribed_dofs, :]
+
+        sff = pym.Signal('ff', ff)
+        sup = pym.Signal('up', up)
+
+        fn = pym.Network()
+        sx = pym.Signal('x', np.random.rand(domain.nel))
+        sK = fn.append(pym.AssembleStiffness(sx, pym.Signal('K'), domain))
+        su = fn.append(pym.SystemOfEquations([sK, sff, sup], free=free_dofs, prescribed=prescribed_dofs))
+        sc = fn.append(pym.EinSum(su[1], expression='ij->'))
+        fn.response()
+
+        def tfn(x0, dx, df_an, df_fd): self.assertTrue(np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5))
+
+        pym.finite_difference(fn, [sx, sff, sup], sc, test_fn=tfn, dx=1e-5, tol=1e-4, verbose=False)
+
+
+if __name__ == '__main__':
+    unittest.main()

{pyMOTO-1.1.0 → pyMOTO-1.2.1}/tests/test_solvers_sparse.py

@@ -1,14 +1,16 @@
+import inspect
+import pathlib  # For importing files
+import sys
 import unittest
+from math import isclose
+
 import numpy as np
 import scipy as sp
-from scipy.io import mmread  # For importing files
-import pathlib  # For importing files
 import scipy.sparse as spsp
 import scipy.sparse.linalg as spspla
-import scipy
+from scipy.io import mmread  # For importing files
+
 import pymoto as pym
-import sys
-import inspect
 
 try:
     import cvxopt
@@ -408,208 +410,5 @@ class TestPardiso(GenericTestSolvers):
     ]
 
 
-""" ------------------ TEST LINSOLVE MODULE -------------------- """
-
-
-class DynamicMatrix(pym.Module):
-    alpha = 0.5
-    beta = 0.5
-
-    def _response(self, K, M, omega):
-        return K + 1j * omega * (self.alpha * M + self.beta * K) - omega ** 2 * M
-
-    def _sensitivity(self, dZ):
-        K, M, omega = [s.state for s in self.sig_in]
-        dK = np.real(dZ) - (omega * self.beta) * np.imag(dZ)
-        dM = (-omega ** 2) * np.real(dZ) - (omega * self.alpha) * np.imag(dZ)
-        dZrM = np.real(dZ).contract(M)
-        dZiK = np.imag(dZ).contract(K)
-        dZiM = np.imag(dZ).contract(M)
-        domega = -self.beta * dZiK - self.alpha * dZiM - 2 * omega * dZrM
-        return dK, dM, domega
-
-class TestLinSolveModule_sparse(unittest.TestCase):
-    # # ------------- Symmetric -------------
-    def test_symmetric_real_compliance2d(self):
-        """ Test symmetric real sparse matrix (compliance in 2D)"""
-        N = 10  # Number of elements
-        dom = pym.DomainDefinition(N, N)
-        sx = pym.Signal('x', np.random.rand(dom.nel))
-        fixed_nodes = dom.get_nodenumber(0, np.arange(0, N+1))
-        bc = np.concatenate((fixed_nodes*2, fixed_nodes*2+1))
-        # Setup different rhs types
-        iforce_x = dom.get_nodenumber(N, np.arange(0, N + 1)) * 2  # Force in x-direction
-        iforce_y = dom.get_nodenumber(N, np.arange(0, N + 1)) * 2 + 1  # Force in y-direction
-
-        force_vecs = dict()
-
-        # Single force
-        f = np.zeros(dom.nnodes*2)
-        f[iforce_x] = 1.0
-        force_vecs['single_real'] = f
-
-        # Multiple rhs
-        f = np.zeros((dom.nnodes * 2, 2))
-        f[iforce_x, 0] = 1.0
-        f[iforce_y, 1] = 1.0
-        force_vecs['multiple_real'] = f
-
-        for k, f in force_vecs.items():
-            with self.subTest(f"RHS-{k}"):
-                sf = pym.Signal('f', f)
-
-                fn = pym.Network()
-                sK = fn.append(pym.AssembleStiffness(sx, pym.Signal('K'), dom, bc=bc))
-                su = fn.append(pym.LinSolve([sK, sf], pym.Signal('u')))
-
-                fn.response()
-
-                self.assertTrue(np.allclose(sK.state@su.state, sf.state))  # Check residual
-                # Check finite difference
-                # def tfn(x0, dx, df_an, df_fd): np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5)
-                def tfn(x0, dx, df_an, df_fd): self.assertTrue(np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5))
-                pym.finite_difference(fn, [sx, sf], su, test_fn=tfn, dx=1e-5, tol=1e-4, verbose=False)
-
-    def test_symmetric_real_compliance3d(self):
-        """ Test symmetric real sparse matrix (compliance in 3D)"""
-        N = 3  # Number of elements
-        dom = pym.DomainDefinition(N, N, N)
-        sx = pym.Signal('x', np.random.rand(dom.nel))
-        jfix, kfix = np.meshgrid(np.arange(0, N+1), np.arange(0, N+1), indexing='ij')
-        fixed_nodes = dom.get_nodenumber(0, jfix, kfix).flatten()
-        bc = np.concatenate((fixed_nodes*3, fixed_nodes*3+1, fixed_nodes*3+2))
-        iforce = dom.get_nodenumber(N, np.arange(0, N+1), np.arange(0, N+1))*3 + 1
-        sf = pym.Signal('f', np.zeros(dom.nnodes*3))
-        sf.state[iforce] = 1.0
-
-        fn = pym.Network()
-        sK = fn.append(pym.AssembleStiffness(sx, pym.Signal('K'), dom, bc=bc))
-        su = fn.append(pym.LinSolve([sK, sf], pym.Signal('u')))
-
-        fn.response()
-
-        self.assertTrue(np.allclose(sK.state@su.state, sf.state))  # Check residual
-        # Check finite difference
-        # def tfn(x0, dx, df_an, df_fd): np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5)
-        def tfn(x0, dx, df_an, df_fd): self.assertTrue(np.allclose(df_an, df_fd, rtol=2e-3, atol=1e-5))
-        pym.finite_difference(fn, [sx, sf], su, test_fn=tfn, dx=1e-5, tol=1e-4, verbose=False)
-
-    def test_symmetric_complex_dyncompliance2d(self):
-        """ Test symmetric complex sparse matrix (dynamic compliance in 2D)"""
-        N = 5  # Number of elements
-        dom = pym.DomainDefinition(N, N)
-        sx = pym.Signal('x', np.random.rand(dom.nel))
-        fixed_nodes = dom.get_nodenumber(0, np.arange(0, N+1))
-        bc = np.concatenate((fixed_nodes*2, fixed_nodes*2+1))
-        iforce = dom.get_nodenumber(N, np.arange(0, N+1))*2 + 1
-        sf = pym.Signal('f', np.zeros(dom.nnodes*2))
-        sf.state[iforce] = 1.0
-
-        sOmega = pym.Signal('omega', 0.1)
-        fn = pym.Network()
-        sK = fn.append(pym.AssembleStiffness(sx, pym.Signal('K'), dom, bc=bc))
-        sM = fn.append(pym.AssembleMass(sx, pym.Signal('M'), dom, bc=bc))
-        sZ = fn.append(DynamicMatrix([sK, sM, sOmega], pym.Signal('Z')))
-
-        su = fn.append(pym.LinSolve([sZ, sf], pym.Signal('u')))
-
-        fn.response()
-
-        # spspla.eigsh(sK.state, M=sM.state, k=6, sigma=0.0)
-
-        self.assertTrue(np.allclose(sZ.state@su.state, sf.state))  # Check residual
-        # Check finite difference
-        # def tfn(x0, dx, df_an, df_fd): np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5)
-        def tfn(x0, dx, df_an, df_fd): self.assertTrue(np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5))
-        pym.finite_difference(fn, [sx, sf, sOmega], su, test_fn=tfn, dx=1e-7, tol=1e-4, verbose=False)
-
-
-class TestSystemOfEquations(unittest.TestCase):
-    def test_sparse_symmetric_real_compliance2d_single_load(self):
-        """ Test symmetric real sparse matrix (compliance in 2D)"""
-        N=10
-        # Set up the domain
-        domain = pym.DomainDefinition(N, N)
-
-        # node groups
-        nodes_left = domain.get_nodenumber(0, np.arange(N + 1))
-        nodes_right = domain.get_nodenumber(N, np.arange(N + 1))
-
-        # dof groups
-        dofs_left = np.repeat(nodes_left * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
-        dofs_right = np.repeat(nodes_right * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
-        dofs_left_horizontal = dofs_left[0::2]
-        dofs_left_vertical = dofs_left[1::2]
-
-        # free and prescribed dofs
-        all_dofs = np.arange(0, 2 * domain.nnodes)
-        prescribed_dofs = np.unique(np.hstack([dofs_left_horizontal, dofs_right, dofs_left_vertical]))
-        free_dofs = np.setdiff1d(all_dofs, prescribed_dofs)
-
-        # Setup solution vectors and rhs
-        ff = np.zeros_like(free_dofs, dtype=float)
-        ff[:] = np.random.rand(len(free_dofs))
-        u = np.zeros_like(all_dofs, dtype=float)
-
-        u[dofs_left_vertical] = np.random.rand(len(dofs_left_vertical))
-        up = u[prescribed_dofs]
-
-        sff = pym.Signal('ff', ff)
-        sup = pym.Signal('up', up)
-
-        fn = pym.Network()
-        sx = pym.Signal('x', np.random.rand(domain.nel))
-        sK = fn.append(pym.AssembleStiffness(sx, pym.Signal('K'), domain))
-        su = fn.append(pym.SystemOfEquations([sK, sff, sup], free=free_dofs, prescribed=prescribed_dofs))
-        sc = fn.append(pym.EinSum([su[0], su[1]], expression='i,i->'))
-        fn.response()
-        def tfn(x0, dx, df_an, df_fd): self.assertTrue(np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5))
-        pym.finite_difference(fn, [sx, sff, sup], sc, test_fn=tfn, dx=1e-5, tol=1e-4, verbose=False)
-
-    def test_sparse_symmetric_real_compliance2d_single_multi_load(self):
-        """ Test symmetric real sparse matrix (compliance in 2D)"""
-        N=10
-        # Set up the domain
-        domain = pym.DomainDefinition(N, N)
-
-        # node groups
-        nodes_left = domain.get_nodenumber(0, np.arange(N + 1))
-        nodes_right = domain.get_nodenumber(N, np.arange(N + 1))
-
-        # dof groups
-        dofs_left = np.repeat(nodes_left * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
-        dofs_right = np.repeat(nodes_right * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
-        dofs_left_horizontal = dofs_left[0::2]
-        dofs_left_vertical = dofs_left[1::2]
-
-        # free and prescribed dofs
-        all_dofs = np.arange(0, 2 * domain.nnodes)
-        prescribed_dofs = np.unique(np.hstack([dofs_left_horizontal, dofs_right, dofs_left_vertical]))
-        free_dofs = np.setdiff1d(all_dofs, prescribed_dofs)
-
-        # Setup solution vectors and rhs
-        ff = np.zeros((len(free_dofs), 2), dtype=float)
-        ff[:, :] = np.random.rand(np.shape(ff)[0], np.shape(ff)[1])
-        u = np.zeros((len(all_dofs), 2), dtype=float)
-
-        u[dofs_left_vertical, 0] = np.random.rand(len(dofs_left_vertical))
-        u[dofs_left_horizontal, 1] = np.random.rand(len(dofs_left_vertical))
-        up = u[prescribed_dofs, :]
-
-        sff = pym.Signal('ff', ff)
-        sup = pym.Signal('up', up)
-
-        fn = pym.Network()
-        sx = pym.Signal('x', np.random.rand(domain.nel))
-        sK = fn.append(pym.AssembleStiffness(sx, pym.Signal('K'), domain))
-        su = fn.append(pym.SystemOfEquations([sK, sff, sup], prescribed=prescribed_dofs))
-        sc1 = fn.append(pym.EinSum([su[0][:, 0], su[1][:, 0]], expression='i,i->'))
-        sc2 = fn.append(pym.EinSum([su[0][:, 1], su[1][:, 1]], expression='i,i->'))
-        sc = fn.append(pym.MathGeneral([sc1, sc2], expression='inp0 + inp1'))
-        fn.response()
-        def tfn(x0, dx, df_an, df_fd): self.assertTrue(np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5))
-        pym.finite_difference(fn, [sx, sff, sup], sc, test_fn=tfn, dx=1e-5, tol=1e-4, verbose=False)
-
-
 if __name__ == '__main__':
     unittest.main()

pyMOTO-1.2.1/tests/test_static_condenstation.py

@@ -0,0 +1,55 @@
+import unittest
+import numpy as np
+import pymoto as pym
+import numpy.testing as npt
+
+np.random.seed(0)
+
+
+class TestStaticCondensation(unittest.TestCase):
+    def test_real_symmetric(self):
+        """ Test symmetric real sparse matrix (compliance in 2D)"""
+        N = 20
+        # Set up the domain
+        domain = pym.DomainDefinition(N, N)
+
+        # node groups
+        nodes_left = domain.get_nodenumber(0, np.arange(N + 1))
+        nodes_right = domain.get_nodenumber(N, np.arange(N + 1))
+
+        # dof groups
+        dofs_left = np.repeat(nodes_left * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
+        dofs_right = np.repeat(nodes_right * 2, 2, axis=-1) + np.tile(np.arange(2), N + 1)
+
+        # free and prescribed dofs
+        all_dofs = np.arange(0, 2 * domain.nnodes)
+        prescribed_dofs = dofs_right
+        main_dofs = dofs_left[0::2]
+        free_dofs = np.setdiff1d(all_dofs, np.unique(np.hstack([main_dofs, prescribed_dofs])))
+
+        fn = pym.Network()
+        sx = pym.Signal('x', np.random.rand(domain.nel))
+        sK = fn.append(pym.AssembleStiffness(sx, pym.Signal('K'), domain))
+        su = fn.append(pym.StaticCondensation([sK], free=free_dofs, main=main_dofs))
+        sc = fn.append(pym.EinSum([su], expression='ij->'))
+        fn.response()
+
+        # Check result
+        fn1 = pym.Network()
+        sK1 = fn1.append(pym.AssembleStiffness(sx, domain=domain, bc=np.concatenate([main_dofs[1:], prescribed_dofs])))
+        sf = pym.Signal('f', np.zeros(domain.nnodes*2))
+        sf.state[main_dofs[0]] = 1.0
+        su1 = fn1.append(pym.LinSolve([sK1, sf]))
+        suKu1 = fn1.append(pym.EinSum([su1, sf], expression='i,i->'))
+        fn1.response()
+
+        npt.assert_allclose(suKu1.state, 1/su.state[0, 0])
+
+        def tfn(x0, dx, df_an, df_fd): self.assertTrue(np.allclose(df_an, df_fd, rtol=1e-3, atol=1e-5))
+
+        pym.finite_difference(fn, [sx], sc, test_fn=tfn, dx=1e-5, tol=1e-4, verbose=False)
+
+
+
+if __name__ == '__main__':
+    unittest.main()