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

pymoto/core_objects.py

@@ -107,6 +107,9 @@ class Signal:
                 return
             if self.sensitivity is None:
                 self.sensitivity = copy.deepcopy(ds)
+            elif 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
@@ -183,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
 
@@ -200,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:" +
@@ -209,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:" +
@@ -218,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:" +
@@ -227,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.
@@ -405,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):
@@ -553,62 +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):
+    def timefn(self, fn, name=None):
         start_t = time.time()
         fn()
-        print(f"Evaluating {fn} took {time.time() - start_t} s")
+        duration = time.time() - start_t
+        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) 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):
-        [b.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:
+            [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
@@ -628,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)
@@ -649,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
@@ -325,29 +329,47 @@ class ElementOperation(Module):
 
     :math:`y_e = \mathbf{B} \mathbf{u}_e`
 
+    This module is the reverse of :py:class:`pymoto.NodalOperation`.
+
     Input Signal:
-        - ``u``: Nodal vector of size ``(n_dof_per_element * #nodes)``
+        - ``u``: Nodal vector of size ``(#dofs_per_node * #nodes)``
 
     Output Signal:
-        - ``y``: Elemental output data of size ``(..., #elements)``
+        - ``y``: Elemental output data of size ``(..., #elements)`` or ``(#dofs, ..., #elements)``
 
     Args:
         domain: The domain defining element and nodal connectivity
-        element_matrix: The element operator matrix :math:`\mathbf{B}` of size ``(..., n_dof_per_element)``
+        element_matrix: The element operator matrix :math:`\mathbf{B}` of size ``(..., #dofs_per_element)`` or ``(..., #nodes_per_element)``
     """
     def _prepare(self, domain: DomainDefinition, element_matrix: np.ndarray):
         if element_matrix.shape[-1] % domain.elemnodes != 0:
-            raise IndexError("Size of last dimension of element operator matrix is not compatible with mesh. "
-                             "Must be dividable by the number of nodes.")
-
-        ndof = element_matrix.shape[-1] // domain.elemnodes
-
+            raise IndexError(
+                f"Size of last dimension of element operator matrix ({element_matrix.shape[-1]}) is not compatible "
+                f"with mesh. Must be dividable by the number of nodes per element ({domain.elemnodes})."
+            )
+        self.domain = domain
         self.element_matrix = element_matrix
-        self.dofconn = domain.get_dofconnectivity(ndof)
-        self.usiz = ndof * domain.nnodes
+        self.dofconn = None
 
     def _response(self, u):
-        assert u.size == self.usiz
+        if u.size % self.domain.nnodes != 0:
+            raise IndexError(f"Size of input vector ({u.size}) does not match number of nodes ({self.domain.nnodes})")
+        ndof = u.size // self.domain.nnodes
+
+        if self.element_matrix.shape[-1] != self.domain.elemnodes * ndof:
+            # Initialize only after first call to response(), because the number of dofs may not yet be known
+            em = self.element_matrix.copy()
+            assert em.shape[-1] == self.domain.elemnodes, f"Size of element matrix must match #dofs_per_element ({ndof*self.domain.elemnodes}) or #nodes_per_element ({self.domain.elemnodes})."
+
+            # Element matrix is repeated for each dof
+            self.element_matrix = np.zeros((ndof, *self.element_matrix.shape[:-1], ndof * self.domain.elemnodes))
+            for i in range(ndof):
+                self.element_matrix[i, ..., i::ndof] = em
+
+        if self.dofconn is None:
+            self.dofconn = self.domain.get_dofconnectivity(ndof)
+
+        assert self.element_matrix.shape[-1] == ndof * self.domain.elemnodes
         return einsum('...k, lk -> ...l', self.element_matrix, u[self.dofconn], optimize=True)
 
     def _sensitivity(self, dy):
@@ -372,10 +394,10 @@ class Strain(ElementOperation):
     in case ``voigt = True``, for which :math:`\gamma_{xy}=2\epsilon_{xy}`.
 
     Input Signal:
-       - ``u``: Nodal vector of size ``(#dof per element * #nodes)``
+       - ``u``: Nodal vector of size ``(#dofs_per_node * #nodes)``
 
     Output Signal:
-       - ``e``: Strain matrix of size ``(#strains per element, #elements)``
+       - ``e``: Strain matrix of size ``(#strains_per_element, #elements)``
 
     Args:
         domain: The domain defining element and nodal connectivity
@@ -408,10 +430,10 @@ class Stress(Strain):
     """ Calculate the average stresses per element
 
     Input Signal:
-       - ``u``: Nodal vector of size ``(#dof per element * #nodes)``
+       - ``u``: Nodal vector of size ``(#dofs_per_node * #nodes)``
 
     Output Signal:
-       - ``s``: Stress matrix of size ``(#stresses per element, #elements)``
+       - ``s``: Stress matrix of size ``(#stresses_per_element, #elements)``
 
     Args:
         domain: The domain defining element and nodal connectivity
@@ -431,3 +453,99 @@ class Stress(Strain):
         if domain.dim == 2:
             D *= domain.element_size[2]
         self.element_matrix = D @ self.element_matrix
+
+
+class ElementAverage(ElementOperation):
+    r""" Determine average value in element of input nodal values
+
+    Input Signal:
+       - ``v``: Nodal vector of size ``(#dofs_per_node * #nodes)``
+
+    Output Signal:
+       - ``v_el``: Elemental vector of size ``(#elements)`` or ``(#dofs, #elements)`` if ``#dofs_per_node>1``
+
+    Args:
+        domain: The domain defining element and nodal connectivity
+    """
+    def _prepare(self, domain: DomainDefinition):
+        shapefuns = domain.eval_shape_fun(pos=np.array([0, 0, 0]))
+        super()._prepare(domain, shapefuns)
+
+
+class NodalOperation(Module):
+    r""" Generic module for nodal operations based on elemental information
+
+    :math:`u_e = \mathbf{A} x_e`
+
+    This module is the reverse of :py:class:`pymoto.ElementOperation`.
+
+    Input Signal:
+        - ``x``: Elemental vector of size ``(#elements)``
+
+    Output Signal:
+        - ``u``: nodal output data of size ``(..., #dofs_per_node * #nodes)``
+
+    Args:
+        domain: The domain defining element and nodal connectivity
+        element_matrix: The element operator matrix :math:`\mathbf{A}` of size ``(..., #dofs_per_element)``
+    """
+    def _prepare(self, domain: DomainDefinition, element_matrix: np.ndarray):
+        if element_matrix.shape[-1] % domain.elemnodes != 0:
+            raise IndexError("Size of last dimension of element operator matrix is not compatible with mesh. "
+                             "Must be dividable by the number of nodes.")
+
+        ndof = element_matrix.shape[-1] // domain.elemnodes
+
+        self.element_matrix = element_matrix
+        self.dofconn = domain.get_dofconnectivity(ndof)
+        self.ndofs = ndof*domain.nnodes
+
+    def _response(self, x):
+        dofs_el = einsum('...k, ...l -> lk', self.element_matrix, x, optimize=True)
+        dofs = np.zeros(self.ndofs)
+        np.add.at(dofs, self.dofconn, dofs_el)
+        return dofs
+
+    def _sensitivity(self, dx):
+        return einsum('...k, lk -> ...l', self.element_matrix, dx[self.dofconn], optimize=True)
+
+
+class ThermoMechanical(NodalOperation):
+    r""" Determine equivalent thermo-mechanical load from design vector and elemental temperature difference
+
+    :math:`f_thermal = \mathbf{A} (x*t_delta)_e`
+
+    Input Signal:
+        - ``x*t_delta``: Elemental vector of size ``(#elements)`` containing elemental densities multiplied by
+                         elemental temperature difference
+
+    Output Signal:
+        - ``f_thermal``: nodal equivalent thermo-mechanical load of size ``(#dofs_per_node * #nodes)``
+
+    Args:
+        domain: The domain defining element and nodal connectivity
+        e_modulus (optional): Young's modulus
+        poisson_ratio (optional): Poisson ratio
+        alpha (optional): Coefficient of thermal expansion
+        plane (optional): Plane 'strain' or 'stress'
+    """
+    def _prepare(self, domain: DomainDefinition, e_modulus: float = 1.0, poisson_ratio: float = 0.3, alpha: float = 1e-6, plane: str = 'strain'):
+        dim = domain.dim
+        D = get_D(e_modulus, poisson_ratio, '3d' if dim == 3 else plane.lower())
+        if dim == 2:
+            Phi = np.array([1, 1, 0])
+            D *= domain.element_size[2]
+        elif dim == 3:
+            Phi = np.array([1, 1, 1, 0, 0, 0])
+
+        # Numerical integration
+        BDPhi = np.zeros(domain.elemnodes * dim)
+        siz = domain.element_size
+        w = np.prod(siz[:domain.dim] / 2)
+        for n in domain.node_numbering:
+            pos = n * (siz / 2) / np.sqrt(3)  # Sampling point
+            dN_dx = domain.eval_shape_fun_der(pos)
+            B = get_B(dN_dx)
+            BDPhi += w * B.T @ D @ Phi  # Add contribution
+
+        super()._prepare(domain, alpha*BDPhi)

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()
 
@@ -255,7 +267,7 @@ class WriteToVTI(Module):
     accepted, which get the suffixed as ``_00``.
 
     Input Signals:
-      - ``*args`` (`numpy.ndarary`): Vectors to write to VTI. The signal tags are used as name.
+      - ``*args`` (`numpy.ndarray`): Vectors to write to VTI. The signal tags are used as name.
 
     Args:
         domain: The domain layout
@@ -282,3 +294,65 @@ class WriteToVTI(Module):
             filen = pth[0] + '.{0:04d}'.format(self.iter) + pth[1]
         self.domain.write_to_vti(data, filename=filen, scale=self.scale)
         self.iter += 1
+
+
+class ScalarToFile(Module):
+    """ Writes iteration data to a log file
+
+    This function can also handle small vectors of scalars, i.e. eigenfrequencies or multiple constraints.
+
+    Input Signals:
+      - ``*args`` (`Numeric` or `np.ndarray`): Values to write to file. The signal tags are used as name.
+
+    Args:
+        saveto: Location to save the log file, supports .txt or .csv
+        fmt (optional): Value format (e.g. 'e', 'f', '.3e', '.5g', '.3f')
+        separator (optional): Value separator, .csv files will automatically use a comma
+    """
+    def _prepare(self, saveto: str, fmt: str = '.10e', separator: str = '\t'):
+        self.saveto = saveto
+        Path(saveto).parent.mkdir(parents=True, exist_ok=True)
+        self.iter = 0
+
+        # Test the format
+        3.14.__format__(fmt)
+        self.format = fmt
+
+        self.separator = "," if ".csv" in self.saveto else separator
+
+    def _response(self, *args):
+        tags = [] if self.iter == 0 else None
+
+        # Add iteration as first column
+        dat = [self.iter.__format__('d')]
+        if tags is not None:
+            tags.append('Iteration')
+
+        # Add all signals
+        for s in self.sig_in:
+            if np.size(np.asarray(s.state)) > 1:
+                it = np.nditer(s.state, flags=['multi_index'])
+                while not it.finished:
+                    dat.append(it.value.__format__(self.format))
+                    if tags is not None:
+                        tags.append(f"{s.tag}{list(it.multi_index)}")
+                    it.iternext()
+            else:
+                dat.append(s.state.__format__(self.format))
+                if tags is not None:
+                    tags.append(s.tag)
+
+        # Write to file
+        if tags is not None:
+            assert len(tags) == len(dat)
+            with open(self.saveto, "w+") as f:
+                # Write header line
+                f.write(self.separator.join(tags))
+                f.write("\n")
+
+        with open(self.saveto, "a+") as f:
+            # Write data
+            f.write(self.separator.join(dat))
+            f.write("\n")
+
+        self.iter += 1