weac 2.6.1__py3-none-any.whl → 2.6.3__py3-none-any.whl

weac/__init__.py

@@ -6,16 +6,12 @@ dry-snow slab avalanche release.
 """
 
 # Module imports
-from weac.layered import Layered
-from weac.inverse import Inverse
 from weac import plot
+from weac.inverse import Inverse
+from weac.layered import Layered
 
 # Version
-__version__ = '2.6.1'
+__version__ = "2.6.3"
 
 # Public names
-__all__ = [
-    'Layered',
-    'Inverse',
-    'plot'
-]
+__all__ = ["Layered", "Inverse", "plot"]

weac/eigensystem.py

@@ -90,7 +90,7 @@ class Eigensystem:
         Describes the stiffnesses of weak-layer and slab.
     """
 
-    def __init__(self, system='pst-', touchdown=False):
+    def __init__(self, system="pst-", touchdown=False):
         """
         Initialize eigensystem with user input.
 
@@ -108,54 +108,51 @@ class Eigensystem:
             to one layer. Default is [[240, 200], ].
         """
         # Assign global attributes
-        self.g = 9810           # Gravitaiton (mm/s^2)
-        self.lski = 1000        # Effective out-of-plane length of skis (mm)
-        self.tol = 1e-3         # Relative Romberg integration tolerance
-        self.system = system    # 'pst-', '-pst', 'vpst-', '-vpst', 'skier', 'skiers'
+        self.g = 9810  # Gravitaiton (mm/s^2)
+        self.lski = 1000  # Effective out-of-plane length of skis (mm)
+        self.tol = 1e-3  # Relative Romberg integration tolerance
+        self.system = system  # 'pst-', '-pst', 'vpst-', '-vpst', 'skier', 'skiers'
 
         # Initialize weak-layer attributes that will be filled later
-        self.weak = False           # Weak-layer properties dictionary
-        self.t = False              # Weak-layer thickness (mm)
-        self.kn = False             # Weak-layer compressive stiffness
-        self.kt = False             # Weak-layer shear stiffness
+        self.weak = False  # Weak-layer properties dictionary
+        self.t = False  # Weak-layer thickness (mm)
+        self.kn = False  # Weak-layer compressive stiffness
+        self.kt = False  # Weak-layer shear stiffness
 
         # Initialize slab attributes
-        self.p = 0                  # Surface line load (N/mm)
-        self.slab = False           # Slab properties dictionary
-        self.k = False              # Slab shear correction factor
-        self.h = False              # Total slab height (mm)
-        self.zs = False             # Z-coordinate of slab center of gravity (mm)
-        self.phi = False            # Slab inclination (°)
-        self.A11 = False            # Slab extensional stiffness
-        self.B11 = False            # Slab bending-extension coupling stiffness
-        self.D11 = False            # Slab bending stiffness
-        self.kA55 = False           # Slab shear stiffness
-        self.K0 = False             # Stiffness determinant
+        self.p = 0  # Surface line load (N/mm)
+        self.slab = False  # Slab properties dictionary
+        self.k = False  # Slab shear correction factor
+        self.h = False  # Total slab height (mm)
+        self.zs = False  # Z-coordinate of slab center of gravity (mm)
+        self.phi = False  # Slab inclination (°)
+        self.A11 = False  # Slab extensional stiffness
+        self.B11 = False  # Slab bending-extension coupling stiffness
+        self.D11 = False  # Slab bending stiffness
+        self.kA55 = False  # Slab shear stiffness
+        self.K0 = False  # Stiffness determinant
 
         # Inizialize eigensystem attributes
-        self.ewC = False            # Complex eigenvalues
-        self.ewR = False            # Real eigenvalues
-        self.evC = False            # Complex eigenvectors
-        self.evR = False            # Real eigenvectors
-        self.sC = False             # Stability shift of complex eigenvalues
-        self.sR = False             # Stability shift of real eigenvalues
+        self.ewC = False  # Complex eigenvalues
+        self.ewR = False  # Real eigenvalues
+        self.evC = False  # Complex eigenvectors
+        self.evR = False  # Real eigenvectors
+        self.sC = False  # Stability shift of complex eigenvalues
+        self.sR = False  # Stability shift of real eigenvalues
 
         # Initialize touchdown attributes
         self.touchdown = touchdown  # Flag whether touchdown is possible
