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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyMOTO
-Version: 1.5.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/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '1.5.0'
+__version__ = '1.5.1'
 
 from .common.domain import DomainDefinition
 

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)
 

pymoto/common/dyadcarrier.py

@@ -393,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]

pymoto/common/mma.py

@@ -305,8 +305,12 @@ 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()
@@ -371,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 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
@@ -564,4 +572,4 @@ class MMA:
             print(f"  | Changes: {', '.join(change_msgs)}")
 
         return xmma, change
-      
+      

pymoto/core_objects.py

@@ -186,14 +186,14 @@ class SignalSlice(Signal):
     The sliced values are referenced to their original source Signal, such that they can be used and updated in modules.
     This means that updating the values in this SignalSlice changes the data in its source Signal.
     """
-    def __init__(self, orig_signal, sl, tag=None):
-        self.orig_signal = orig_signal
+    def __init__(self, base, sl, tag=None):
+        self.base = base
         self.slice = sl
         self.keep_alloc = False  # Allocation must be False because sensitivity cannot be assigned with [] operator
 
         # for s in slice:
         if tag is None:
-            self.tag = f"{self.orig_signal.tag}[{fmt_slice(self.slice)}]"
+            self.tag = f"{self.base.tag}[{fmt_slice(self.slice)}]"
         else:
             self.tag = tag
 
@@ -203,7 +203,7 @@ class SignalSlice(Signal):
     @property
     def state(self):
         try:
-            return None if self.orig_signal.state is None else self.orig_signal.state[self.slice]
+            return None if self.base.state is None else self.base.state[self.slice]
         except Exception as e:
             # Possibilities: Unslicable object (TypeError) or Wrong dimensions or out of range (IndexError)
             raise type(e)(str(e) + "\n\t| Above error was raised in SignalSlice.state (getter). Signal details:" +
@@ -212,7 +212,7 @@ class SignalSlice(Signal):
     @state.setter
     def state(self, new_state):
         try:
-            self.orig_signal.state[self.slice] = new_state
+            self.base.state[self.slice] = new_state
         except Exception as e:
             # Possibilities: Unslicable object (TypeError) or Wrong dimensions or out of range (IndexError)
             raise type(e)(str(e) + "\n\t| Above error was raised in SignalSlice.state (setter). Signal details:" +
@@ -221,7 +221,7 @@ class SignalSlice(Signal):
     @property
     def sensitivity(self):
         try:
-            return None if self.orig_signal.sensitivity is None else self.orig_signal.sensitivity[self.slice]
+            return None if self.base.sensitivity is None else self.base.sensitivity[self.slice]
         except Exception as e:
             # Possibilities: Unslicable object (TypeError) or Wrong dimensions or out of range (IndexError)
             raise type(e)(str(e) + "\n\t| Above error was raised in SignalSlice.sensitivity (getter). Signal details:" +
@@ -230,26 +230,55 @@ class SignalSlice(Signal):
     @sensitivity.setter
     def sensitivity(self, new_sens):
         try:
-            if self.orig_signal.sensitivity is None:
+            if self.base.sensitivity is None:
+                # Initialize sensitivity of base-signal
                 if new_sens is None:
                     return  # Sensitivity doesn't need to be initialized when it is set to None
                 try:
-                    self.orig_signal.sensitivity = self.orig_signal.state * 0  # Make a new copy with 0 values
+                    self.base.sensitivity = self.base.state * 0  # Make a new copy with 0 values
                 except TypeError:
-                    if self.orig_signal.state is None:
+                    if self.base.state is None:
                         raise TypeError("Could not initialize sensitivity because state is not set" + self._err_str())
                     else:
-                        raise TypeError(f"Could not initialize sensitivity for type \'{type(self.orig_signal.state).__name__}\'")
+                        raise TypeError(f"Could not initialize sensitivity for type \'{type(self.base.state).__name__}\'")
 
             if new_sens is None:
                 new_sens = 0  # reset() uses this
 
-            self.orig_signal.sensitivity[self.slice] = new_sens
+            self.base.sensitivity[self.slice] = new_sens
         except Exception as e:
             # Possibilities: Unslicable object (TypeError) or Wrong dimensions or out of range (IndexError)
             raise type(e)(str(e) + "\n\t| Above error was raised in SignalSlice.state (setter). Signal details:" +
                           self._err_str()).with_traceback(sys.exc_info()[2])
 
+    def add_sensitivity(self, ds: Any):
+        """ Add a new term to internal sensitivity """
+        try:
+            if ds is None:
+                return
+            if self.base.sensitivity is None:
+                self.base.sensitivity = self.base.state * 0
+                # self.sensitivity = copy.deepcopy(ds)
+
+            if hasattr(self.sensitivity, "add_sensitivity"):
+                # Allow user to implement a custom add_sensitivity function instead of __iadd__
+                self.sensitivity.add_sensitivity(ds)
+            else:
+                self.sensitivity += ds
+            return self
+        except TypeError:
+            if isinstance(ds, type(self.sensitivity)):
+                raise TypeError(
+                    f"Cannot add to the sensitivity with type '{type(self.sensitivity).__name__}'" + self._err_str())
+            else:
+                raise TypeError(
+                    f"Adding wrong type '{type(ds).__name__}' to the sensitivity '{type(self.sensitivity).__name__}'" + self._err_str())
+        except ValueError:
+            sens_shape = self.sensitivity.shape if hasattr(self.sensitivity, 'shape') else ()
+            ds_shape = ds.shape if hasattr(ds, 'shape') else ()
+            raise ValueError(
+                f"Cannot add argument of shape {ds_shape} to the sensitivity of shape {sens_shape}" + self._err_str()) from None
+
     def reset(self, keep_alloc: bool = None):
         """ Reset the sensitivities to zero or None
         This must be called to clear internal memory of subsequent sensitivity calculations.
