pyroll-pillar-model-karman 3.1.0b1__tar.gz

pyroll_pillar_model_karman-3.1.0b1/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.pyc
+.venv/
+*.egg-info/
+.pytest_cache/
+tests/output/
+/.idea/misc.xml
+/.idea/modules.xml
+/.idea/inspectionProfiles/profiles_settings.xml
+/.idea/pyroll-pillar-model-karman.iml
+/.idea/vcs.xml

pyroll_pillar_model_karman-3.1.0b1/LICENSE

@@ -0,0 +1,11 @@
+Copyright 2024 Christoph Renzing
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

pyroll_pillar_model_karman-3.1.0b1/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.5
+Name: pyroll-pillar-model-karman
+Version: 3.1.0b1
+Summary: Plugin for PyRolL providing a pillar-wise calculation of von-Karmans differential-equation.
+Project-URL: Homepage, https://pyroll.readthedocs.io
+Project-URL: Repository, https://github.com/pyroll-project/pyroll-pillar-model-karman
+Project-URL: Documentation, https://github.com/pyroll-project/pyroll-pillar-model-karman/blob/main/docs/docs.pdf
+Author-email: Christoph Renzing <christophrenzing@posteo.de>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Hatch
+Classifier: Framework :: IPython
+Classifier: Framework :: Jupyter
+Classifier: Framework :: Pytest
+Classifier: Framework :: Sphinx
+Classifier: Intended Audience :: Manufacturing
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: <4.0,>=3.9
+Requires-Dist: pandas
+Requires-Dist: plotly
+Requires-Dist: pyroll-core~=3.1
+Requires-Dist: pyroll-freiberg-flow-stress~=3.0
+Requires-Dist: pyroll-interface-friction~=3.0
+Requires-Dist: pyroll-pillar-model~=3.0

pyroll_pillar_model_karman-3.1.0b1/hatch.toml

@@ -0,0 +1,40 @@
+[build]
+packages = [
+    "pyroll"
+]
+
+[metadata]
+allow-direct-references = true
+
+[version]
+path = "pyroll/pillar_model_karman/__init__.py"
+
+[envs.default]
+path = ".venv"
+dependencies = [
+    "pytest ~= 7.0",
+    "matplotlib ~= 3.6",
+    "pyroll-report ~= 3.0",
+    "pyroll-sparling-spreading",
+    "imageio-ffmpeg ~= 0.5",
+]
+
+[envs.docs]
+path = ".docs_venv"
+dependencies = [
+    "pygments ~= 2.0",
+    "pytask",
+    "pytask-latex",
+    "matplotlib"
+]
+[envs.docs.scripts]
+build = "python -m pytask"
+
+[envs.test]
+path = ""
+
+[envs.test.scripts]
+all = "pytest"
+
+[[envs.test.matrix]]
+python = ["3.9", "3.10", "3.11"]

pyroll_pillar_model_karman-3.1.0b1/pyproject.toml

@@ -0,0 +1,49 @@
+[project]
+name = "pyroll-pillar-model-karman"
+description = "Plugin for PyRolL providing a pillar-wise calculation of von-Karmans differential-equation."
+authors = [
+    { name = "Christoph Renzing", email = "christophrenzing@posteo.de" }
+]
+license = "BSD-3-Clause"
+requires-python = ">=3.9, <4.0"
+
+dependencies = [
+    "pyroll-core ~= 3.1",
+    "pyroll-pillar-model ~= 3.0",
+    "pyroll-freiberg-flow-stress~=3.0",
+    "pyroll-interface-friction~=3.0",
+    "plotly",
+    "pandas"
+]
+
+classifiers = [
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Manufacturing",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering",
+    "License :: OSI Approved :: BSD License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Development Status :: 5 - Production/Stable",
+    "Framework :: Hatch",
+    "Framework :: IPython",
+    "Framework :: Jupyter",
+    "Framework :: Pytest",
+    "Framework :: Sphinx",
+    "Natural Language :: English",
+]
+
+dynamic = ["version"]
+
+[project.urls]
+Homepage = "https://pyroll.readthedocs.io"
+
+
+Repository = "https://github.com/pyroll-project/pyroll-pillar-model-karman"
+Documentation = "https://github.com/pyroll-project/pyroll-pillar-model-karman/blob/main/docs/docs.pdf"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