-        self.a = False              # Cracklength
-        self.tc = False             # Weak-layer collapse height (mm)
-        self.ratio = False          # Stiffness ratio of collapsed to uncollapsed weak-layer
-        self.betaU = False          # Ratio of slab to bedding stiffness (uncollapsed)
-        self.betaC = False          # Ratio of slab to bedding stiffness (collapsed)
-        self.mode = False           # Touchdown-mode can be either A, B, C or D
-        self.td = False             # Touchdown length
+        self.a = False  # Cracklength
+        self.tc = False  # Weak-layer collapse height (mm)
+        self.ratio = False  # Stiffness ratio of collapsed to uncollapsed weak-layer
+        self.betaU = False  # Ratio of slab to bedding stiffness (uncollapsed)
+        self.betaC = False  # Ratio of slab to bedding stiffness (collapsed)
+        self.mode = False  # Touchdown-mode can be either A, B, C or D
+        self.td = False  # Touchdown length
 
     def set_foundation_properties(
-            self,
-            t: float = 30.0,
-            E: float = 0.25,
-            nu: float = 0.25,
-            update: bool = False):
+        self, t: float = 30.0, E: float = 0.25, nu: float = 0.25, update: bool = False
+    ):
         """
         Set material properties and geometry of foundation (weak layer).
 
@@ -175,20 +172,19 @@ class Eigensystem:
             foundation properties have changed.
         """
         # Geometry
-        self.t = t              # Weak-layer thickness (mm)
+        self.t = t  # Weak-layer thickness (mm)
 
         # Material properties
         self.weak = {
-            'nu': nu,           # Poisson's ratio (-)
-            'E': E              # Young's modulus (MPa)
+            "nu": nu,  # Poisson's ratio (-)
+            "E": E,  # Young's modulus (MPa)
         }
 
         # Recalculate the fundamental system after properties have changed
         if update:
             self.calc_fundamental_system()
 
-    def set_beam_properties(self, layers, C0=6.5, C1=4.4,
-                            nu=0.25, update=False):
+    def set_beam_properties(self, layers, C0=6.5, C1=4.4, nu=0.25, update=False):
         """
         Set material and properties geometry of beam (slab).
 
@@ -220,9 +216,9 @@ class Eigensystem:
             E = bergfeld(layers[:, 0], C0=C0, C1=C1)  # Young's modulus
 
         # Derive other elastic properties
-        nu = nu*np.ones(layers.shape[0])         # Global poisson's ratio
-        G = E/(2*(1 + nu))                       # Shear modulus
-        self.k = 5/6                             # Shear correction factor
+        nu = nu * np.ones(layers.shape[0])  # Global poisson's ratio
+        G = E / (2 * (1 + nu))  # Shear modulus
+        self.k = 5 / 6  # Shear correction factor
 
         # Compute total slab thickness and center of gravity
         self.h, self.zs = calc_center_of_gravity(layers)
@@ -257,12 +253,12 @@ class Eigensystem:
     def calc_foundation_stiffness(self):
         """Compute foundation normal and shear stiffness."""
         # Elastic moduli (MPa) under plane-strain conditions
-        G = self.weak['E']/(2*(1 + self.weak['nu']))    # Shear modulus
-        E = self.weak['E']/(1 - self.weak['nu']**2)     # Young's modulus
+        G = self.weak["E"] / (2 * (1 + self.weak["nu"]))  # Shear modulus
+        E = self.weak["E"] / (1 - self.weak["nu"] ** 2)  # Young's modulus
 
         # Foundation (weak layer) stiffnesses (N/mm^3)
-        self.kn = E/self.t                              # Normal stiffness
-        self.kt = G/self.t                              # Shear stiffness
+        self.kn = E / self.t  # Normal stiffness
+        self.kt = G / self.t  # Shear stiffness
 
     def get_ply_coordinates(self):
         """
