weac 2.3.2__tar.gz → 2.4.1__tar.gz

{weac-2.3.2 → weac-2.4.1}/CITATION.cff

@@ -8,7 +8,7 @@ authors:
 - family-names: "Weissgraeber"
   given-names: "Philipp"
   orcid: "https://orcid.org/0000-0001-8320-8672"
-version: 2.3.2
+version: 2.4.1
 date-released: 2021-12-30
 identifiers:
   - description: Collection of archived snapshots of all versions of WEAC

{weac-2.3.2 → weac-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: weac
-Version: 2.3.2
+Version: 2.4.1
 Summary: Weak layer anticrack nucleation model
 Home-page: https://github.com/2phi/weac
 Author: 2phi GbR
@@ -15,8 +15,12 @@ Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Provides-Extra: interactive
 License-File: LICENSE
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: scipy
+Provides-Extra: interactive
+Requires-Dist: jupyter; extra == "interactive"
 
 <!-- LOGO AND TITLE-->
 <!-- <p align="right"><img src="https://github.com/2phi/weac/raw/main/img/logo.png" alt="Logo" width="80" height="80"></p> -->

{weac-2.3.2 → weac-2.4.1}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = weac
-version = 2.3.2
+version = 2.4.1
 author = 2phi GbR
 author_email = mail@2phi.de
 description = Weak layer anticrack nucleation model

{weac-2.3.2 → weac-2.4.1}/weac/__init__.py

@@ -11,7 +11,7 @@ from weac.inverse import Inverse
 from weac import plot
 
 # Version
-__version__ = '2.3.2'
+__version__ = '2.4.1'
 
 # Public names
 __all__ = [

{weac-2.3.2 → weac-2.4.1}/weac/eigensystem.py

@@ -96,11 +96,12 @@ class Eigensystem:
 
         Arguments
         ---------
-        system : {'pst-', '-pst', 'skier', 'skiers'}, optional
+        system : {'pst-', '-pst', 'vpst-', '-vpst', 'skier', 'skiers'}, optional
             Type of system to analyse: PST cut from the right (pst-),
-            PST cut form the left (-pst), one skier on infinite
-            slab (skier) or multiple skiers on infinite slab (skeirs).
-            Default is 'pst-'.
+            PST cut form the left (-pst), PST with vertical faces cut
+            from the right (vpst-), PST with vertical faces cut from the
+            left (-vpst), one skier on infinite slab (skier) or multiple
+            skiers on infinite slab (skiers). Default is 'pst-'.
         layers : list, optional
             2D list of layer densities and thicknesses. Columns are
             density (kg/m^3) and thickness (mm). One row corresponds
@@ -110,7 +111,7 @@ class Eigensystem:
         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', 'skier', 'skiers'
+        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
@@ -141,9 +142,9 @@ class Eigensystem:
         self.sR = False         # Stability shift of real eigenvalues
 
         # Initialize touchdown attributes
+        self.touchdown = False  # Flag whether touchdown is possible
         self.lC = False         # Minimum length of substratum contact (mm)
-        self.lS = False         # Maximum length of span between
-                                # between bedded and touchdowned boundary (mm)
+        self.lS = False         # Maximum span between bedded and touchdown (mm)
         self.ratio = False      # Stiffness ratio of collalpsed to uncollapsed weak-layer
         self.beta = False       # Ratio of slab to bedding stiffness
 
@@ -221,7 +222,7 @@ class Eigensystem:
 
         # Compute total slab thickness and center of gravity
         self.h, self.zs = calc_center_of_gravity(layers)
-
+        
         # Assemble layering into matrix (top to bottom)
         # Columns are density (kg/m^3), layer thickness (mm)
         # Young's modulus (MPa), shear modulus (MPa), and
@@ -509,15 +510,19 @@ class Eigensystem:
                 First coefficient for sixth order term,
                 second coefficient for fith order term and so on.
             """
-            a1 = self.kA55**2*kR1*kN1*q0
-            a2 = 6*self.kA55*(self.D11*self.kA55 + kR1*kR2)*kN1*q0
-            a3 = 30*self.D11*self.kA55*(kR1 + kR2)*kN1*q0
-            a4 = 24*self.D11*(2*self.kA55**2*kR1 + 3*self.D11*self.kA55*kN1 + 3*kR1*kR2*kN1)*q0
-            a5 = 72*self.D11*(self.D11*(self.kA55**2 + (kR1 + kR2)*kN1)*q0 \
-                + self.kA55*kR1*(2*kR2*q0 - self.kA55*kN1*self.tc))
-            a6 = 144*self.D11*self.kA55*(self.D11*(kR1 + kR2)*q0 \
-                - (self.D11*self.kA55 + kR1*kR2)*kN1*self.tc)
-            a7 = - 144*self.D11**2*self.kA55*(kR1 + kR2)*kN1*self.tc
+            kA55 = self.kA55
+            D11 = self.D11
+            tc = self.tc
+            
+            a1 = kA55**2*kR1*kN1*q0
+            a2 = 6*kA55*(D11*kA55 + kR1*kR2)*kN1*q0
+            a3 = 30*D11*kA55*(kR1 + kR2)*kN1*q0
+            a4 = 24*D11*(2*kA55**2*kR1 + 3*D11*kA55*kN1 + 3*kR1*kR2*kN1)*q0
+            a5 = 72*D11*(D11*(kA55**2 + (kR1 + kR2)*kN1)*q0 \
+                + kA55*kR1*(2*kR2*q0 - kA55*kN1*tc))
+            a6 = 144*D11*kA55*(D11*(kR1 + kR2)*q0 \
+                - (D11*kA55 + kR1*kR2)*kN1*tc)
+            a7 = - 144*D11**2*kA55*(kR1 + kR2)*kN1*tc
             return [a1,a2,a3,a4,a5,a6,a7]
 
         # Get spring stiffnesses for adjacent segment with intact weak-layer
@@ -692,7 +697,7 @@ class Eigensystem:
         A11 = self.A11
         B11 = self.B11
         kA55 = self.kA55
-        E0 = self.K0
+        K0 = self.K0
 
         # Unpack geometric properties
         h = self.h
@@ -711,13 +716,13 @@ class Eigensystem:
                 [0]])
         else:
             zp = np.array([
-                [(-3*(qt + pt)/A11 - B11*(qn + pn)*x/E0)/6*x**2],
-                [(-2*(qt + pt)/A11 - B11*(qn + pn)*x/E0)/2*x],
-                [-A11*(qn + pn)*x**4/(24*E0)],
-                [-A11*(qn + pn)*x**3/(6*E0)],
-                [A11*(qn + pn)*x**3/(6*E0)
+                [(-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*E0) - 1/kA55)]])
+                [(qn + pn)*(A11*x**2/(2*K0) - 1/kA55)]])
 
         return zp
 

{weac-2.3.2 → weac-2.4.1}/weac/layered.py

@@ -26,11 +26,12 @@ class Layered(FieldQuantitiesMixin, SolutionMixin, AnalysisMixin,
 
         Arguments
         ---------
-        system : {'pst-', '-pst', 'skier', 'skiers'}, optional
+        system : {'pst-', '-pst', 'vpst-', '-vpst', 'skier', 'skiers'}, optional
             Type of system to analyse: PST cut from the right (pst-),
-            PST cut form the left (-pst), one skier on infinite
-            slab (skier) or multiple skiers on infinite slab (skiers).
-            Default is 'pst-'.
+            PST cut form the left (-pst), PST with vertical faces cut
+            from the right (vpst-), PST with vertical faces cut from the
+            left (-vpst), one skier on infinite slab (skier) or multiple
+            skiers on infinite slab (skiers). Default is 'pst-'.
         layers : list, optional
             2D list of layer densities and thicknesses. Columns are
             density(kg/m ^ 3) and thickness(mm). One row corresponds

{weac-2.3.2 → weac-2.4.1}/weac/mixins.py

@@ -4,13 +4,12 @@
 # Standard library imports
 from functools import partial
 
-
 # Third party imports
 import numpy as np
 from scipy.integrate import romberg, cumulative_trapezoid
 
 # Module imports
-from weac.tools import tensile_strength_slab
+from weac.tools import tensile_strength_slab, calc_vertical_bc_center_of_gravity
 
 
 class FieldQuantitiesMixin:
@@ -510,15 +509,16 @@ class SolutionMixin:
             A - free end, B - intermediate touchdown,
             C - full touchdown (maximum clamped end).
         """
-        # Classify boundary type by element length
-        if l <= self.lC:
-            mode = 'A'
-        elif self.lC < l <= self.lS:
-            mode = 'B'
-        elif self.lS < l:
-            mode = 'C'
-
-        return mode
+        if self.touchdown:
+            # Classify boundary type by element length
+            if l <= self.lC:
+                return 'A'
+            elif self.lC < l <= self.lS:
+                return 'B'
+            elif self.lS < l:
+                return 'C'
+        else:
+            return 'A'
 
     def reduce_stiffness(self, l=0, mode='A'):
         """
@@ -586,28 +586,39 @@ class SolutionMixin:
             if not k:
                 if mode in ['A']:
                     # Free end
-                    bc = np.array([self.N(z),
-                                   self.M(z),
-                                   self.V(z)
-                                   ])
+                    bc = np.array([
+                        self.N(z),
+                        self.M(z),
+                        self.V(z)
+                    ])
                 elif mode in ['B', 'C'] and pos in ['r', 'right']:
                     # Touchdown right
-                    bc = np.array([self.N(z),
-                                   self.M(z) + kf*kR*self.psi(z),
-                                   self.w(z)
-                                   ])
+                    bc = np.array([
+                        self.N(z),
+                        self.M(z) + kf*kR*self.psi(z),
+                        self.w(z)
+                    ])
                 elif mode in ['B', 'C'] and pos in ['l', 'left']:
                     # Touchdown left
-                    bc = np.array([self.N(z),
-                                   self.M(z) - kf*kR*self.psi(z),
-                                   self.w(z)
-                                   ])
+                    bc = np.array([
+                        self.N(z),
+                        self.M(z) - kf*kR*self.psi(z),
+                        self.w(z)
+                    ])
             else:
                 # Free end
-                bc = np.array([self.N(z),
-                                self.M(z),
-                                self.V(z)
-                                ])
+                bc = np.array([
+                    self.N(z),
+                    self.M(z),
+                    self.V(z)
+                ])
+        # Set boundary conditions for PST-systems with vertical faces
+        elif self.system in ['-vpst', 'vpst-']:
+            bc = np.array([
+                self.N(z),
+                self.M(z),
+                self.V(z)
+            ])
         # Set boundary conditions for SKIER-systems
         elif self.system in ['skier', 'skiers']:
             # Infinite end (vanishing complementary solution)
@@ -653,40 +664,40 @@ class SolutionMixin:
         """
         if pos in ('l', 'left'):
             eqs = np.array([
-                self.bc(zl, l, k, pos)[0],             # Left boundary condition
-                self.bc(zl, l, k, pos)[1],             # Left boundary condition
-                self.bc(zl, l, k, pos)[2],             # Left boundary condition
-                self.u(zr, z0=0),           # ui(xi = li)
-                self.w(zr),                 # wi(xi = li)
-                self.psi(zr),               # psii(xi = li)
-                self.N(zr),                 # Ni(xi = li)
-                self.M(zr),                 # Mi(xi = li)
-                self.V(zr)])                # Vi(xi = li)
+                self.bc(zl, l, k, pos)[0],      # Left boundary condition
+                self.bc(zl, l, k, pos)[1],      # Left boundary condition
+                self.bc(zl, l, k, pos)[2],      # Left boundary condition
+                self.u(zr, z0=0),               # ui(xi = li)
+                self.w(zr),                     # wi(xi = li)
+                self.psi(zr),                   # psii(xi = li)
+                self.N(zr),                     # Ni(xi = li)
+                self.M(zr),                     # Mi(xi = li)
+                self.V(zr)])                    # Vi(xi = li)
         elif pos in ('m', 'mid'):
             eqs = np.array([
-                -self.u(zl, z0=0),          # -ui(xi = 0)
-                -self.w(zl),                # -wi(xi = 0)
-                -self.psi(zl),              # -psii(xi = 0)
-                -self.N(zl),                # -Ni(xi = 0)
-                -self.M(zl),                # -Mi(xi = 0)
-                -self.V(zl),                # -Vi(xi = 0)
-                self.u(zr, z0=0),           # ui(xi = li)
-                self.w(zr),                 # wi(xi = li)
-                self.psi(zr),               # psii(xi = li)
-                self.N(zr),                 # Ni(xi = li)
-                self.M(zr),                 # Mi(xi = li)
-                self.V(zr)])                # Vi(xi = li)
+                -self.u(zl, z0=0),              # -ui(xi = 0)
+                -self.w(zl),                    # -wi(xi = 0)
+                -self.psi(zl),                  # -psii(xi = 0)
+                -self.N(zl),                    # -Ni(xi = 0)
+                -self.M(zl),                    # -Mi(xi = 0)
+                -self.V(zl),                    # -Vi(xi = 0)
+                self.u(zr, z0=0),               # ui(xi = li)
+                self.w(zr),                     # wi(xi = li)
+                self.psi(zr),                   # psii(xi = li)
+                self.N(zr),                     # Ni(xi = li)
+                self.M(zr),                     # Mi(xi = li)
+                self.V(zr)])                    # Vi(xi = li)
         elif pos in ('r', 'right'):
             eqs = np.array([
-                -self.u(zl, z0=0),          # -ui(xi = 0)
-                -self.w(zl),                # -wi(xi = 0)
-                -self.psi(zl),              # -psii(xi = 0)
-                -self.N(zl),                # -Ni(xi = 0)
-                -self.M(zl),                # -Mi(xi = 0)
-                -self.V(zl),                # -Vi(xi = 0)
-                self.bc(zr, l, k, pos)[0],             # Right boundary condition
-                self.bc(zr, l, k, pos)[1],             # Right boundary condition
-                self.bc(zr, l, k, pos)[2]])            # Right boundary condition
+                -self.u(zl, z0=0),              # -ui(xi = 0)
+                -self.w(zl),                    # -wi(xi = 0)
+                -self.psi(zl),                  # -psii(xi = 0)
+                -self.N(zl),                    # -Ni(xi = 0)
+                -self.M(zl),                    # -Mi(xi = 0)
+                -self.V(zl),                    # -Vi(xi = 0)
+                self.bc(zr, l, k, pos)[0],      # Right boundary condition
+                self.bc(zr, l, k, pos)[1],      # Right boundary condition
+                self.bc(zr, l, k, pos)[2]])     # Right boundary condition
         else:
             raise ValueError(
                 (f'Invalid position argument {pos} given. '
@@ -719,10 +730,10 @@ class SolutionMixin:
             Used for system 'skiers'.
         L : float, optional
             Total length of model (mm). Used for systems 'pst-', '-pst',
-            and 'skier'.
+            'vpst-', '-vpst', and 'skier'.
         a : float, optional
-            Crack length (mm).  Used for systems 'pst-', '-pst', and
-            'skier'.
+            Crack length (mm). Used for systems 'pst-', '-pst',  'pst-',
+            '-pst', and 'skier'.
         phi : float, optional
             Inclination (degree).
         m : float, optional
@@ -752,12 +763,22 @@ class SolutionMixin:
             ki = np.array(ki)                           # Crack
             k0 = np.array(k0)                           # No crack
         elif self.system == 'pst-':
-            li = np.array([L - a, lU])                   # Segment lengths
+            li = np.array([L - a, lU])                  # Segment lengths
             mi = np.array([0])                          # Skier weights
             ki = np.array([True, False])                # Crack
             k0 = np.array([True, True])                 # No crack
         elif self.system == '-pst':
-            li = np.array([lU, L - a])                   # Segment lengths
+            li = np.array([lU, L - a])                  # Segment lengths
+            mi = np.array([0])                          # Skier weights
+            ki = np.array([False, True])                # Crack
+            k0 = np.array([True, True])                 # No crack
+        elif self.system == 'vpst-':
+            li = np.array([L - a, a])                   # Segment lengths
+            mi = np.array([0])                          # Skier weights
+            ki = np.array([True, False])                # Crack
+            k0 = np.array([True, True])                 # No crack
+        elif self.system == '-vpst':
+            li = np.array([a, L - a])                   # Segment lengths
             mi = np.array([0])                          # Skier weights
             ki = np.array([False, True])                # Crack
             k0 = np.array([True, True])                 # No crack
@@ -820,7 +841,7 @@ class SolutionMixin:
             raise ValueError('Make sure len(li)=N, len(ki)=N, and '
                              'len(mi)=N-1 for a system of N segments.')
 
-        if self.system not in ['pst-', '-pst']:
+        if self.system not in ['pst-', '-pst', 'vpst-', '-vpst']:
             # Boundary segments must be on foundation for infinite BCs
             if not all([ki[0], ki[-1]]):
                 raise ValueError('Provide supported boundary segments in '
@@ -885,17 +906,34 @@ class SolutionMixin:
         if self.system not in ['pst-', '-pst']:
             rhs[:3] = self.bc(self.zp(x=0, phi=phi, bed=ki[0]))
             rhs[-3:] = self.bc(self.zp(x=li[-1], phi=phi, bed=ki[-1]))
-
-        # Loop through segments to set touchdown at rhs
-        for i in range(nS):
-            # Length, foundation and position of segment i
-            l, k, pos = li[i], ki[i], pi[i]
-            mode = self.mode_td(l=l)
-            if not k and bool(mode in ['B', 'C']):
-                if i==0:
-                    rhs[:3] = np.vstack([0,0,self.tc])
-                if i == (nS - 1):
-                    rhs[-3:] = np.vstack([0,0,self.tc])
+            
+        # Set rhs for vertical faces
+        if self.system in ['vpst-', '-vpst']:
+            # Calculate center of gravity and mass of
+            # added or cut off slab segement
+            xs, zs, m = calc_vertical_bc_center_of_gravity(self.slab, phi)
+            # Convert slope angle to radians
+            phi = np.deg2rad(phi)
+            # Translate inbto section forces and moments
+            N = -self.g*m*np.sin(phi)
+            M = -self.g*m*(xs*np.cos(phi) + zs*np.sin(phi))
+            V = self.g*m*np.cos(phi)
+            # Add to right-hand side
+            rhs[:3] = np.vstack([N, M, V])          # left end
+            rhs[-3:] = np.vstack([N, M, V])         # right end
+            
+        # Set touchdown boundary conditions
+        elif self.system in ['pst-', '-pst']:
+            # Loop through segments to set touchdown at rhs
+            for i in range(nS):
+                # Length, foundation and position of segment i
+                l, k, pos = li[i], ki[i], pi[i]
+                mode = self.mode_td(l=l)
+                if not k and bool(mode in ['B', 'C']):
+                    if i==0:
+                        rhs[:3] = np.vstack([0,0,self.tc])
+                    if i == (nS - 1):
+                        rhs[-3:] = np.vstack([0,0,self.tc])
 
         # --- SOLVE -----------------------------------------------------------
 
@@ -1091,7 +1129,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] = 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, :]

{weac-2.3.2 → weac-2.4.1}/weac/plot.py

@@ -349,7 +349,7 @@ def deformed(instance, xsl, xwl, z, phi, dz=2, scale=100,
              'k', linewidth=1)
 
     # Plot deformed weak-layer outline
-    if instance.system in ['-pst', 'pst-']:
+    if instance.system in ['-pst', 'pst-', '-vpst', 'vpst-']:
         nanmask = np.isfinite(xwl)
         plt.plot(outline(Xwl[:, nanmask] + scale*Uwl[:, nanmask]),
                  outline(Zwl[:, nanmask] + scale*Wwl[:, nanmask]),

{weac-2.3.2 → weac-2.4.1}/weac/tools.py

@@ -49,6 +49,7 @@ def load_dummy_profile(profile_id):
         'e':      [hard,   soft,   soft],
         'f':      [soft,   soft,   hard],
         # Homogeneous
+        'h':      [medium,   medium,   medium],
         'soft':   [soft,   soft,   soft],
         'medium': [medium, medium, medium],
         'hard':   [hard,   hard,   hard],
@@ -75,7 +76,7 @@ def calc_center_of_gravity(layers):
 
     Arguments
     ---------
-    layers : list
+    layers : ndarray
         2D list of layer densities and thicknesses. Columns are
         density (kg/m^3) and thickness (mm). One row corresponds
         to one layer.
@@ -88,10 +89,10 @@ def calc_center_of_gravity(layers):
         Z-coordinate of center of gravity (mm).
     """
     # Layering info for center of gravity calculation (bottom to top)
-    n = layers.shape[0]                 # Number of layers
-    rho = np.flipud(layers[:, 0])       # Layer densities
-    h = np.flipud(layers[:, 1])          # Layer thicknesses
-    H = sum(h)                          # Total slab thickness
+    n = layers.shape[0]                    # Number of layers
+    rho = 1e-12*np.flipud(layers[:, 0])    # Layer densities (kg/m^3 -> t/mm^3)
+    h = np.flipud(layers[:, 1])            # Layer thicknesses
+    H = sum(h)                             # Total slab thickness
     # Layer center coordinates (bottom to top)
     zi = [H/2 - sum(h[0:j]) - h[j]/2 for j in range(n)]
     # Z-coordinate of the center of gravity
@@ -100,6 +101,61 @@ def calc_center_of_gravity(layers):
     return H, zs
 
 
+def calc_vertical_bc_center_of_gravity(slab, phi):
+    """
+    Calculate center of gravity of triangular slab segements for vertical PSTs.
+
+    Parameters
+    ----------
+    slab : ndarray
+        List of layer densities, thicknesses, and elastic properties.
+        Columns are density (kg/m^3), thickness (mm), Young's modulus
+        (MPa), shear modulus (MPa), and Poisson's ratio. One row corresponds
+        to one layer.
+    phi : fload
+        Slope angle (deg).
+
+    Returns
+    -------
+    xs : float
+        Horizontal coordinate of center of gravity (mm).
+    zs : float
+        Vertical coordinate of center of gravity (mm).
+    w : ndarray
+        Weight of the slab segment that is cut off or added (t).
+    """
+    # Convert slope angle to radians
+    phi = np.deg2rad(phi)
+    
+    # Catch flat-field case
+    if phi == 0:
+        xs = 0
+        zs = 0
+        w = 0
+    else:
+        # Layering info for center of gravity calculation (top to bottom)
+        n = slab.shape[0]               # Number of slab
+        rho = 1e-12*slab[:, 0]          # Layer densities (kg/m^3 -> t/mm^3)
+        hi = slab[:, 1]                 # Layer thicknesses
+        H = sum(hi)                     # Total slab thickness
+        # Layer coordinates z_i (top to bottom)
+        z = np.array([-H/2 + sum(hi[0:j]) for j in range(n + 1)])
+        zi = z[:-1]                         # z_i
+        zii = z[1:]                         # z_{i+1}
+        # Center of gravity of all layers (top to bottom)
+        zsi = zi + hi/3*(3/2*H - zi - 2*zii)/(H - zi - zii)
+        # Surface area of all layers (top to bottom)
+        Ai = hi/2*(H - zi - zii)*np.tan(phi)
+        # Center of gravity in vertical direction
+        zs = sum(zsi*rho*Ai)/sum(rho*Ai)
+        # Center of gravity in horizontal direction
+        xs = (H/2 - zs)*np.tan(phi/2)
+        # Weight of added or cut off slab segments (t)
+        w = sum(Ai*rho)
+    
+    # Return center of gravity and weight of slab segment
+    return xs, zs, w
+
 def scapozza(rho):
     """
     Compute Young's modulus (MPa) from density (kg/m^3).