pyroll_pillar_model_karman-3.1.0b1/pyroll/pillar_model_karman/__init__.py

@@ -0,0 +1,26 @@
+import importlib.util
+from . import roll_pass
+from pyroll.core import config as _config
+
+VERSION = "3.1.0b1"
+
+REPORT_INSTALLED = bool(importlib.util.find_spec("pyroll.report"))
+
+if REPORT_INSTALLED:
+    from . import report
+    import pyroll.report
+
+    pyroll.report.plugin_manager.register(report)
+
+
+@_config("PYROLL_3D_KARMAN_MODEL")
+class Config:
+    SHEAR_STRESS_DIRECTION_REGULARISATION = 0.001
+    SHEAR_STRESS_PRESSURE_REGULARISATION = 0.001
+    LATERAL_SHEAR_STRESS_DIRECTION_REGULARISATION = 0.05
+    USE_SPREADING_VELOCITY_REGULARISATION = True
+    """If True, the latitudinal friction direction is regularized from each pillar's actual
+    lateral (spreading) velocity (can flip sign locally, e.g. "Querfliessen"); requires a
+    spread model that resolves non-trivial pillar_spreads. If False, falls back to the
+    purely geometric tanh(z / (eps * b/2)), which always assumes outward flow away from the
+    centerline."""

pyroll_pillar_model_karman-3.1.0b1/pyroll/pillar_model_karman/report.py