@@ -278,7 +274,7 @@ class Eigensystem:
         # Get list of ply (layer) thicknesses and prepend 0
         t = np.concatenate(([0], self.slab[:, 1]))
         # Calculate and return ply z-coordiantes
-        return np.cumsum(t) - self.h/2
+        return np.cumsum(t) - self.h / 2
 
     def calc_laminate_stiffness_matrix(self):
         """
@@ -293,16 +289,16 @@ class Eigensystem:
         # Add layerwise contributions
         for i in range(len(z) - 1):
             E, G, nu = self.slab[i, 2:5]
-            A11 = A11 + E/(1 - nu**2)*(z[i+1] - z[i])
-            B11 = B11 + 1/2*E/(1 - nu**2)*(z[i+1]**2 - z[i]**2)
-            D11 = D11 + 1/3*E/(1 - nu**2)*(z[i+1]**3 - z[i]**3)
-            kA55 = kA55 + self.k*G*(z[i+1] - z[i])
+            A11 = A11 + E / (1 - nu**2) * (z[i + 1] - z[i])
+            B11 = B11 + 1 / 2 * E / (1 - nu**2) * (z[i + 1] ** 2 - z[i] ** 2)
+            D11 = D11 + 1 / 3 * E / (1 - nu**2) * (z[i + 1] ** 3 - z[i] ** 3)
+            kA55 = kA55 + self.k * G * (z[i + 1] - z[i])
 
         self.A11 = A11
         self.B11 = B11
         self.D11 = D11
         self.kA55 = kA55
-        self.K0 = B11**2 - A11*D11
+        self.K0 = B11**2 - A11 * D11
 
     def calc_system_matrix(self):
         """
@@ -321,29 +317,39 @@ class Eigensystem:
         kt = self.kt
 
         # Abbreviations (MIT t/2 im GGW, MIT w' in Kinematik)
-        K21 = kt*(-2*self.D11 + self.B11*(self.h + self.t))/(2*self.K0)
-        K24 = (2*self.D11*kt*self.t
-               - self.B11*kt*self.t*(self.h + self.t)
-               + 4*self.B11*self.kA55)/(4*self.K0)
-        K25 = (-2*self.D11*self.h*kt
-               + self.B11*self.h*kt*(self.h + self.t)
-               + 4*self.B11*self.kA55)/(4*self.K0)
-        K43 = kn/self.kA55
-        K61 = kt*(2*self.B11 - self.A11*(self.h + self.t))/(2*self.K0)
-        K64 = (-2*self.B11*kt*self.t
-               + self.A11*kt*self.t*(self.h+self.t)
-               - 4*self.A11*self.kA55)/(4*self.K0)
-        K65 = (2*self.B11*self.h*kt
-               - self.A11*self.h*kt*(self.h+self.t)
-               - 4*self.A11*self.kA55)/(4*self.K0)
+        K21 = kt * (-2 * self.D11 + self.B11 * (self.h + self.t)) / (2 * self.K0)
+        K24 = (
+            2 * self.D11 * kt * self.t
+            - self.B11 * kt * self.t * (self.h + self.t)
+            + 4 * self.B11 * self.kA55
+        ) / (4 * self.K0)
+        K25 = (
+            -2 * self.D11 * self.h * kt
+            + self.B11 * self.h * kt * (self.h + self.t)
+            + 4 * self.B11 * self.kA55
+        ) / (4 * self.K0)
+        K43 = kn / self.kA55
+        K61 = kt * (2 * self.B11 - self.A11 * (self.h + self.t)) / (2 * self.K0)
+        K64 = (
+            -2 * self.B11 * kt * self.t
+            + self.A11 * kt * self.t * (self.h + self.t)
+            - 4 * self.A11 * self.kA55
+        ) / (4 * self.K0)
+        K65 = (
+            2 * self.B11 * self.h * kt
+            - self.A11 * self.h * kt * (self.h + self.t)
+            - 4 * self.A11 * self.kA55
+        ) / (4 * self.K0)
 
         # System matrix