@@ -408,7 +437,7 @@ class Module(ABC, RegisteredClass):
     >> Module([inputs])
 
     Using keywords:
-    >> Module(sig_in=[inputs], sig_out=[outputs]
+    >> Module(sig_in=[inputs], sig_out=[outputs])
     """
 
     def _err_str(self, module_signature: bool = True, init: bool = True, fn=None):
@@ -556,67 +585,74 @@ class Module(ABC, RegisteredClass):
 class Network(Module):
     """ Binds multiple Modules together as one Module
 
+    Initialize a network with a number of modules that should be executed consecutively
     >> Network(module1, module2, ...)
 
     >> Network([module1, module2, ...])
 
     >> Network((module1, module2, ...))
 
+    Modules can also be constructed using a dictionary based on strings
     >> Network([ {type="module1", sig_in=[sig1, sig2], sig_out=[sig3]},
                  {type="module2", sig_in=[sig3], sig_out=[sig4]} ])
 
+    Appending modules to a network will output the signals automatically
+    >> fn = Network()
+    >> s_out = fn.append(module1)
+
+    Args:
+        print_timing: Print timing of each module inside this Network
     """
     def __init__(self, *args, print_timing=False):
+        super().__init__()
         self._init_loc = get_init_str()
-
-        # Obtain the internal blocks
-        self.mods = _parse_to_list(*args)
-
-        # Check if the blocks are initialized, else create them
-        for i, b in enumerate(self.mods):
-            if isinstance(b, dict):
-                exclude_keys = ['type']
-                b_ex = {k: b[k] for k in set(list(b.keys())) - set(exclude_keys)}
-                self.mods[i] = Module.create(b['type'], **b_ex)
-
-        # Check validity of modules
-        for m in self.mods:
-            if not _is_valid_module(m):
-                raise TypeError(f"Argument is not a valid Module, type=\'{type(mod).__name__}\'.")
-
-        # Gather all the input and output signals of the internal blocks
-        all_in = set()
-        all_out = set()
-        [all_in.update(b.sig_in) for b in self.mods]
-        [all_out.update(b.sig_out) for b in self.mods]
-        in_unique = all_in - all_out
-
-        # Initialize the parent module, with correct inputs and outputs
-        super().__init__(list(in_unique), list(all_out))
-
+        self.mods = []  # Empty module list
+        self.append(*args)  # Append to module list
         self.print_timing = print_timing
 
-    def timefn(self, fn, prefix='Evaluation'):
+    def timefn(self, fn, name=None):
         start_t = time.time()
         fn()
         duration = time.time() - start_t
-        if duration > .5:
-            print(f"{prefix} {fn} took {time.time() - start_t} s")
+        if name is None:
+            name = f"{fn}"
+        if isinstance(self.print_timing, bool):
+            tmin = 0.0
+        else:
+            tmin = self.print_timing
+        if duration > tmin:
+            print(f"{name} took {time.time() - start_t} s")
 
     def response(self):
-        if self.print_timing:
-            [self.timefn(b.response, prefix='Response') for b in self.mods]
+        if self.print_timing is not False:
+            start_t = time.time()
+            [self.timefn(m.response, name=f"-- Response of \"{type(m).__name__}\"") for m in self.mods]
+            duration = time.time() - start_t
+            if isinstance(self.print_timing, bool):
+                tmin = 0.0
+            else:
+                tmin = self.print_timing
+            if duration > tmin:
+                print(f"-- TOTAL Response took {time.time() - start_t} s")
         else:
-            [b.response() for b in self.mods]
+            [m.response() for m in self.mods]
 
     def sensitivity(self):
-        if self.print_timing:
-            [self.timefn(b.sensitivity, 'Sensitivity') for b in reversed(self.mods)]
+        if self.print_timing is not False:
+            start_t = time.time()
+            [self.timefn(m.sensitivity, name=f"-- Sensitivity of \"{type(m).__name__}\"") for m in reversed(self.mods)]
+            duration = time.time() - start_t
+            if isinstance(self.print_timing, bool):
+                tmin = 0.0
+            else:
+                tmin = self.print_timing
+            if duration > tmin:
+                print(f"-- TOTAL Sensitivity took {time.time() - start_t} s")
         else:
-            [b.sensitivity() for b in reversed(self.mods)]
+            [m.sensitivity() for m in reversed(self.mods)]
 
     def reset(self):
-        [b.reset() for b in reversed(self.mods)]
+        [m.reset() for m in reversed(self.mods)]
 
     def _response(self, *args):
         pass  # Unused
@@ -636,13 +672,25 @@ class Network(Module):
     def __iter__(self):
         return iter(self.mods)
 
+    def __call__(self, *args):
+        return self.append(*args)
+
     def append(self, *newmods):
         modlist = _parse_to_list(*newmods)
+        if len(modlist) == 0:
+            return
 
         # Check if the blocks are initialized, else create them
+        for i, m in enumerate(modlist):
+            if isinstance(m, dict):
+                exclude_keys = ['type']
+                b_ex = {k: m[k] for k in set(list(m.keys())) - set(exclude_keys)}
+                modlist[i] = Module.create(m['type'], **b_ex)
+
+        # Check validity of modules
         for i, m in enumerate(modlist):
             if not _is_valid_module(m):
-                raise TypeError(f"Argument #{i} is not a valid module, type=\'{type(mod).__name__}\'.")
+                raise TypeError(f"Argument #{i} is not a valid module, type=\'{type(m).__name__}\'.")
 
         # Obtain the internal blocks
         self.mods.extend(modlist)
@@ -657,4 +705,4 @@ class Network(Module):
         self.sig_in = _parse_to_list(in_unique)
         self.sig_out = _parse_to_list(all_out)
 
-        return modlist[-1].sig_out[0] if len(modlist[-1].sig_out) == 1 else modlist[-1].sig_out  # Returns the output signal
+        return modlist[-1].sig_out[0] if len(modlist[-1].sig_out) == 1 else modlist[-1].sig_out

pymoto/modules/assembly.py

@@ -57,20 +57,21 @@ class AssembleGeneral(Module):
         self.bc = bc
         self.bcdiagval = np.max(element_matrix) if bcdiagval is None else bcdiagval
         if bc is not None:
-            self.bcselect = np.argwhere(np.bitwise_not(np.bitwise_or(np.isin(self.rows, self.bc),
-                                                                     np.isin(self.cols, self.bc)))).flatten()
-
-            self.rows = np.concatenate((self.rows[self.bcselect], self.bc))
-            self.cols = np.concatenate((self.cols[self.bcselect], self.bc))
+            bc_inds = np.bitwise_or(np.isin(self.rows, self.bc), np.isin(self.cols, self.bc))
+            self.bcselect = np.argwhere(np.bitwise_not(bc_inds)).flatten()
+            self.bcrows = np.concatenate((self.rows[self.bcselect], self.bc))
+            self.bccols = np.concatenate((self.cols[self.bcselect], self.bc))
         else:
             self.bcselect = None
+            self.bcrows = self.rows
+            self.bccols = self.cols
 
         self.add_constant = add_constant
 
     def _response(self, xscale: np.ndarray):
         nel = self.dofconn.shape[0]
         assert xscale.size == nel, f"Input vector wrong size ({xscale.size}), must be of size #nel ({nel})"
-        scaled_el = ((self.elmat.flatten()[np.newaxis]).T * xscale).flatten(order='F')
+        scaled_el = (self.elmat.flatten() * xscale[..., np.newaxis]).flatten()
 
         # Set boundary conditions
         if self.bc is not None:
@@ -80,7 +81,7 @@ class AssembleGeneral(Module):
             mat_values = scaled_el
 
         try:
-            mat = self.matrix_type((mat_values, (self.rows, self.cols)), shape=(self.n, self.n))
+            mat = self.matrix_type((mat_values, (self.bcrows, self.bccols)), shape=(self.n, self.n))
         except TypeError as e:
             raise type(e)(str(e) + "\n\tInvalid matrix_type={}. Either scipy.sparse.cscmatrix or "
                                    "scipy.sparse.csrmatrix are supported"
@@ -96,14 +97,16 @@ class AssembleGeneral(Module):
         if self.bc is not None:
             dgdmat[self.bc, :] = 0.0
             dgdmat[:, self.bc] = 0.0
+        dx = np.zeros_like(self.sig_in[0].state)
         if isinstance(dgdmat, np.ndarray):
-            dx = np.zeros_like(self.sig_in[0].state)
             for i in range(len(dx)):
                 indu, indv = np.meshgrid(self.dofconn[i], self.dofconn[i], indexing='ij')
-                dx[i] = einsum("ij,ij->", self.elmat, dgdmat[indu, indv])
-            return dx
+                dxi = einsum("ij,ij->", self.elmat, dgdmat[indu, indv])
+                dx[i] = np.real(dxi) if np.isrealobj(dx) else dxi
         elif isinstance(dgdmat, DyadCarrier):
-            return dgdmat.contract(self.elmat, self.dofconn, self.dofconn)
+            dxi = dgdmat.contract(self.elmat, self.dofconn, self.dofconn)
+            dx[:] = np.real(dxi) if np.isrealobj(dx) else dxi
+        return dx
 
 
 def get_B(dN_dx, voigt=True):
@@ -123,7 +126,7 @@ def get_B(dN_dx, voigt=True):
     """
     n_dim, n_shapefn = dN_dx.shape
     n_strains = int((n_dim * (n_dim+1))/2)  # Triangular number: ndim=3 -> nstrains = 3+2+1
-    B = np.zeros((n_strains, n_shapefn*n_dim))
+    B = np.zeros((n_strains, n_shapefn*n_dim), dtype=dN_dx.dtype)
     if n_dim == 1:
         for i in range(n_shapefn):
             B[i, 0] = dN_dx[i, 0]
@@ -222,7 +225,8 @@ class AssembleStiffness(AssembleGeneral):
         ndof = nnode*domain.dim
 
         # Element stiffness matrix
-        self.stiffness_element = np.zeros((ndof, ndof))
+        dtype = np.result_type(D, domain.element_size.dtype)
+        self.stiffness_element = np.zeros((ndof, ndof), dtype=dtype)
 
         # Numerical integration
         siz = domain.element_size

pymoto/modules/io.py

@@ -202,15 +202,16 @@ class PlotIter(FigModule):
         show (bool): Show the figure on the screen
         ylim: Provide y-axis limits for the plot
     """
-    def _prepare(self, ylim=None):
+    def _prepare(self, ylim=None, log_scale=False):
         self.minlim = 1e+200
         self.maxlim = -1e+200
         self.ylim = ylim
+        self.log_scale = log_scale
 
     def _response(self, *args):
         if not hasattr(self, 'ax'):
             self.ax = self.fig.add_subplot(111)
-            self.ax.set_yscale('linear')
+            self.ax.set_yscale('linear' if not self.log_scale else 'log')
             self.ax.set_xlabel("Iteration")
 
         if not hasattr(self, 'line'):
@@ -233,13 +234,24 @@ class PlotIter(FigModule):
             self.minlim = min(self.minlim, np.min(xadd))
             self.maxlim = max(self.maxlim, np.max(xadd))
 
-        dy = max((self.maxlim - self.minlim)*0.05, sys.float_info.min)
-
         self.ax.set_xlim([-0.5, self.iter+0.5])
         if self.ylim is not None:
             self.ax.set_ylim(self.ylim)
         elif np.isfinite(self.minlim) and np.isfinite(self.maxlim):
-            self.ax.set_ylim([self.minlim - dy, self.maxlim + dy])
+            if self.log_scale:
+                dy = (np.log10(self.maxlim) - np.log10(self.minlim))*0.05
+                ll = 10**(np.log10(self.minlim) - dy)
+                ul = 10**(np.log10(self.maxlim) + dy)
+            else:
+                dy = (self.maxlim - self.minlim)*0.05
+                ll = self.minlim - dy
+                ul = self.maxlim + dy
+
+            if ll == ul:
+                dy = abs(np.nextafter(abs(ll), 1) - abs(ll))
+                ll = ll - 1e5*dy
+                ul = ul + 1e5*dy
+            self.ax.set_ylim([ll, ul])
 
         self._update_fig()
 

pymoto/modules/linalg.py

@@ -268,7 +268,7 @@ class LinSolve(Module):
         if not isinstance(self.solver, LDAWrapper) and self.use_lda_solver:
             lda_kwargs = dict(hermitian=self.ishermitian, symmetric=self.issymmetric)
             if hasattr(self.solver, 'tol'):
-                lda_kwargs['tol'] = self.solver.tol * 2
+                lda_kwargs['tol'] = self.solver.tol * 5
             self.solver = LDAWrapper(self.solver, **lda_kwargs)
 
         # Update solver with new matrix
@@ -371,9 +371,11 @@ class EigenSolve(Module):
             Bqi = qi if B is None else B@qi
 
             normval = np.sqrt(qi @ Bqi)
-            avgval = np.average(qi)/normval
-
-            sf = np.sign(np.real(avgval)) / normval
+            sgn = 1 if np.real(np.average(qi)) >= 0 else -1
+            sf = sgn / normval
+            assert np.isfinite(sf)
+            if sf == 0.0:
+                warnings.warn(f"Scaling factor of mode {i} is zero!")
             qi *= sf
         return W, Q
 
@@ -423,8 +425,9 @@ class EigenSolve(Module):
         if self.is_hermitian:
             return spsla.eigsh(A, M=B, k=self.nmodes, OPinv=AinvOp, sigma=self.sigma, mode=self.mode)
         else:
-            # TODO
-            raise NotImplementedError('Non-Hermitian sparse matrix not supported')
+            if self.mode.lower() not in ['normal']:
+                raise NotImplementedError('Only `normal` mode can be selected for non-hermitian matrix')
+            return spsla.eigs(A, M=B, k=self.nmodes, OPinv=AinvOp, sigma=self.sigma)
 
     def _dense_sens(self, A, B, dW, dQ):
         """ Calculates all (eigenvector and eigenvalue) sensitivities for dense matrix """
@@ -465,17 +468,14 @@ class EigenSolve(Module):
             qi = Q[:, i]
             qmq = qi@qi if B is None else qi @ (B @ qi)
             dA_u = (dwi/qmq) * qi
-            if np.isrealobj(A):
-                dA += DyadCarrier([np.real(dA_u), -np.imag(dA_u)], [np.real(qi), np.imag(qi)])
-            else:
-                dA += DyadCarrier(dA_u, qi)
+            dAi = DyadCarrier(dA_u, qi)
+            dA += np.real(dAi) if np.isrealobj(A) else dAi
 
             if dB is not None:
                 dB_u = (wi*dwi/qmq) * qi
-                if np.isrealobj(B):
-                    dB -= DyadCarrier([np.real(dB_u), -np.imag(dB_u)], [np.real(qi), np.imag(qi)])
-                else:
-                    dB -= DyadCarrier(dB_u, qi)
+                dBi = DyadCarrier(dB_u, qi)
+                dB -= np.real(dBi) if np.isrealobj(B) else dBi
+
         return dA, dB
 
     def _sparse_eigvec_sens(self, A, B, dW, dQ):

pymoto/routines.py

@@ -10,10 +10,10 @@ from scipy.sparse import issparse
 def _has_signal_overlap(sig1: List[Signal], sig2: List[Signal]):
     for s1 in sig1:
         while isinstance(s1, SignalSlice):
-            s1 = s1.orig_signal
+            s1 = s1.base
         for s2 in sig2:
             while isinstance(s2, SignalSlice):
-                s2 = s2.orig_signal
+                s2 = s2.base
             if s1 == s2:
                 return True
     return False

pymoto/solvers/iterative.py

@@ -132,7 +132,7 @@ class GeometricMultigrid(Preconditioner):
         assert cycle.lower() in self._available_cycles, f"Cycle ({cycle}) is not available. Options are {self._available_cycles}"
         self.cycle = cycle
         self.inner_level = None if inner_level is None else inner_level
-        self.smoother = DampedJacobi(w=0.5) if smoother is None else None
+        self.smoother = DampedJacobi(w=0.5) if smoother is None else smoother
         self.smooth_steps = smooth_steps
         self.R = None
         self.sub_domain = DomainDefinition(domain.nelx // 2, domain.nely // 2, domain.nelz // 2,
@@ -299,7 +299,7 @@ class CG(LinearSolver):
         self.A = A
         self.preconditioner.update(A)
         if self.verbosity >= 1:
-            print(f"Preconditioner set up in {np.round(time.perf_counter() - tstart,3)}s")
+            print(f"CG Preconditioner set up in {np.round(time.perf_counter() - tstart, 3)}s")
 
     def solve(self, rhs, x0=None, trans='N'):
         if trans == 'N':
@@ -321,10 +321,18 @@ class CG(LinearSolver):
             x = x.reshape((x.size, 1))
 
         r = b - A@x
+        tval = np.linalg.norm(r, axis=0) / np.linalg.norm(b, axis=0)
+        if self.verbosity >= 2:
+            print(f"CG Initial (max) residual = {tval.max()}")
+
+        if tval.max() <= self.tol:
+            if self.verbosity >= 1:
+                print(f"CG Converged in 0 iterations and {np.round(time.perf_counter() - tstart, 3)}s, with final (max) residual {tval.max()}")
+
+            return x.flatten() if rhs.ndim == 1 else x
+
         z = self.preconditioner.solve(r, trans=trans)
         p = orth(z, normalize=True)
-        if self.verbosity >= 2:
-            print(f"Initial residual = {np.linalg.norm(r, axis=0) / np.linalg.norm(b, axis=0)}")
 
         for i in range(self.maxit):
             q = A @ p
@@ -333,16 +341,15 @@ class CG(LinearSolver):
             alpha = pq_inv @ (p.conj().T @ r)
 
             x += p @ alpha
-            if i % 50 == 0:  # Explicit restart
+            if i % self.restart == 0:  # Explicit restart
                 r = b - A@x
             else:
                 r -= q @ alpha
 
+            tval = np.linalg.norm(r, axis=0)/np.linalg.norm(b, axis=0)
             if self.verbosity >= 2:
-                print(f"i = {i}, residuals = {np.linalg.norm(r, axis=0) / np.linalg.norm(b, axis=0)}")
-
-            tval = np.linalg.norm(r)/np.linalg.norm(b)
-            if tval <= self.tol:
+                print(f"CG i = {i}, residuals = {tval}")
+            if tval.max() <= self.tol:
                 break
 
             z = self.preconditioner.solve(r, trans=trans)
@@ -350,12 +357,9 @@ class CG(LinearSolver):
             beta = -pq_inv @ (q.conj().T @ z)
             p = orth(z + p@beta, normalize=False)
 
-        if tval > self.tol:
-            warnings.warn(f'Maximum iterations ({self.maxit}) reached, with final residual {tval}')
+        if tval.max() > self.tol:
+            warnings.warn(f'CG Maximum iterations ({self.maxit}) reached, with final residuals {tval}')
         elif self.verbosity >= 1:
-            print(f"Converged in {i} iterations and {np.round(time.perf_counter() - tstart, 3)}s, with final residuals {np.linalg.norm(r, axis=0) / np.linalg.norm(b, axis=0)}")
+            print(f"CG Converged in {i} iterations and {np.round(time.perf_counter() - tstart, 3)}s, with final (max) residual {tval.max()}")
 
-        if rhs.ndim == 1:
-            return x.flatten()
-        else:
-            return x
+        return x.flatten() if rhs.ndim == 1 else x

pymoto/solvers/solvers.py

@@ -75,6 +75,17 @@ class LinearSolver:
         return np.linalg.norm(mat@x - b, axis=0) / np.linalg.norm(b, axis=0)
 
 
+def get_diagonal_indices(mat):
+    """ Get the row/column indices for entries in the matrix that are diagonal (has all zeros in its row and column) """
+    assert mat.ndim == 2, "Not a matrix"
+    n = min(*mat.shape)  # Matrix size
+    bmat = mat != 0
+    has_diag = bmat.diagonal()
+    nnz_rows = np.array(bmat.sum(axis=0)).flatten()[:n]
+    nnz_cols = np.array(bmat.sum(axis=1)).flatten()[:n]
+    return np.logical_and(has_diag, nnz_rows <= 1, nnz_cols <= 1)
+
+
 class LDAWrapper(LinearSolver):
     r""" Linear dependency aware solver (LDAS)
 
@@ -105,6 +116,8 @@ class LDAWrapper(LinearSolver):
         self.xadj_stored = []
         self.badj_stored = []
         self.A = None
+        self.diagonal_idx = []
+        self.nondiagonal_idx = slice(None)
         self._did_solve = False  # For debugging purposes
         self._last_rtol = 0.
         self.hermitian = hermitian
@@ -123,6 +136,9 @@ class LDAWrapper(LinearSolver):
             self.hermitian = matrix_is_hermitian(A)
 
         self.A = A
+        diags = get_diagonal_indices(A)
+        self.diagonal_idx = np.argwhere(diags).flatten()
+        self.nondiagonal_idx = np.argwhere(~diags).flatten()
         self.x_stored.clear()
         self.b_stored.clear()
         self.xadj_stored.clear()
@@ -130,6 +146,9 @@ class LDAWrapper(LinearSolver):
         self.solver.update(A)
 
     def _do_solve_1rhs(self, A, rhs, x_data, b_data, solve_fn, x0=None):
+        isel = self.nondiagonal_idx
+        idia = self.diagonal_idx
+
         dtype = np.result_type(A, rhs)
         if rhs.ndim == 1:
             rhs_loc = np.zeros((rhs.size, 1), dtype=dtype)
@@ -139,11 +158,16 @@ class LDAWrapper(LinearSolver):
             rhs_loc[:] = rhs
         sol = np.zeros_like(rhs_loc, dtype=dtype)
 
-        # Check linear dependencies in the rhs using modified Gram-Schmidt
+        # Diagonal part of the matrix
+        sol[idia, ...] = rhs_loc[idia, ...] / A.diagonal()[idia, None]
+        rhs_loc[idia, ...] = 0
+
+        # Non-diagonal part of the matrix
+        # Reconstruct using the database using modified Gram-Schmidt
         for (x, b) in zip(x_data, b_data):
             assert x.ndim == b.ndim == 1
-            assert x.size == b.size == rhs_loc.shape[0]
-            alpha = rhs_loc.T @ b.conj() / (b.conj() @ b)
+            # assert x.size == b.size == rhs_loc.shape[0]
+            alpha = rhs_loc[isel, ...].T @ b.conj() / (b.conj() @ b)
 
             rem_rhs = alpha * b[:, None]
             add_sol = alpha * x[:, None]
@@ -162,34 +186,41 @@ class LDAWrapper(LinearSolver):
                     warnings.warn('LDAS: Complex vector cannot be added to real solution')
                     continue
 
-            rhs_loc -= rem_rhs
-            sol += add_sol
+            rhs_loc[isel, ...] -= rem_rhs
+            sol[isel, ...] += add_sol
+
+        assert np.all(rhs_loc[idia, ...] == 0)
 
         # Check tolerance
-        self._last_rtol = np.ones(rhs_loc.shape[-1]) if len(x_data) == 0 else self.residual(A, sol, rhs if rhs.ndim > 1 else rhs.reshape(-1, 1))
+        self._last_rtol = self.residual(A, sol, rhs if rhs.ndim > 1 else rhs.reshape(-1, 1))
         self._did_solve = self._last_rtol > self.tol
+        # If tolerance too large, use the solver for new values
         if np.any(self._did_solve):
             if x0 is not None:
                 if x0.ndim == 1:
                     x0_loc = x0.reshape(-1, 1).copy()
                 else:
                     x0_loc = x0[..., self._did_solve].copy()
+                x0_loc[idia, ...] = 0
                 for x in x_data:
-                    beta = x0_loc.T @ x.conj() / (x.conj() @ x)
-                    x0_loc -= beta * x
+                    beta = x0_loc[isel, ...].T @ x.conj() / (x.conj() @ x)
+                    x0_loc[isel, ...] -= beta * x
             else:
                 x0_loc = None
 
-            # Calculate a new solution
+            # Calculate a new solution (for the vectors that have too high residual)
             xnew = solve_fn(rhs_loc[..., self._did_solve], x0_loc)
-            self.residual(A, xnew, rhs_loc[..., self._did_solve])
-            sol[..., self._did_solve] += xnew
+
+            if isinstance(isel, slice):
+                sol[isel, self._did_solve] += xnew[isel, ...]
+            else:
+                sol[np.ix_(isel, self._did_solve)] += xnew[isel, ...]
 
             # Add to database
             for i in range(xnew.shape[-1]):
                 # Remove all previous components that are already in the database (orthogonalize)
-                xadd = xnew[..., i]
-                badd = A @ xadd
+                xadd = xnew[isel, i]
+                badd = (A @ xnew[..., i])[isel, ...]
                 for x, b in zip(x_data, b_data):
                     beta = badd @ b.conj() / (b.conj() @ b)
                     badd -= beta * b

pymoto/solvers/sparse.py

@@ -140,6 +140,9 @@ class SolverSparsePardiso(LinearSolver):
         Returns:
             Solution of the system of linear equations, same shape as input b
         """
+        if b.dtype != np.float64:  # Only float64 is supported --> this is also done in _check_b, but fails for int8
+            warnings.warn(f"Array b's data type was converted from {b.dtype} to float64")
+            b = b.astype(np.float64)
         if trans == 'N':
             return self._pardiso_solver.solve(self.A, b)
         elif trans == 'T' or trans == 'H':
@@ -200,6 +203,13 @@ class SolverSparsePardiso(LinearSolver):
             if v != 0:
                 print(f"{i+1}: {v} ({k})")  # i+1 because of 1-based numbering
 
+    def __del__(self):
+        try:
+            self._pardiso_solver.free_memory(everything=True)
+        except ImportError:
+            # To prevent ImportError: sys.meta_path is None, Python is likely shutting down
+            pass
+
 
 # ------------------------------------ LU Solver -----------------------------------
 try:

pyMOTO-1.5.0.dist-info/RECORD

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