@@ -0,0 +1,160 @@
+import numpy as np
+import plotly.io as pio
+import matplotlib.pyplot as plt
+import plotly.graph_objects as go
+
+from pyroll.core import Unit, RollPass
+from pyroll.report import hookimpl
+
+
+def _mirror_pillars(pillars: np.ndarray) -> np.ndarray:
+    """Mirror the half-width pillar z-coordinates (``pillars[0]`` at the center) to the full
+    profile width."""
+    return np.concatenate([-pillars[:0:-1], pillars])
+
+
+def _mirror_values(values: np.ndarray, antisymmetric: bool) -> np.ndarray:
+    """Mirror a per-pillar quantity from half- to full-width. Stresses and friction stresses
+    acting in the rolling or roll-normal direction are symmetric about the profile center
+    (``antisymmetric=False``); the latitudinal (width-direction) friction stress reverses sign
+    on the opposite half of the profile, since it opposes the (mirrored) outward material flow
+    there, so it is mirrored antisymmetrically (``antisymmetric=True``)."""
+    mirrored_half = -values[:0:-1] if antisymmetric else values[:0:-1]
+    return np.concatenate([mirrored_half, values])
+
+
+def _full_width_surface(rp: RollPass, attr: str, antisymmetric: bool = False):
+    x = np.array([
+        np.ones_like(_mirror_pillars(de.out_profile.pillars)) * de.out_profile.x
+        for de in rp.disk_elements
+    ])
+    y = np.array([_mirror_pillars(de.out_profile.pillars) for de in rp.disk_elements])
+    z = np.array([
+        _mirror_values(getattr(de.out_profile, attr), antisymmetric) for de in rp.disk_elements
+    ])
+    return x, y, z
+
+
+@hookimpl(specname="unit_plot")
+def roll_pass_altitudinal_stress_stress_profile(unit: Unit):
+    if isinstance(unit, RollPass) and unit.disk_elements:
+        rp: RollPass = unit
+        x, y, z = _full_width_surface(rp, "pillars_altitudinal_stress")
+
+        fig = go.Figure(data=[go.Surface(z=z, x=x, y=y)])
+        fig.update_layout(title='Workpiece Altitudinal Stress Profile')
+        fig.update_layout(
+            scene=dict(
+                xaxis=dict(title='Contact Length', gridcolor='rgb(200, 200, 200)', showgrid=True),
+                yaxis=dict(title='Profile Width', gridcolor='rgb(200, 200, 200)', showgrid=True),
+                zaxis=dict(title='Altitudinal Stress', gridcolor='rgb(200, 200, 200)', showgrid=True),
+            ),
+            title='Workpiece Altitudinal Stress Profile',
+            width=1200,
+            height=800,
+            template='simple_white'
+        )
+
+        html_string = pio.to_html(fig, full_html=False, include_plotlyjs='cdn')
+
+        return html_string
+
+
+@hookimpl(specname="unit_plot")
+def roll_pass_latitudinal_stress_profile(unit: Unit):
+    if isinstance(unit, RollPass) and unit.disk_elements:
+        rp: RollPass = unit
+        x, y, z = _full_width_surface(rp, "pillars_latitudinal_stress")
+
+        fig = go.Figure(data=[go.Surface(z=z, x=x, y=y)])
+        fig.update_layout(title='Workpiece Latitudinal Stress Profile')
+        fig.update_layout(
+            scene=dict(
+                xaxis=dict(title='Contact Length', gridcolor='rgb(200, 200, 200)', showgrid=True),
+                yaxis=dict(title='Profile Width', gridcolor='rgb(200, 200, 200)', showgrid=True),
+                zaxis=dict(title='Latitudinal Stress', gridcolor='rgb(200, 200, 200)', showgrid=True),
+            ),
+            title='Workpiece Latitudinal Stress Profile',
+            width=1200,
+            height=800,
+            template='simple_white'
+        )
+
+        html_string = pio.to_html(fig, full_html=False, include_plotlyjs='cdn')
+
+        return html_string
+
+
+@hookimpl(specname="unit_plot")
+def roll_pass_longitudinal_stress_profile(unit: Unit):
+    if isinstance(unit, RollPass) and unit.disk_elements:
+        rp: RollPass = unit
+        x, y, z = _full_width_surface(rp, "pillars_longitudinal_stress")
+
+        fig = go.Figure(data=[go.Surface(z=z, x=x, y=y)])
+        fig.update_layout(title='Workpiece Longitudinal Stress Profile')
+        fig.update_layout(
+            scene=dict(
+                xaxis=dict(title='Contact Length', gridcolor='rgb(200, 200, 200)', showgrid=True),
+                yaxis=dict(title='Profile Width', gridcolor='rgb(200, 200, 200)', showgrid=True),
+                zaxis=dict(title='Logitudinal Stress', gridcolor='rgb(200, 200, 200)', showgrid=True),
+            ),
+            title='Workpiece Longitudinal Stress Profile',
+            width=1200,
+            height=800,
+            template='simple_white'
+        )
+
+        html_string = pio.to_html(fig, full_html=False, include_plotlyjs='cdn')
+
+        return html_string
+
+
+@hookimpl(specname="unit_plot")
+def roll_pass_pillars_latitudinal_friction_stress_profile(unit: Unit):
+    if isinstance(unit, RollPass) and unit.disk_elements:
+        rp: RollPass = unit
+        x, y, z = _full_width_surface(rp, "pillars_latitudinal_friction_stress", antisymmetric=True)
+
+        fig = go.Figure(data=[go.Surface(z=z, x=x, y=y)])
+        fig.update_layout(title='Workpiece Latitudinal Shear Stress')
+        fig.update_layout(
+            scene=dict(
+                xaxis=dict(title='Contact Length', gridcolor='rgb(200, 200, 200)', showgrid=True),
+                yaxis=dict(title='Profile Width', gridcolor='rgb(200, 200, 200)', showgrid=True),
+                zaxis=dict(title='Latitudinal Shear Stress', gridcolor='rgb(200, 200, 200)', showgrid=True),
+            ),
+            title='Workpiece Latitudinal Shear Stress Profile',
+            width=1200,
+            height=800,
+            template='simple_white'
+        )
+
+        html_string = pio.to_html(fig, full_html=False, include_plotlyjs='cdn')
+
+        return html_string
+
+
+@hookimpl(specname="unit_plot")
+def roll_pass_pillars_longitudinal_friction_stress_profile(unit: Unit):
+    if isinstance(unit, RollPass) and unit.disk_elements:
+        rp: RollPass = unit
+        x, y, z = _full_width_surface(rp, "pillars_longitudinal_friction_stress")
+
+        fig = go.Figure(data=[go.Surface(z=z, x=x, y=y)])
+        fig.update_layout(title='Workpiece Longitudinal Shear Stress')
+        fig.update_layout(
+            scene=dict(
+                xaxis=dict(title='Contact Length', gridcolor='rgb(200, 200, 200)', showgrid=True),
+                yaxis=dict(title='Profile Width', gridcolor='rgb(200, 200, 200)', showgrid=True),
+                zaxis=dict(title='Longitudinal Shear Stress', gridcolor='rgb(200, 200, 200)', showgrid=True),
+            ),
+            title='Workpiece Longitudinal Shear Stress Profile',
+            width=1200,
+            height=800,
+            template='simple_white'
+        )
+
+        html_string = pio.to_html(fig, full_html=False, include_plotlyjs='cdn')
+
+        return html_string