-        K = [[0,    1,    0,    0,    0,    0],
-             [K21,  0,    0,  K24,  K25,    0],
-             [0,    0,    0,    1,    0,    0],
-             [0,    0,  K43,    0,    0,   -1],
-             [0,    0,    0,    0,    0,    1],
-             [K61,  0,    0,  K64,  K65,    0]]
+        K = [
+            [0, 1, 0, 0, 0, 0],
+            [K21, 0, 0, K24, K25, 0],
+            [0, 0, 0, 1, 0, 0],
+            [0, 0, K43, 0, 0, -1],
+            [0, 0, 0, 0, 0, 1],
+            [K61, 0, 0, K64, K65, 0],
+        ]
 
         return np.array(K)
 
@@ -367,16 +373,28 @@ class Eigensystem:
         """
         qn, qt = self.get_weight_load(phi)
         pn, pt = self.get_surface_load(phi)
-        return np.array([
-            [0],
-            [(self.B11*(self.h*pt - 2*qt*self.zs)
-              + 2*self.D11*(qt + pt))/(2*self.K0)],
-            [0],
-            [-(qn + pn)/self.kA55],
-            [0],
-            [-(self.A11*(self.h*pt - 2*qt*self.zs)
-               + 2*self.B11*(qt + pt))/(2*self.K0)]
-        ])
+        return np.array(
+            [
+                [0],
+                [
+                    (
+                        self.B11 * (self.h * pt - 2 * qt * self.zs)
+                        + 2 * self.D11 * (qt + pt)
+                    )
+                    / (2 * self.K0)
+                ],
+                [0],
+                [-(qn + pn) / self.kA55],
+                [0],
+                [
+                    -(
+                        self.A11 * (self.h * pt - 2 * qt * self.zs)
+                        + 2 * self.B11 * (qt + pt)
+                    )
+                    / (2 * self.K0)
+                ],
+            ]
+        )
 
     def calc_eigensystem(self):
         """Calculate eigenvalues and eigenvectors of the system matrix."""
@@ -384,7 +402,7 @@ class Eigensystem:
         ew, ev = np.linalg.eig(self.calc_system_matrix())
         # Classify real and complex eigenvalues
         real = (ew.imag == 0) & (ew.real != 0)  # real eigenvalues
-        cmplx = ew.imag > 0                   # positive complex conjugates
+        cmplx = ew.imag > 0  # positive complex conjugates
         # Eigenvalues
         self.ewC = ew[cmplx]
         self.ewR = ew[real].real
@@ -418,13 +436,13 @@ class Eigensystem:
             Line load (N/mm) at center of gravity in tangential direction.
         """
         # Convert units
-        phi = np.deg2rad(phi)                   # Convert inclination to rad
-        rho = self.slab[:, 0]*1e-12             # Convert density to t/mm^3
+        phi = np.deg2rad(phi)  # Convert inclination to rad
+        rho = self.slab[:, 0] * 1e-12  # Convert density to t/mm^3
         # Sum up layer weight loads
-        q = sum(rho*self.g*self.slab[:, 1])     # Line load (N/mm)
+        q = sum(rho * self.g * self.slab[:, 1])  # Line load (N/mm)
         # Split into components
-        qn = q*np.cos(phi)                      # Normal direction
-        qt = -q*np.sin(phi)                     # Tangential direction
+        qn = q * np.cos(phi)  # Normal direction
+        qt = -q * np.sin(phi)  # Tangential direction
 
         return qn, qt
 
@@ -445,10 +463,10 @@ class Eigensystem:
             Surface line load (N/mm) in tangential direction.
         """
         # Convert units
-        phi = np.deg2rad(phi)                   # Convert inclination to rad
+        phi = np.deg2rad(phi)  # Convert inclination to rad
         # Split into components
-        pn = self.p*np.cos(phi)                 # Normal direction
-        pt = -self.p*np.sin(phi)                # Tangential direction
+        pn = self.p * np.cos(phi)  # Normal direction
+        pt = -self.p * np.sin(phi)  # Tangential direction
 
         return pn, pt
 
@@ -470,10 +488,10 @@ class Eigensystem:
         Ft : float
             Skier load (N) in tangential direction.
         """
