pyroll-core 2.1.3__tar.gz → 2.1.4__tar.gz

{pyroll_core-2.1.3 → pyroll_core-2.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyroll-core
-Version: 2.1.3
+Version: 2.1.4
 Summary: PyRoll rolling simulation framework - core library.
 Project-URL: Homepage, https://pyroll-project.github.io
 Project-URL: Repository, https://github.com/pyroll-project/pyroll-core
@@ -29,8 +29,14 @@ Requires-Dist: ezdxf
 Requires-Dist: numpy~=1.19
 Requires-Dist: scipy~=1.9
 Requires-Dist: shapely~=2.0
+Provides-Extra: matplotlib
+Requires-Dist: matplotlib~=3.7; extra == 'matplotlib'
 Provides-Extra: plot
 Requires-Dist: matplotlib~=3.7; extra == 'plot'
+Provides-Extra: plotly
+Requires-Dist: kaleido; extra == 'plotly'
+Requires-Dist: pandas~=2.0; extra == 'plotly'
+Requires-Dist: plotly~=5.18; extra == 'plotly'
 Description-Content-Type: text/markdown
 
 # PyRolL Rolling Simulation Framework
@@ -38,6 +44,7 @@ Description-Content-Type: text/markdown
 [![PyPI](https://img.shields.io/pypi/v/pyroll-core)](https://pypi.org/project/pyroll-core/)
 ![Python Versions](https://img.shields.io/pypi/pyversions/pyroll-core)
 [![License](https://img.shields.io/pypi/l/pyroll-core)](LICENSE)
+[![DOI](https://joss.theoj.org/papers/10.21105/joss.06200/status.svg)](https://doi.org/10.21105/joss.06200)
 ![Downloads](https://img.shields.io/pypi/dm/pyroll-core)
 [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/7971/badge)](https://www.bestpractices.dev/projects/7971)
 

{pyroll_core-2.1.3 → pyroll_core-2.1.4}/README.md

@@ -3,6 +3,7 @@
 [![PyPI](https://img.shields.io/pypi/v/pyroll-core)](https://pypi.org/project/pyroll-core/)
 ![Python Versions](https://img.shields.io/pypi/pyversions/pyroll-core)
 [![License](https://img.shields.io/pypi/l/pyroll-core)](LICENSE)
+[![DOI](https://joss.theoj.org/papers/10.21105/joss.06200/status.svg)](https://doi.org/10.21105/joss.06200)
 ![Downloads](https://img.shields.io/pypi/dm/pyroll-core)
 [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/7971/badge)](https://www.bestpractices.dev/projects/7971)
 

{pyroll_core-2.1.3 → pyroll_core-2.1.4}/hatch.toml

@@ -11,20 +11,19 @@ path = ".venv"
 dependencies = [
     "ipython ~= 8.0",
     "pytest ~= 7.0",
-    "matplotlib ~= 3.6",
     "pyroll-report ~= 2.0.0",
-    "jupyter"
+    "jupyter",
 ]
+features = ["plotly", "matplotlib"]
 
 [envs.test]
 path = ""
 dependencies = [
     "pytest ~= 7.0",
-    "matplotlib ~= 3.6",
 ]
 
 [[envs.test.matrix]]
-python = ["3.9", "3.10", "3.11"]
+features = ["matplotlib", "plotly"]
 
 [envs.test.scripts]
 all = "pytest tests"

{pyroll_core-2.1.3 → pyroll_core-2.1.4}/pyproject.toml

@@ -46,6 +46,14 @@ dynamic = ["version"]
 plot = [
     "matplotlib ~= 3.7"
 ]
+matplotlib = [
+    "matplotlib ~= 3.7"
+]
+plotly = [
+    "plotly ~= 5.18",
+    "pandas ~= 2.0",
+    "kaleido"
+]
 
 [project.urls]
 Homepage = "https://pyroll-project.github.io"

{pyroll_core-2.1.3 → pyroll_core-2.1.4}/pyroll/core/__init__.py

@@ -12,7 +12,7 @@ from .hooks import Hook, HookHost, HookFunction, root_hooks
 from .disk_elements import DiskElementUnit
 from .config import Config, config
 
-VERSION = "2.1.3"
+VERSION = "2.1.4"
 
 root_hooks.extend(
     [
@@ -32,3 +32,16 @@ root_hooks.extend(
         PassSequence.log_elongation,
     ]
 )
+
+# determine available plotting backend, plotly is preferred
+try:
+    import plotly as _
+    PLOTTING_BACKEND = "plotly"
+
+except ImportError:
+    try:
+        import matplotlib as _
+        PLOTTING_BACKEND = "matplotlib"
+
+    except ImportError:
+        PLOTTING_BACKEND = None

{pyroll_core-2.1.3 → pyroll_core-2.1.4}/pyroll/core/config.py

@@ -168,3 +168,25 @@ class Config:
 
     ROLL_SURFACE_DISCRETIZATION_COUNT = 100
     """Count of discrete points used to describe the roll surface."""
+
+    UNIVERSAL_GAS_CONSTANT = 8.31446261815324
+    """Universal gas constant R."""
+
+    BOLTZMANN_CONSTANT = 1.380649e-23
+    """Boltzmann constant kB."""
+    
+    STEFAN_BOLTZMANN_CONSTANT = 5.670374419e-8
+    """Stefan-Boltzmann radiation constant σ."""
+
+    AVOGADRO_CONSTANT = 6.02214076e23
+    """Avogadro constant NA."""
+
+    STANDARD_GRAVITY = 9.80665
+    """Standard acceleration of gravity g0."""
+
+    PROFILE_CONTOUR_REFINEMENT = 0
+    """Refine the line string of profile contours with more intermediate points. 
+    Higher integers mean finer. Values < 1 disable this feature."""
+
+    GROOVE_RADIUS_POINT_COUNT = 20
+    """Count of points used to represent the radii in a generic elongation groove as line string."""

{pyroll_core-2.1.3 → pyroll_core-2.1.4}/pyroll/core/grooves/base.py

@@ -65,22 +65,44 @@ class GrooveBase(ReprMixin):
         }
 
     def plot(self, **kwargs):
-        try:
-            import matplotlib.pyplot as plt
-        except ImportError as e:
+        from pyroll.core import PLOTTING_BACKEND
+        if PLOTTING_BACKEND is None:
             raise RuntimeError(
-                "This method is only available if matplotlib is installed in the environment. "
-                "You may install it using the 'plot' extra of pyroll-core."
-            ) from e
+                "This method is only available if matplotlib or plotly is installed in the environment. "
+                "You may install one of them using the 'plot', 'matplotlib' or 'plotly' extras of pyroll-core."
+            )
+
+        if PLOTTING_BACKEND == "matplotlib":
+            import matplotlib.pyplot as plt
+
+            fig: plt.Figure = plt.figure(**kwargs)
+            ax: plt.Axes = fig.subplots()
+
+            ax.set_ylabel("y")
+            ax.set_xlabel("z")
+
+            ax.set_aspect("equal", "datalim")
+            ax.grid(lw=0.5)
+
+            ax.plot(*self.contour_line.xy, color="k")
+            return fig
+
+        if PLOTTING_BACKEND == "plotly":
+            import plotly.express as px
+
+            fig = px.line(
+                x=self.contour_line.xy[0],
+                y=self.contour_line.xy[1],
+                labels={"y": "y", "x": "z"},
+                template="simple_white",
+            )
 
-        fig: plt.Figure = plt.figure(**kwargs)
-        ax: plt.Axes = fig.subplots()
+            fig.update_traces(line_color="black")
 
-        ax.set_ylabel("y")
-        ax.set_xlabel("z")
+            fig.update_yaxes(
+                scaleanchor="x",
+                scaleratio=1
+            )
 
-        ax.set_aspect("equal", "datalim")
-        ax.grid(lw=0.5)
+            return fig
 
-        ax.plot(*self.contour_line.xy, color="k")
-        return fig

{pyroll_core-2.1.3 → pyroll_core-2.1.4}/pyroll/core/grooves/generic_elongation.py

@@ -193,22 +193,22 @@ class GenericElongationGroove(GrooveBase, ReprMixin):
         yield self.z0, self.y0
 
         if not np.isclose(self.z1, self.z3):
-            for z in np.linspace(self.z1, self.z3, 20, endpoint=False):
+            for z in np.linspace(self.z1, self.z3, Config.GROOVE_RADIUS_POINT_COUNT, endpoint=False):
                 yield z, self._r1_contour_line(z)
 
         if not np.isclose(self.z3, self.z4):
             yield self.z3, self.y3
 
         if not np.isclose(self.z4, self.z5):
-            for z in np.linspace(self.z4, self.z5, 20, endpoint=False):
+            for z in np.linspace(self.z4, self.z5, Config.GROOVE_RADIUS_POINT_COUNT, endpoint=False):
                 yield z, self._r2_contour_line(z)
 
         if not np.isclose(self.z5, self.z6):
-            for z in np.linspace(self.z5, self.z6, 20, endpoint=False):
+            for z in np.linspace(self.z5, self.z6, Config.GROOVE_RADIUS_POINT_COUNT, endpoint=False):
                 yield z, self._r3_contour_line(z)
 
         if not np.isclose(self.z6, self.z7):
-            for z in np.linspace(self.z6, self.z7, 20, endpoint=False):
+            for z in np.linspace(self.z6, self.z7, Config.GROOVE_RADIUS_POINT_COUNT, endpoint=False):
                 yield z, self._r4_contour_line(z)
 
         yield self.z9, self.y9

{pyroll_core-2.1.3 → pyroll_core-2.1.4}/pyroll/core/grooves/spline.py

@@ -1,9 +1,9 @@
-from typing import Union, Tuple, Iterable, Optional
-
 import numpy as np
 import scipy.interpolate
+from pathlib import Path
 from ezdxf import readfile
-from shapely.geometry import Polygon, LineString, Point
+from shapely.geometry import Polygon, LineString
+from typing import Union, Tuple, Iterable, Optional
 
 from pyroll.core.grooves import GrooveBase
 
@@ -93,7 +93,7 @@ class SplineGroove(GrooveBase):
         return self._local_depth(z)
 
     @classmethod
-    def from_dxf_drawing(cls, filepath: str, classifiers: Iterable[str], usable_width: Optional[float] = None,
+    def from_dxf_drawing(cls, filepath: Path, classifiers: Iterable[str], usable_width: Optional[float] = None,
                          arc_discretization: int = 1000) -> 'SplineGroove':
         """
         Creates a spline groove with a given contour line as defined inside the .dxf drawing.

{pyroll_core-2.1.3 → pyroll_core-2.1.4}/pyroll/core/profile/profile.py

@@ -7,6 +7,7 @@ from shapely.affinity import translate, rotate
 from shapely.geometry import Point, LinearRing, Polygon, LineString
 from shapely.ops import clip_by_rect, unary_union
 
+from ..config import Config
 from ..grooves import GrooveBase
 from ..hooks import HookHost, Hook
 
@@ -106,6 +107,30 @@ class Profile(HookHost):
     scale_thickness = Hook[float]()
     """Thickness of the scale covering the profile."""
 
+    deformation_activation_energy = Hook[float]()
+    """Activation energy of deformation especially for calculation of Zener-Holomon-Parameter."""
+
+    martensite_start_temperature = Hook[float]()
+    """Martensite start temperature for the given chemical composition of the profile."""
+
+    martensite_finish_temperature = Hook[float]()
+    """Martensite finish temperature for the given chemical composition of the profile."""
+
+    bainite_start_temperature = Hook[float]()
+    """Bainite start temperature for the given chemical composition of the profile."""
+
+    bainite_finish_temperature = Hook[float]()
+    """Bainite finish temperature for the given chemical composition of the profile."""
+
+    ae1_temperature = Hook[float]()
+    """Temperature at which austenite starts to transform into a mixture of ferrite and cementite during cooling."""
+
+    ae3_temperature = Hook[float]()
+    """Temperature above which the transformation of austenite into a mixture of ferrite and cementite is complete during cooling."""
+
+    vickers_hardness = Hook[float]()
+    """Vickers hardness of the cold profile material."""
+
     def __init__(self, **kwargs):
         """Using the ``__init__`` is not recommended, use one of the factory class methods instead."""
         self.t = 0
@@ -190,7 +215,7 @@ class Profile(HookHost):
         polygon = clip_by_rect(poly, -width / 2, -math.inf, width / 2, math.inf)
 
         return cls(
-            cross_section=polygon,
+            cross_section=refine_cross_section(polygon),
             classifiers=set(groove.classifiers),
             **kwargs
         )
@@ -340,7 +365,6 @@ class Profile(HookHost):
         :raises ValueError: if arguments are out of range
         """
 
-
         return HexagonProfile(side, height, diagonal, corner_radius, **kwargs)
 
     def local_height(self, z: float) -> float:
@@ -390,26 +414,47 @@ class Profile(HookHost):
                 raise ValueError("Value of self.material is neither a string or a collection of strings.")
 
     def plot(self, **kwargs):
-        try:
-            import matplotlib.pyplot as plt
-        except ImportError as e:
+        from pyroll.core import PLOTTING_BACKEND
+        if PLOTTING_BACKEND is None:
             raise RuntimeError(
-                "This method is only available if matplotlib is installed in the environment. "
-                "You may install it using the 'plot' extra of pyroll-core."
-            ) from e
+                "This method is only available if matplotlib or plotly is installed in the environment. "
+                "You may install one of them using the 'plot', 'matplotlib' or 'plotly' extras of pyroll-core."
+            )
 
-        fig: plt.Figure = plt.figure(**kwargs)
-        ax: plt.Axes = fig.subplots()
+        if PLOTTING_BACKEND == "matplotlib":
+            import matplotlib.pyplot as plt
+
+            fig: plt.Figure = plt.figure(**kwargs)
+            ax: plt.Axes = fig.subplots()
+
+            ax.set_ylabel("y")
+            ax.set_xlabel("z")
+
+            ax.set_aspect("equal", "datalim")
+            ax.grid(lw=0.5)
+
+            ax.plot(*self.cross_section.boundary.xy, color="k")
+            ax.fill(*self.cross_section.boundary.xy, color="k", alpha=0.5)
+            return fig
+
+        if PLOTTING_BACKEND == "plotly":
+            import plotly.express as px
 
-        ax.set_ylabel("y")
-        ax.set_xlabel("z")
+            fig = px.line(
+                x=self.cross_section.boundary.xy[0],
+                y=self.cross_section.boundary.xy[1],
+                labels={"y": "y", "x": "z"},
+                template="simple_white",
+            )
+
+            fig.data[0].fill = "toself"
 
-        ax.set_aspect("equal", "datalim")
-        ax.grid(lw=0.5)
+            fig.update_yaxes(
+                scaleanchor="x",
+                scaleratio=1
+            )
 
-        ax.plot(*self.cross_section.boundary.xy, color="k")
-        ax.fill(*self.cross_section.boundary.xy, color="k", alpha=0.5)
-        return fig
+            return fig
 
 
 class RoundProfile(Profile):
@@ -447,7 +492,7 @@ class RoundProfile(Profile):
         circle = center.buffer(radius)
 
         super().__init__(
-            cross_section=circle,
+            cross_section=refine_cross_section(circle),
             classifiers={"round"},
             **kwargs
         )
@@ -506,7 +551,7 @@ class BoxProfile(Profile):
         polygon = polygon.buffer(corner_radius)
 
         super().__init__(
-            cross_section=polygon,
+            cross_section=refine_cross_section(polygon),
             classifiers={"box"},
             **kwargs
         )
@@ -560,7 +605,7 @@ class DiamondProfile(Profile):
         polygon = polygon.buffer(corner_radius)
 
         super().__init__(
-            cross_section=polygon,
+            cross_section=refine_cross_section(polygon),
             classifiers={"diamond"},
             **kwargs
         )
@@ -621,7 +666,7 @@ class SquareProfile(Profile):
         polygon = polygon.buffer(corner_radius)
 
         super().__init__(
-            cross_section=polygon,
+            cross_section=refine_cross_section(polygon),
             classifiers={"square", "diamond"},
             **kwargs
         )
@@ -713,7 +758,7 @@ class HexagonProfile(Profile):
         polygon = polygon.buffer(corner_radius)
 
         super().__init__(
-            cross_section=polygon,
+            cross_section=refine_cross_section(polygon),
             classifiers={"hexagon"},
             **kwargs
         )
@@ -739,3 +784,10 @@ class HexagonProfile(Profile):
             side=self._side,
             diagonal=self._diagonal,
             corner_radius=self._corner_radius)
+
+
+def refine_cross_section(cross_section: Polygon):
+    if Config.PROFILE_CONTOUR_REFINEMENT < 1:
+        return cross_section
+
+    return cross_section.segmentize(cross_section.boundary.length / Config.PROFILE_CONTOUR_REFINEMENT)

{pyroll_core-2.1.3 → pyroll_core-2.1.4}/pyroll/core/repr.py

@@ -48,38 +48,53 @@ class ReprMixin(ABC):
     def _repr_html_(self):
         """HTML repr for IPython."""
 
-        buf = [f"<table><tr><th colspan=2 style='text-align:center'>{html.escape(str(self), True)}</th></tr>"]
+        buf = [f"<details><summary style='font-weight:bold'>{html.escape(str(self), True)}</summary><table>"]
 
         for name, value in sorted(self.__attrs__.items()):
             if hasattr(value, "_repr_html_"):
                 r = value._repr_html_()
+            elif isinstance(value, list) or isinstance(value, set):
+                item_reprs = (
+                    item._repr_html_() if hasattr(item, "_repr_html_") else html.escape(repr(item), True)
+                    for item in value
+                )
+                r = f"<table style='margin:0'>{''.join(f'<tr><td>{item}</td></tr>' for item in item_reprs)}</table>"
             else:
                 r = html.escape(repr(value), True)
             buf.append(f"<tr><td style='text-align:left'>{html.escape(name, True)}</td><td>{r}</td></tr>")
 
-        buf.append("</table>")
+        buf.append("</table></details>")
 
         table = ''.join(buf)
 
         try:
             plot = self.plot()
 
-            import matplotlib.pyplot as plt
-            import re
+            from pyroll.core import PLOTTING_BACKEND
 
-            with StringIO() as sio:
-                plot.savefig(sio, format="svg")
-                plt.close(plot)
+            if PLOTTING_BACKEND == "matplotlib":
+                import matplotlib.pyplot as plt
+                with StringIO() as sio:
+                    plot.savefig(sio, format="svg")
                 svg = sio.getvalue()
-
-                return (
-                        "<table>"
-                        + "<tr><td style='text-align: center'>" + svg + "</td></tr>"
-                        + "<tr><td style='text-align: left'>" + table + "</td></tr>"
-                        + "</table>"
-                )
-
-        except (NotImplementedError, ImportError, AttributeError, TypeError):
+                plt.close(plot)
+            if PLOTTING_BACKEND == "plotly":
+                from plotly.io import to_image
+                svg = to_image(
+                    plot,
+                    format="svg",
+                    width=600,
+                    height=400
+                ).decode("utf-8")
+
+            return (
+                    "<table>"
+                    + "<tr><td style='text-align: center'>" + svg + "</td></tr>"
+                    + "<tr><td style='text-align: left'>" + table + "</td></tr>"
+                    + "</table>"
+            )
+
+        except (NotImplementedError, ImportError, AttributeError, TypeError) as e:
             return table
 
     def __rich_repr__(self):

{pyroll_core-2.1.3 → pyroll_core-2.1.4}/pyroll/core/roll_pass/deformation_unit.py

@@ -54,6 +54,9 @@ class DeformationUnit(Unit):
     deformation_resistance = Hook[float]()
     """Equivalent deformation resistance (mean flow stress increased by deformation efficiency)."""
 
+    zener_holomon_parameter = Hook[float]()
+    """Temperature corrected strain rate acc. to Zener and Holomon."""
+
     class Profile(Unit.Profile):
         """Represents a profile in context of a deformation unit."""
 

{pyroll_core-2.1.3 → pyroll_core-2.1.4}/pyroll/core/roll_pass/hookimpls/deformation_unit.py

@@ -1,6 +1,7 @@
 import numpy as np
 
 from ..roll_pass import DeformationUnit
+from ...config import Config
 
 
 @DeformationUnit.draught
@@ -76,3 +77,10 @@ def strain_rate(self: DeformationUnit):
 @DeformationUnit.free_surface_area
 def free_surface_area(self: DeformationUnit):
     return self.surface_area - self.contact_area
+
+
+@DeformationUnit.zener_holomon_parameter
+def zener_holomon_parameter(self: DeformationUnit):
+    return self.strain_rate * np.exp(self.in_profile.deformation_activation_energy / (
+            Config.UNIVERSAL_GAS_CONSTANT * self.in_profile.temperature
+    ))

{pyroll_core-2.1.3 → pyroll_core-2.1.4}/pyroll/core/roll_pass/hookimpls/helpers.py

@@ -6,11 +6,12 @@ from shapely.affinity import rotate
 
 from ..roll_pass import RollPass
 from ..three_roll_pass import ThreeRollPass
+from ...profile.profile import refine_cross_section
 
 
 def out_cross_section(rp: RollPass, width: float) -> Polygon:
     poly = Polygon(np.concatenate([cl.coords for cl in rp.contour_lines]))
-    return clip_by_rect(poly, -width / 2, -math.inf, width / 2, math.inf)
+    return refine_cross_section(clip_by_rect(poly, -width / 2, -math.inf, width / 2, math.inf))
 
 
 def out_cross_section3(rp: ThreeRollPass, width: float) -> Polygon:
@@ -20,4 +21,4 @@ def out_cross_section3(rp: ThreeRollPass, width: float) -> Polygon:
         poly = clip_by_rect(poly, -math.inf, -width / 2, math.inf, math.inf)
         poly = rotate(poly, angle=120, origin=(0, 0))
 
-    return poly
+    return refine_cross_section(poly)

{pyroll_core-2.1.3 → pyroll_core-2.1.4}/pyroll/core/roll_pass/roll_pass.py

@@ -96,6 +96,9 @@ class RollPass(DiskElementUnit, DeformationUnit):
     forward_slip_ratio = Hook[float]()
     """Ratio of forward slip of the roll gap."""
 
+    location = Hook[float]()
+    """Coordinate of the passes high point in rolling direction."""
+
     def __init__(
             self,
             roll: BaseRoll,
@@ -234,27 +237,12 @@ class RollPass(DiskElementUnit, DeformationUnit):
             """Represents an outgoing profile of a disk element unit."""
 
     def plot(self, **kwargs):
-        try:
-            import matplotlib.pyplot as plt
-        except ImportError as e:
+        from pyroll.core import PLOTTING_BACKEND
+        if PLOTTING_BACKEND is None:
             raise RuntimeError(
-                "This method is only available if matplotlib is installed in the environment. "
-                "You may install it using the 'plot' extra of pyroll-core."
-            ) from e
-
-        fig: plt.Figure = plt.figure(**kwargs)
-        ax: plt.Axes
-        axl: plt.Axes
-        ax = fig.subplots()
-
-        if self.label:
-            ax.set_title(f"Roll Pass '{self.label}'")
-
-        ax.set_ylabel("y")
-        ax.set_xlabel("z")
-
-        ax.set_aspect("equal", "datalim")
-        ax.grid(lw=0.5)
+                "This method is only available if matplotlib or plotly is installed in the environment. "
+                "You may install one of them using the 'plot', 'matplotlib' or 'plotly' extras of pyroll-core."
+            )
 
         def oriented(geom):
             orientation = self.orientation
@@ -271,38 +259,124 @@ class RollPass(DiskElementUnit, DeformationUnit):
                 return rotate(geom, orientation, (0, 0))
             return geom
 
-        artists = []
-
-        if self.in_profile:
-            artists += ax.fill(
-                *oriented(self.in_profile.cross_section.boundary).xy,
-                alpha=0.5, color="red", label="in profile"
-            )
-            artists += ax.fill(
-                *oriented(self.in_profile.equivalent_rectangle.boundary).xy,
-                fill=False, color="red", ls="--", label="in eq. rectangle"
-            )
-
-        if self.out_profile:
-            artists += ax.fill(
-                *oriented(self.out_profile.cross_section.boundary).xy,
-                alpha=0.5, color="blue", label="out profile"
-            )
-            artists += ax.fill(
-                *oriented(self.out_profile.equivalent_rectangle.boundary).xy,
-                fill=False, color="blue", ls="--", label="out eq. rectangle"
-            )
-
-        c = None
-        for cl in self.contour_lines:
-            c = ax.plot(*oriented(cl).xy, color="k", label="roll surface")
-
-        if c is not None:
-            artists += c
-
-        ncols = len(artists) // 2 + 1
-
-        ax.legend(handles=artists, ncols=ncols, loc='lower center')
-        fig.set_layout_engine('constrained')
+        if PLOTTING_BACKEND == "matplotlib":
+            import matplotlib.pyplot as plt
 
-        return fig
+            fig: plt.Figure = plt.figure(**kwargs)
+            ax: plt.Axes
+            axl: plt.Axes
+            ax = fig.subplots()
+
+            if self.label:
+                ax.set_title(f"Roll Pass '{self.label}'")
+
+            ax.set_ylabel("y")
+            ax.set_xlabel("z")
+
+            ax.set_aspect("equal", "datalim")
+            ax.grid(lw=0.5)
+
+            artists = []
+
+            if self.in_profile:
+                artists += ax.fill(
+                    *oriented(self.in_profile.cross_section.boundary).xy,
+                    alpha=0.5, color="red", label="in profile"
+                )
+                artists += ax.fill(
+                    *oriented(self.in_profile.equivalent_rectangle.boundary).xy,
+                    fill=False, color="red", ls="--", label="in eq. rectangle"
+                )
+
+            if self.out_profile:
+                artists += ax.fill(
+                    *oriented(self.out_profile.cross_section.boundary).xy,
+                    alpha=0.5, color="blue", label="out profile"
+                )
+                artists += ax.fill(
+                    *oriented(self.out_profile.equivalent_rectangle.boundary).xy,
+                    fill=False, color="blue", ls="--", label="out eq. rectangle"
+                )
+
+            c = None
+            for cl in self.contour_lines:
+                c = ax.plot(*oriented(cl).xy, color="k", label="roll surface")
+
+            if c is not None:
+                artists += c
+
+            ncols = len(artists) // 2 + 1
+
+            ax.legend(handles=artists, ncols=ncols, loc='lower center')
+            fig.set_layout_engine('constrained')
+
+            return fig
+
+        if PLOTTING_BACKEND == "plotly":
+            import plotly.graph_objects as go
+
+            fig = go.Figure(layout=go.Layout(
+                xaxis=dict(
+                    title="z",
+                ),
+                yaxis=dict(
+                    title="y",
+                    scaleanchor="x",
+                    scaleratio=1
+                ),
+                title=f"Roll Pass '{self.label}'" if self.label else None,
+                template="simple_white"
+            ))
+
+            if self.in_profile:
+                coords = oriented(self.in_profile.cross_section.boundary).xy
+                fig.add_trace(go.Scatter(
+                    x=np.array(coords[0]),
+                    y=np.array(coords[1]),
+                    mode="lines",
+                    fill="toself",
+                    line=dict(color="red"),
+                    name="in profile"
+                ))
+                coords = oriented(self.in_profile.equivalent_rectangle.boundary).xy
+                fig.add_trace(go.Scatter(
+                    x=np.array(coords[0]),
+                    y=np.array(coords[1]),
+                    mode="lines",
+                    line=dict(color="red", dash="dash"),
+                    name="in eq. rectangle"
+                ))
+
+            if self.out_profile:
+                coords = oriented(self.out_profile.cross_section.boundary).xy
+                fig.add_trace(go.Scatter(
+                    x=np.array(coords[0]),
+                    y=np.array(coords[1]),
+                    mode="lines",
+                    fill="toself",
+                    line=dict(color="blue"),
+                    name="out profile"
+                ))
+                coords = oriented(self.out_profile.equivalent_rectangle.boundary).xy
+                fig.add_trace(go.Scatter(
+                    x=np.array(coords[0]),
+                    y=np.array(coords[1]),
+                    mode="lines",
+                    line=dict(color="blue", dash="dash"),
+                    name="out eq. rectangle"
+                ))
+
+            show_in_legend = True
+            for cl in self.contour_lines:
+                coords = oriented(cl).xy
+                fig.add_trace(go.Scatter(
+                    x=np.array(coords[0]),
+                    y=np.array(coords[1]),
+                    mode="lines",
+                    line=dict(color="black"),
+                    name="roll surface",
+                    showlegend=show_in_legend
+                ))
+                show_in_legend = False
+
+            return fig

pyroll_core-2.1.4/pyroll/core/transport/hookimpls.py

@@ -0,0 +1,52 @@
+from .transport import Transport
+
+
+@Transport.OutProfile.strain
+def out_strain(self: Transport.OutProfile):
+    """Assume total recrystallization during transport."""
+    return 0
+
+
+@Transport.duration
+def duration(self: Transport):
+    if self.has_set_or_cached("length"):
+        return self.length / self.velocity
+
+
+@Transport.velocity(
+    trylast=True  # do not override getting from in_profile
+)
+def conti_velocity(self: Transport):
+    if self.has_set_or_cached("length"):  # probably indicates conti process
+        return self.prev.velocity
+
+
+@Transport.environment_temperature
+def environment_temperature(self):
+    return 293
+
+
+@Transport.length
+def length_from_roll_pass_positions(self: Transport, cycle):
+    if cycle:
+        return None
+
+    from ..roll_pass import RollPass
+    next_pass = self.next_of(RollPass)
+    prev_pass = self.prev_of(RollPass)
+
+    if next_pass.has_value("location") and prev_pass.has_value("location"):
+        entry = next_pass.entry_point if next_pass.has_value("entry_point") else 0
+        length = 0
+
+        current = self
+        while not (current.next is next_pass):
+            length += current.next.length
+            current = current.next
+
+        current = self
+        while not (current.prev is prev_pass):
+            length += current.prev.length
+            current = current.prev
+
+        return next_pass.location - prev_pass.location + entry - length

{pyroll_core-2.1.3 → pyroll_core-2.1.4}/pyroll/core/unit/hookimpls.py

@@ -23,20 +23,20 @@ def surface_area(self: Unit):
 
 
 @Unit.length
-def length(self: Unit):
-    if self.has_set_or_cached("duration"):
+def length(self: Unit, cycle):
+    if not cycle and self.has_value("duration"):
         return self.velocity * self.duration
 
 
 @Unit.duration
-def duration(self: Unit):
-    if self.has_set_or_cached("length"):
+def duration(self: Unit, cycle):
+    if not cycle and self.has_value("length"):
         return self.length / self.velocity
 
 
 @Unit.velocity
 def velocity(self: Unit):
-    if self.in_profile.has_set_or_cached("velocity"):
+    if self.in_profile.has_value("velocity"):
         return self.in_profile.velocity
 
 

{pyroll_core-2.1.3 → pyroll_core-2.1.4}/pyroll/core/unit/unit.py

@@ -218,6 +218,20 @@ class Unit(HookHost):
         """List of the subunits."""
         return self._subunits
 
+    @property
+    def profiles(self) -> List[BaseProfile]:
+        """Returns a list of all profiles appearing in this unit.
+        The list contains in and out profiles of all subunits and this unit itself in the order of rolling direction.
+        This property recurses into all subunits."""
+
+        def _yield_profiles():
+            yield self.in_profile
+            for u in self._subunits:
+                yield from u.profiles
+            yield self.out_profile
+
+        return list(_yield_profiles())
+
     class Profile(BaseProfile):
         """Represents a profile in context of a unit."""
 

pyroll_core-2.1.3/pyroll/core/transport/hookimpls.py

@@ -1,26 +0,0 @@
-from .transport import Transport
-
-
-@Transport.OutProfile.strain
-def out_strain(self: Transport.OutProfile):
-    """Assume total recrystallization during transport."""
-    return 0
-
-
-@Transport.duration
-def duration(self: Transport):
-    if self.has_set_or_cached("length"):
-        return self.length / self.velocity
-
-
-@Transport.velocity(
-    trylast=True  # do not override getting from in_profile
-)
-def conti_velocity(self: Transport):
-    if self.has_set_or_cached("length"):  # probably indicates conti process
-        return self.prev.velocity
-
-
-@Transport.environment_temperature
-def environment_temperature(self):
-    return 293