pyroll_pillar_model_karman-3.1.0b1/pyroll/pillar_model_karman/roll_pass/__init__.py

@@ -0,0 +1,3 @@
+from . import pillar_disk_element
+from . import hookimpls
+from . import additional_inits

pyroll_pillar_model_karman-3.1.0b1/pyroll/pillar_model_karman/roll_pass/additional_inits.py

@@ -0,0 +1,80 @@
+import numpy as np
+from pyroll.core import Profile as BaseProfile
+from pyroll.core import SymmetricRollPass, Unit
+
+from . import stress_solver as ss
+
+
+class KarmanInitialSolver(Unit):
+    def __init__(self, disk_element: SymmetricRollPass.DiskElement):
+        self.de = disk_element
+        super().__init__(label=f"Initial Solution for {self.de.roll_pass}")
+
+    def solve(self, in_profile: BaseProfile) -> BaseProfile:
+        if self.de is not self.de.roll_pass.disk_elements[0]:
+            return in_profile
+
+        from .. import Config
+
+        roll_pass = self.de.roll_pass
+        mu = roll_pass.coulomb_friction_coefficient
+        longitudinal_direction = 1.0
+        # geometric regularization only: this lumped entry-wedge step has no in/out pillar
+        # pair to derive an actual lateral velocity from, unlike the per-disk-element solver
+        # (see hookimpls/pillar_disk_element.py).
+        lateral_scale = Config.LATERAL_SHEAR_STRESS_DIRECTION_REGULARISATION * in_profile.pillar_boundaries[-1]
+        latitudinal_directions = np.tanh(in_profile.pillars / lateral_scale)
+        longitudinal_angles = roll_pass.roll.pillar_entry_angles
+
+        n = len(in_profile.pillars)
+        flow_stresses = np.full(n, in_profile.flow_stress)
+        longitudinal_stresses = np.full(n, roll_pass.back_tension, dtype=float)
+        altitudinal_stresses = np.zeros(n)
+        latitudinal_stresses = np.zeros(n)
+        normal_stresses = np.zeros(n)
+        longitudinal_friction_stresses = np.zeros(n)
+        latitudinal_friction_stresses = np.zeros(n)
+
+        latitudinal_stress = 0.0
+        for i in range(n - 1, -1, -1):
+            longitudinal_angle = longitudinal_angles[i]
+            latitudinal_angle = in_profile.pillar_latitudinal_angles[i]
+            latitudinal_direction = latitudinal_directions[i]
+            flow_stress = flow_stresses[i]
+
+            altitudinal_stress = ss.altitudinal_stress(longitudinal_stresses[i], latitudinal_stress, flow_stress)
+            normal_stress = ss.normal_stress(
+                altitudinal_stress, longitudinal_angle, latitudinal_angle,
+                longitudinal_direction, latitudinal_direction, mu,
+            )
+            longitudinal_friction_stress = ss.longitudinal_friction_stress(
+                normal_stress, latitudinal_angle, longitudinal_direction, mu
+            )
+            latitudinal_friction_stress = ss.latitudinal_friction_stress(
+                normal_stress, longitudinal_angle, latitudinal_direction, mu
+            )
+            latitudinal_stress_increment = ss.latitudinal_stress_increment(
+                normal_stress, latitudinal_friction_stress, latitudinal_stress,
+                longitudinal_angle, latitudinal_angle,
+                in_profile.pillar_latitudinal_height_derivatives[i], in_profile.pillar_heights[i],
+            )
+
+            altitudinal_stresses[i] = altitudinal_stress
+            normal_stresses[i] = normal_stress
+            latitudinal_stresses[i] = latitudinal_stress
+            longitudinal_friction_stresses[i] = longitudinal_friction_stress
+            latitudinal_friction_stresses[i] = latitudinal_friction_stress
+
+            latitudinal_stress = latitudinal_stress + latitudinal_stress_increment * in_profile.pillar_widths[i]
+
+        in_profile.pillars_longitudinal_stress = longitudinal_stresses
+        in_profile.pillars_altitudinal_stress = altitudinal_stresses
+        in_profile.pillars_latitudinal_stress = latitudinal_stresses
+        in_profile.pillars_normal_stress = normal_stresses
+        in_profile.pillars_longitudinal_friction_stress = longitudinal_friction_stresses
+        in_profile.pillars_latitudinal_friction_stress = latitudinal_friction_stresses
+
+        return in_profile
+
+
+SymmetricRollPass.DiskElement.pre_processors.append(KarmanInitialSolver)