-        phi = np.deg2rad(phi)                   # Convert inclination to rad
-        F = 1e-3*np.array(m)*self.g/self.lski   # Total skier load (N)
-        Fn = F*np.cos(phi)                      # Normal skier load (N)
-        Ft = -F*np.sin(phi)                     # Tangential skier load (N)
+        phi = np.deg2rad(phi)  # Convert inclination to rad
+        F = 1e-3 * np.array(m) * self.g / self.lski  # Total skier load (N)
+        Fn = F * np.cos(phi)  # Normal skier load (N)
+        Ft = -F * np.sin(phi)  # Tangential skier load (N)
 
         return Fn, Ft
 
@@ -497,30 +515,41 @@ class Eigensystem:
             Complementary solution matrix (6x6) at position x.
         """
         if bed:
-            zh = np.concatenate([
-                # Real
-                self.evR*np.exp(self.ewR*(x + l*self.sR)),
-                # Complex
-                np.exp(self.ewC.real*(x + l*self.sC))*(
-                       self.evC.real*np.cos(self.ewC.imag*x)
-                       - self.evC.imag*np.sin(self.ewC.imag*x)),
-                # Complex
-                np.exp(self.ewC.real*(x + l*self.sC))*(
-                       self.evC.imag*np.cos(self.ewC.imag*x)
-                       + self.evC.real*np.sin(self.ewC.imag*x))], axis=1)
+            zh = np.concatenate(
+                [
+                    # Real
+                    self.evR * np.exp(self.ewR * (x + l * self.sR)),
+                    # Complex
+                    np.exp(self.ewC.real * (x + l * self.sC))
+                    * (
+                        self.evC.real * np.cos(self.ewC.imag * x)
+                        - self.evC.imag * np.sin(self.ewC.imag * x)
+                    ),
+                    # Complex
+                    np.exp(self.ewC.real * (x + l * self.sC))
+                    * (
+                        self.evC.imag * np.cos(self.ewC.imag * x)
+                        + self.evC.real * np.sin(self.ewC.imag * x)
+                    ),
+                ],
+                axis=1,
+            )
         else:
             # Abbreviations
-            H14 = 3*self.B11/self.A11*x**2
-            H24 = 6*self.B11/self.A11*x
-            H54 = -3*x**2 + 6*self.K0/(self.A11*self.kA55)
+            H14 = 3 * self.B11 / self.A11 * x**2
+            H24 = 6 * self.B11 / self.A11 * x
+            H54 = -3 * x**2 + 6 * self.K0 / (self.A11 * self.kA55)
             # Complementary solution matrix of free segments
             zh = np.array(
-                [[0,      0,      0,    H14,      1,      x],
-                 [0,      0,      0,    H24,      0,      1],
-                 [1,      x,   x**2,   x**3,      0,      0],
-                 [0,      1,    2*x, 3*x**2,      0,      0],
-                 [0,     -1,   -2*x,    H54,      0,      0],
-                 [0,      0,     -2,   -6*x,      0,      0]])
+                [
+                    [0, 0, 0, H14, 1, x],
+                    [0, 0, 0, H24, 0, 1],
+                    [1, x, x**2, x**3, 0, 0],
+                    [0, 1, 2 * x, 3 * x**2, 0, 0],
+                    [0, -1, -2 * x, H54, 0, 0],
+                    [0, 0, -2, -6 * x, 0, 0],
+                ]
+            )
 
         return zh
 
@@ -564,23 +593,34 @@ class Eigensystem:
 
         # Assemble particular integral vectors
         if bed:
-            zp = np.array([
-                [(qt + pt)/kt + h*qt*(h + t - 2*zs)/(4*kA55)
-                    + h*pt*(2*h + t)/(4*kA55)],
-                [0],
-                [(qn + pn)/kn],
-                [0],
-                [-(qt*(h + t - 2*zs) + pt*(2*h + t))/(2*kA55)],
-                [0]])
+            zp = np.array(
+                [
+                    [
+                        (qt + pt) / kt
+                        + h * qt * (h + t - 2 * zs) / (4 * kA55)
+                        + h * pt * (2 * h + t) / (4 * kA55)
+                    ],
+                    [0],
+                    [(qn + pn) / kn],
+                    [0],
+                    [-(qt * (h + t - 2 * zs) + pt * (2 * h + t)) / (2 * kA55)],
+                    [0],
+                ]
+            )
         else:
-            zp = np.array([
-                [(-3*(qt + pt)/A11 - B11*(qn + pn)*x/K0)/6*x**2],
-                [(-2*(qt + pt)/A11 - B11*(qn + pn)*x/K0)/2*x],
-                [-A11*(qn + pn)*x**4/(24*K0)],
-                [-A11*(qn + pn)*x**3/(6*K0)],
-                [A11*(qn + pn)*x**3/(6*K0)
-                 + ((zs - B11/A11)*qt - h*pt/2 - (qn + pn)*x)/kA55],
-                [(qn + pn)*(A11*x**2/(2*K0) - 1/kA55)]])
+            zp = np.array(
+                [
+                    [(-3 * (qt + pt) / A11 - B11 * (qn + pn) * x / K0) / 6 * x**2],
+                    [(-2 * (qt + pt) / A11 - B11 * (qn + pn) * x / K0) / 2 * x],
+                    [-A11 * (qn + pn) * x**4 / (24 * K0)],
+                    [-A11 * (qn + pn) * x**3 / (6 * K0)],
+                    [
+                        A11 * (qn + pn) * x**3 / (6 * K0)
+                        + ((zs - B11 / A11) * qt - h * pt / 2 - (qn + pn) * x) / kA55
+                    ],
+                    [(qn + pn) * (A11 * x**2 / (2 * K0) - 1 / kA55)],
+                ]
+            )
 
         return zp
 
@@ -608,9 +648,10 @@ class Eigensystem:
             Solution vector (6xN) at position x.
         """
         if isinstance(x, (list, tuple, np.ndarray)):