pyroll_pillar_model_karman-3.1.0b1/pyroll/pillar_model_karman/roll_pass/hookimpls/__init__.py

@@ -0,0 +1 @@
+from . import pillar_disk_element

pyroll_pillar_model_karman-3.1.0b1/pyroll/pillar_model_karman/roll_pass/hookimpls/pillar_disk_element.py

@@ -0,0 +1,172 @@
+import numpy as np
+
+from ..pillar_disk_element import PillarDiskElement
+from .. import stress_solver as ss
+
+
+@PillarDiskElement.longitudinal_direction
+def longitudinal_direction(self: PillarDiskElement):
+    from ... import Config
+    return 2 / np.pi * np.arctan(
+        (self.roll_pass.velocity - self.out_profile.velocity) / Config.SHEAR_STRESS_DIRECTION_REGULARISATION)
+
+
+@PillarDiskElement.pillar_latitudinal_directions
+def pillar_latitudinal_directions(self: PillarDiskElement):
+    from ... import Config
+    ip = self.in_profile
+    op = self.out_profile
+
+    if not Config.USE_SPREADING_VELOCITY_REGULARISATION:
+        half_width = ip.pillar_boundaries[-1]
+        geometric_scale = Config.LATERAL_SHEAR_STRESS_DIRECTION_REGULARISATION * half_width
+        return np.tanh(ip.pillars / geometric_scale)
+
+    # actual lateral (spreading) velocity of each pillar, from how far its z-position
+    # shifted across this disk element; unlike a purely geometric sign(z), this can flip
+    # sign locally (e.g. material flowing towards the center despite positive overall
+    # spread, "Querfliessen", see Schlegel 1976) whenever the underlying spread model
+    # resolves it. Requires a real spread model to be loaded (pillar_spreads != 1
+    # everywhere) so the lateral velocity is actually non-zero.
+    lateral_velocity = (op.pillars - ip.pillars) / self.length * self.pillar_velocities
+    # tiny floor: at the very first disk element no pillar has started spreading yet, so
+    # both the velocity and its max are genuinely 0 there (not a missing spread model).
+    scale = Config.LATERAL_SHEAR_STRESS_DIRECTION_REGULARISATION * np.max(np.abs(lateral_velocity)) + 1e-30
+    return np.tanh(lateral_velocity / scale)
+
+
+class KarmanSolution3D:
+    """Solves the pillar-wise 3D von Karman equations for one disk element: first the longitudinal
+    (rolling direction) stress increment for all pillars at once, then a sweep over the pillars from
+    the free edge (latitudinal stress = 0 boundary condition) towards the center, integrating the
+    latitudinal stress increment inward. See Overhagen (2018), section 4.5.5, for the discretization
+    scheme this mirrors."""
+
+    def __init__(self, disk_element: PillarDiskElement):
+        self.disk_element = disk_element
+        self.roll_pass = disk_element.roll_pass
+        self.in_profile = disk_element.in_profile
+        self.out_profile = disk_element.out_profile
+        self.number_of_pillars = len(self.in_profile.pillars)
+        self.solution = self.solve()
+
+    def calculate_longitudinal_stresses(self):
+        ip = self.in_profile
+        de = self.disk_element
+        mu = self.roll_pass.coulomb_friction_coefficient
+
+        longitudinal_angle = de.pillar_longitudinal_angles
+        latitudinal_angle = ip.pillar_latitudinal_angles
+
+        friction_x = ss.longitudinal_friction_stress(
+            ip.pillars_normal_stress, latitudinal_angle, de.longitudinal_direction, mu
+        )
+        increment = ss.longitudinal_stress_increment(
+            ip.pillars_normal_stress, friction_x, ip.pillars_longitudinal_stress,
+            longitudinal_angle, latitudinal_angle,
+            de.pillar_longitudinal_height_derivatives, ip.pillar_heights,
+        )
+
+        return ip.pillars_longitudinal_stress + increment * de.length
+
+    def calculate_stresses(self, index: int, latitudinal_stress: float, longitudinal_stress: float):
+        op = self.out_profile
+        de = self.disk_element
+        mu = self.roll_pass.coulomb_friction_coefficient
+
+        longitudinal_angle = de.pillar_longitudinal_angles[index]
+        latitudinal_angle = op.pillar_latitudinal_angles[index]
+        latitudinal_direction = de.pillar_latitudinal_directions[index]
+        flow_stress = op.pillars_flow_stress[index]
+
+        altitudinal_stress = ss.altitudinal_stress(longitudinal_stress, latitudinal_stress, flow_stress)
+        normal_stress = ss.normal_stress(
+            altitudinal_stress, longitudinal_angle, latitudinal_angle,
+            de.longitudinal_direction, latitudinal_direction, mu,
+        )
+        longitudinal_friction_stress = ss.longitudinal_friction_stress(
+            normal_stress, latitudinal_angle, de.longitudinal_direction, mu
+        )
+        latitudinal_friction_stress = ss.latitudinal_friction_stress(
+            normal_stress, longitudinal_angle, latitudinal_direction, mu
+        )
+        latitudinal_stress_increment = ss.latitudinal_stress_increment(
+            normal_stress, latitudinal_friction_stress, latitudinal_stress,
+            longitudinal_angle, latitudinal_angle,
+            op.pillar_latitudinal_height_derivatives[index], op.pillar_heights[index],
+        )
+
+        return {
+            "altitudinal_stress": altitudinal_stress,
+            "normal_stress": normal_stress,
+            "longitudinal_friction_stress": longitudinal_friction_stress,
+            "latitudinal_friction_stress": latitudinal_friction_stress,
+            "latitudinal_stress_increment": latitudinal_stress_increment,
+        }
+
+    def solve(self):
+        n = self.number_of_pillars
+        longitudinal_stresses = self.calculate_longitudinal_stresses()
+
+        altitudinal_stresses = np.zeros(n)
+        latitudinal_stresses = np.zeros(n)
+        longitudinal_friction_stresses = np.zeros(n)
+        latitudinal_friction_stresses = np.zeros(n)
+        normal_stresses = np.zeros(n)
+
+        latitudinal_stress = 0.0
+        for i in range(n - 1, -1, -1):
+            result = self.calculate_stresses(i, latitudinal_stress, longitudinal_stresses[i])
+
+            altitudinal_stresses[i] = result["altitudinal_stress"]
+            latitudinal_stresses[i] = latitudinal_stress
+            longitudinal_friction_stresses[i] = result["longitudinal_friction_stress"]
+            latitudinal_friction_stresses[i] = result["latitudinal_friction_stress"]
+            normal_stresses[i] = result["normal_stress"]
+
+            latitudinal_stress = latitudinal_stress + result["latitudinal_stress_increment"] * \
+                                  self.out_profile.pillar_widths[i]
+
+        return {
+            "longitudinal_stresses": longitudinal_stresses,
+            "altitudinal_stresses": altitudinal_stresses,
+            "latitudinal_stresses": latitudinal_stresses,
+            "longitudinal_friction_stresses": longitudinal_friction_stresses,
+            "latitudinal_friction_stresses": latitudinal_friction_stresses,
+            "normal_stresses": normal_stresses,
+        }
+
+
+@PillarDiskElement.karman_solution
+def karman_solution(self: PillarDiskElement):
+    return KarmanSolution3D(disk_element=self).solution
+
+
+@PillarDiskElement.OutProfile.pillars_longitudinal_stress
+def pillars_longitudinal_stress(self: PillarDiskElement.OutProfile):
+    return self.disk_element.karman_solution["longitudinal_stresses"]
+
+
+@PillarDiskElement.OutProfile.pillars_altitudinal_stress
+def pillars_altitudinal_stress(self: PillarDiskElement.OutProfile):
+    return self.disk_element.karman_solution["altitudinal_stresses"]
+
+
+@PillarDiskElement.OutProfile.pillars_latitudinal_stress
+def pillars_latitudinal_stress(self: PillarDiskElement.OutProfile):
+    return self.disk_element.karman_solution["latitudinal_stresses"]
+
+
+@PillarDiskElement.OutProfile.pillars_normal_stress
+def pillars_normal_stress(self: PillarDiskElement.OutProfile):
+    return self.disk_element.karman_solution["normal_stresses"]
+
+
+@PillarDiskElement.OutProfile.pillars_longitudinal_friction_stress
+def pillars_longitudinal_friction_stress(self: PillarDiskElement.OutProfile):
+    return self.disk_element.karman_solution["longitudinal_friction_stresses"]
+
+
+@PillarDiskElement.OutProfile.pillars_latitudinal_friction_stress
+def pillars_latitudinal_friction_stress(self: PillarDiskElement.OutProfile):
+    return self.disk_element.karman_solution["latitudinal_friction_stresses"]

pyroll_pillar_model_karman-3.1.0b1/pyroll/pillar_model_karman/roll_pass/pillar_disk_element.py

@@ -0,0 +1,24 @@
+import pyroll
+import numpy as np
+
+from pyroll.core import RollPass, Hook
+
+
+@RollPass.DiskElement.extension_class
+class PillarDiskElement(RollPass.DiskElement):
+    karman_solution = Hook[dict]()
+    """Solution of the 3D von Karman's differential equation for this disk element's pillars."""
+
+    longitudinal_direction = Hook[float]()
+    """Regularized sign of the relative velocity between workpiece and roll surface in rolling direction."""
+
+    pillar_latitudinal_directions = Hook[np.ndarray]()
+    """Sign of the lateral material flow direction for each pillar (positive towards the free edge)."""
+
+
+pyroll.core.root_hooks.add(pyroll.core.RollPass.DiskElement.OutProfile.pillars_normal_stress)
+pyroll.core.root_hooks.add(pyroll.core.RollPass.DiskElement.OutProfile.pillars_longitudinal_stress)
+pyroll.core.root_hooks.add(pyroll.core.RollPass.DiskElement.OutProfile.pillars_altitudinal_stress)
+pyroll.core.root_hooks.add(pyroll.core.RollPass.DiskElement.OutProfile.pillars_latitudinal_stress)
+pyroll.core.root_hooks.add(pyroll.core.RollPass.DiskElement.OutProfile.pillars_longitudinal_friction_stress)
+pyroll.core.root_hooks.add(pyroll.core.RollPass.DiskElement.OutProfile.pillars_latitudinal_friction_stress)