-            z = np.concatenate([
-                np.dot(self.zh(xi, l, bed), C)
-                + self.zp(xi, phi, bed) for xi in x], axis=1)
+            z = np.concatenate(
+                [np.dot(self.zh(xi, l, bed), C) + self.zp(xi, phi, bed) for xi in x],
+                axis=1,
+            )
         else:
             z = np.dot(self.zh(x, l, bed), C) + self.zp(x, phi, bed)
 

weac/inverse.py

@@ -2,15 +2,13 @@
 # pylint: disable=invalid-name
 
 # Project imports
-from weac.mixins import FieldQuantitiesMixin
-from weac.mixins import SolutionMixin
-from weac.mixins import AnalysisMixin
-from weac.mixins import OutputMixin
 from weac.eigensystem import Eigensystem
+from weac.mixins import AnalysisMixin, FieldQuantitiesMixin, OutputMixin, SolutionMixin
 
 
-class Inverse(FieldQuantitiesMixin, SolutionMixin, AnalysisMixin,
-              OutputMixin, Eigensystem):
+class Inverse(
+    FieldQuantitiesMixin, SolutionMixin, AnalysisMixin, OutputMixin, Eigensystem
+):
     """
     Fit the elastic properties of the layers of a snowpack.
 
@@ -25,8 +23,7 @@ class Inverse(FieldQuantitiesMixin, SolutionMixin, AnalysisMixin,
     analysis from AnalysisMixin().
     """
 
-    def __init__(
-            self, system='pst-', layers=None, parameters=(6.0, 4.6, 0.25)):
+    def __init__(self, system="pst-", layers=None, parameters=(6.0, 4.6, 0.25)):
         """
         Initialize model with user input.
 

weac/layered.py

@@ -1,16 +1,25 @@
 """Class for the elastic analysis of layered snow slabs."""
 
 # Project imports
-from weac.mixins import FieldQuantitiesMixin
-from weac.mixins import SlabContactMixin
-from weac.mixins import SolutionMixin
-from weac.mixins import AnalysisMixin
-from weac.mixins import OutputMixin
+
 from weac.eigensystem import Eigensystem
+from weac.mixins import (
+    AnalysisMixin,
+    FieldQuantitiesMixin,
+    OutputMixin,
+    SlabContactMixin,
+    SolutionMixin,
+)
 
 
-class Layered(FieldQuantitiesMixin, SlabContactMixin, SolutionMixin,
-              AnalysisMixin, OutputMixin, Eigensystem):
+class Layered(
+    FieldQuantitiesMixin,
+    SlabContactMixin,
+    SolutionMixin,
+    AnalysisMixin,
+    OutputMixin,
+    Eigensystem,
+):
     """
     Layered beam on elastic foundation model application interface.
 
@@ -21,7 +30,7 @@ class Layered(FieldQuantitiesMixin, SlabContactMixin, SolutionMixin,
     analysis from AnalysisMixin().
     """
 
-    def __init__(self, system='pst-', layers=None, touchdown=False):
+    def __init__(self, system="pst-", layers=None, touchdown=False):
         """
         Initialize model with user input.
 
@@ -44,6 +53,12 @@ class Layered(FieldQuantitiesMixin, SlabContactMixin, SolutionMixin,
         super().__init__(system=system, touchdown=touchdown)
 
         # Set material properties and set up model
-        self.set_beam_properties(layers if layers else [[240, 200], ])
+        self.set_beam_properties(
+            layers
+            if layers
+            else [
+                [240, 200],
+            ]
+        )
         self.set_foundation_properties()
         self.calc_fundamental_system()

weac/mixins.py

@@ -526,9 +526,12 @@ class SlabContactMixin:
             Collapse-factor. Ratio of the crack height to the
             uncollapsed weak-layer height.
         """
+        # mark argument as intentionally unused (API compatibility)
+        _ = cf
         # subtract displacement under constact load from collapsed wl height
         qn = self.calc_qn()
-        self.tc = cf * self.t - qn / self.kn
+        collapse_height = 4.70 * (1 - np.exp(-self.t / 7.78))
+        self.tc = collapse_height - qn / self.kn
 
     def set_phi(self, phi):
         """
@@ -776,8 +779,8 @@ class SlabContactMixin:
         """Set class attributes for touchdown consideration"""
         self.set_columnlength(L)
         self.set_cracklength(a)
-        self.set_tc(cf)
         self.set_phi(phi)
+        self.set_tc(cf)
         self.set_stiffness_ratio(ratio)
 
     def calc_touchdown_mode(self):
@@ -883,7 +886,7 @@ class SolutionMixin:
             bc = np.array([self.N(z), self.M(z), self.V(z)])
         else:
             raise ValueError(
-                "Boundary conditions not defined for" f"system of type {self.system}."
+                f"Boundary conditions not defined for system of type {self.system}."
             )
 
         return bc
@@ -1441,9 +1444,7 @@ class AnalysisMixin:
             # Solution at crack tip
             z = self.z(li[idx], C[:, [idx]], li[idx], phi, bed=ki[idx])
             # Mode I and II differential energy release rates
-            Gdif[1:, j] = np.concatenate(
-                (self.Gi(z, unit=unit), self.Gii(z, unit=unit))
-            )
+            Gdif[1:, j] = np.concatenate((self.Gi(z, unit=unit), self.Gii(z, unit=unit)))
 
         # Sum mode I and II contributions
         Gdif[0, :] = Gdif[1, :] + Gdif[2, :]
@@ -1481,10 +1482,7 @@ class AnalysisMixin:
         nlayer = np.ceil((z[1:] - z[:-1]) / dz).astype(np.int32) + 1
         # Calculate grid points as list of z-coordinates (mm)
         zi = np.hstack(
-            [
-                np.linspace(z[i], z[i + 1], n, endpoint=True)
-                for i, n in enumerate(nlayer)
-            ]
+            [np.linspace(z[i], z[i + 1], n, endpoint=True) for i, n in enumerate(nlayer)]
         )
         # Get lists of corresponding elastic properties (E, nu, rho)
         si = np.repeat(self.slab[:, [2, 4, 0]], nlayer, axis=0)