pyroll_pillar_model_karman-3.1.0b1/pyroll/pillar_model_karman/roll_pass/stress_solver.py

@@ -0,0 +1,58 @@
+import numpy as np
+
+
+def altitudinal_stress(longitudinal_stress, latitudinal_stress, flow_stress):
+    """Vertical (altitudinal) stress solved from the von Mises yield criterion, neglecting the
+    friction shear stresses therein."""
+    discriminant = 4 * flow_stress ** 2 + 3 * (
+            2 * longitudinal_stress * latitudinal_stress - longitudinal_stress ** 2 - latitudinal_stress ** 2
+    )
+    return (longitudinal_stress + latitudinal_stress) / 2 + 0.5 * np.sqrt(np.maximum(discriminant, 0.0))
+
+
+def normal_stress(
+        altitudinal_stress_, longitudinal_angle, latitudinal_angle,
+        longitudinal_direction, latitudinal_direction, friction_coefficient,
+):
+    """Contact-normal stress from the altitudinal stress."""
+    return altitudinal_stress_ / (
+            1
+            + longitudinal_direction * friction_coefficient * np.tan(longitudinal_angle) / np.cos(latitudinal_angle)
+            + latitudinal_direction * friction_coefficient * np.tan(latitudinal_angle) / np.cos(longitudinal_angle)
+    )
+
+
+def longitudinal_friction_stress(normal_stress_, latitudinal_angle, longitudinal_direction, friction_coefficient):
+    """Coulomb friction stress component acting in rolling direction."""
+    return friction_coefficient * normal_stress_ * np.cos(latitudinal_angle) * longitudinal_direction
+
+
+def latitudinal_friction_stress(normal_stress_, longitudinal_angle, latitudinal_direction, friction_coefficient):
+    """Coulomb friction stress component acting in width direction."""
+    return friction_coefficient * normal_stress_ * np.cos(longitudinal_angle) * latitudinal_direction
+
+
+def longitudinal_stress_increment(
+        normal_stress_, longitudinal_friction_stress_, longitudinal_stress,
+        longitudinal_angle, latitudinal_angle, longitudinal_height_derivative, height,
+):
+    """d(sigma_x)/dx, expanded via the product rule d(sigma*h)/dx = h * d(sigma)/dx + sigma * dh/dx and solved for d(sigma)/dx."""
+    return (
+                   2 * normal_stress_ * np.sin(longitudinal_angle)
+                   / (np.cos(longitudinal_angle) * np.cos(latitudinal_angle))
+                   + 2 * longitudinal_friction_stress_ / np.cos(latitudinal_angle)
+                   - longitudinal_stress * longitudinal_height_derivative
+           ) / height
+
+
+def latitudinal_stress_increment(
+        normal_stress_, latitudinal_friction_stress_, latitudinal_stress,
+        longitudinal_angle, latitudinal_angle, latitudinal_height_derivative, height,
+):
+    """d(sigma_y)/dy expanded via the product rule, analogous to :func:`longitudinal_stress_increment`."""
+    return (
+                   2 * normal_stress_ * np.sin(latitudinal_angle)
+                   / (np.cos(latitudinal_angle) * np.cos(longitudinal_angle))
+                   + 2 * latitudinal_friction_stress_ / np.cos(longitudinal_angle)
+                   - latitudinal_stress * latitudinal_height_derivative
+           ) / height