pyroll-core 2.1.2.post0__tar.gz → 2.1.3__tar.gz

{pyroll_core-2.1.2.post0 → pyroll_core-2.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyroll-core
-Version: 2.1.2.post0
+Version: 2.1.3
 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
@@ -25,6 +25,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.9
+Requires-Dist: ezdxf
 Requires-Dist: numpy~=1.19
 Requires-Dist: scipy~=1.9
 Requires-Dist: shapely~=2.0
@@ -38,6 +39,8 @@ Description-Content-Type: text/markdown
 ![Python Versions](https://img.shields.io/pypi/pyversions/pyroll-core)
 [![License](https://img.shields.io/pypi/l/pyroll-core)](LICENSE)
 ![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)
+
 
 Welcome to The PyRolL Project!
 
@@ -46,6 +49,25 @@ The current focus lies on groove rolling in elongation grooves.
 The core package includes the basic data structures and algorithms.
 Further functionality is provided via [extension packages](https://pyroll.readthedocs.io/en/latest/extensions/index.html) and model approaches are provided via [plugin packages](https://pyroll.readthedocs.io/en/latest/plugins/index.html).
 
+## Aim and Scope
+
+Publications in the field of groove rolling simulation are, to the authors knowledge, characterized by lack of reproducibility, mainly because often details are missing regarding implementation or numerical solution procedure or the provided equations are erroneous.
+Very few authors provide their source code alongside their publications.
+PyRolL aims to change this by providing an open basis for model and methodology development.
+The PyRolL Core package hosted in this repository is the common base dependency to refer to.
+Plugins to the core provide model approaches for the partial problems to be described in a rolling simulation, which include mechanical, thermal, material behavior and more.
+The library of available models is constantly growing and can be extended by everyone.
+Extensions provide application logic and numerical procedures helping to analyse the subject rolling process regarding its technical feasibility, optimization potential, identity error sources, or, to design a new process.
+PyRolL is therefore a tool for model developers, either with broad focus or specialists, wishing to try out for example a new physical material model within a real process simulation, as well as for technologists wishing to investigate a concrete process.
+Currently, there is no click'n'run graphical user interface (GUI) provided, at least basic knowledge of programming in general and Python in particular is needed to use the software.
+Nevertheless, this is also recommended to leverage the full power of PyRolL.
+
+## Documentation
+
+See the [documentation](https://pyroll.readthedocs.io/en/latest) to learn about basic concepts and
+usage.
+The documentation of version 1.0 can be found [here](https://pyroll.readthedocs.io/en/stable).
+
 ## Versions
 
 The main branch of this repository contains the code of the version 2.0 of PyRolL.
@@ -68,12 +90,6 @@ It is recommended to develop new plugins and extensions only for 2.0.
     - Introduction of disk elements for incremental modelling in rolling direction.
     - Nestable units (esp. pass sequences and disk elements).
 
-## Documentation
-
-See the [documentation](https://pyroll.readthedocs.io/en/latest) to learn about basic concepts and
-usage.
-The documentation of version 1.0 can be found [here](https://pyroll.readthedocs.io/en/stable).
-
 ## License
 
 The project is licensed under the [BSD 3-Clause license](LICENSE).

{pyroll_core-2.1.2.post0 → pyroll_core-2.1.3}/README.md

@@ -4,6 +4,8 @@
 ![Python Versions](https://img.shields.io/pypi/pyversions/pyroll-core)
 [![License](https://img.shields.io/pypi/l/pyroll-core)](LICENSE)
 ![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)
+
 
 Welcome to The PyRolL Project!
 
@@ -12,6 +14,25 @@ The current focus lies on groove rolling in elongation grooves.
 The core package includes the basic data structures and algorithms.
 Further functionality is provided via [extension packages](https://pyroll.readthedocs.io/en/latest/extensions/index.html) and model approaches are provided via [plugin packages](https://pyroll.readthedocs.io/en/latest/plugins/index.html).
 
+## Aim and Scope
+
+Publications in the field of groove rolling simulation are, to the authors knowledge, characterized by lack of reproducibility, mainly because often details are missing regarding implementation or numerical solution procedure or the provided equations are erroneous.
+Very few authors provide their source code alongside their publications.
+PyRolL aims to change this by providing an open basis for model and methodology development.
+The PyRolL Core package hosted in this repository is the common base dependency to refer to.
+Plugins to the core provide model approaches for the partial problems to be described in a rolling simulation, which include mechanical, thermal, material behavior and more.
+The library of available models is constantly growing and can be extended by everyone.
+Extensions provide application logic and numerical procedures helping to analyse the subject rolling process regarding its technical feasibility, optimization potential, identity error sources, or, to design a new process.
+PyRolL is therefore a tool for model developers, either with broad focus or specialists, wishing to try out for example a new physical material model within a real process simulation, as well as for technologists wishing to investigate a concrete process.
+Currently, there is no click'n'run graphical user interface (GUI) provided, at least basic knowledge of programming in general and Python in particular is needed to use the software.
+Nevertheless, this is also recommended to leverage the full power of PyRolL.
+
+## Documentation
+
+See the [documentation](https://pyroll.readthedocs.io/en/latest) to learn about basic concepts and
+usage.
+The documentation of version 1.0 can be found [here](https://pyroll.readthedocs.io/en/stable).
+
 ## Versions
 
 The main branch of this repository contains the code of the version 2.0 of PyRolL.
@@ -34,12 +55,6 @@ It is recommended to develop new plugins and extensions only for 2.0.
     - Introduction of disk elements for incremental modelling in rolling direction.
     - Nestable units (esp. pass sequences and disk elements).
 
-## Documentation
-
-See the [documentation](https://pyroll.readthedocs.io/en/latest) to learn about basic concepts and
-usage.
-The documentation of version 1.0 can be found [here](https://pyroll.readthedocs.io/en/stable).
-
 ## License
 
 The project is licensed under the [BSD 3-Clause license](LICENSE).

{pyroll_core-2.1.2.post0 → pyroll_core-2.1.3}/pyproject.toml

@@ -37,6 +37,7 @@ dependencies = [
     "numpy ~= 1.19",
     "scipy ~= 1.9",
     "shapely ~= 2.0",
+    "ezdxf"
 ]
 
 dynamic = ["version"]

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

@@ -1,7 +1,7 @@
 from . import shapes as _
 
 from .grooves import *
-from .transport import Transport
+from .transport import Transport, CoolingPipe
 from .roll_pass import RollPass, DeformationUnit, ThreeRollPass
 from .unit import Unit
 from .roll import Roll
@@ -12,23 +12,23 @@ from .hooks import Hook, HookHost, HookFunction, root_hooks
 from .disk_elements import DiskElementUnit
 from .config import Config, config
 
-VERSION = "2.1.2.post0"
+VERSION = "2.1.3"
 
-root_hooks.update(
-    {
+root_hooks.extend(
+    [
         RollPass.roll_force,
         RollPass.Roll.roll_torque,
         RollPass.elongation_efficiency,
-        RollPass.OutProfile.filling_ratio,
-        RollPass.OutProfile.cross_section_filling_ratio,
-        RollPass.OutProfile.filling_error,
-        RollPass.OutProfile.cross_section_error,
+        Unit.power,
         Unit.OutProfile.cross_section,
+        Unit.OutProfile.classifiers,
         Unit.OutProfile.strain,
         Unit.OutProfile.length,
-        Unit.OutProfile.classifiers,
         Unit.OutProfile.t,
+        RollPass.OutProfile.filling_ratio,
+        RollPass.OutProfile.cross_section_filling_ratio,
+        RollPass.OutProfile.filling_error,
+        RollPass.OutProfile.cross_section_error,
         PassSequence.log_elongation,
-        Unit.power,
-    }
+    ]
 )

{pyroll_core-2.1.2.post0 → pyroll_core-2.1.3}/pyroll/core/grooves/equivalent_ripped_groove.py

@@ -20,6 +20,7 @@ class EquivalentRibbedGroove(GenericElongationGroove):
             nominal_outer_diameter: float,
             usable_width: float,
             depth: float,
+            rib_flank_angle: Optional[float] = None,
 
             pad_angle: float = 0,
             **kwargs
@@ -42,6 +43,13 @@ class EquivalentRibbedGroove(GenericElongationGroove):
         :param kwargs: more keyword arguments passed to the GenericElongationGroove constructor
         """
 
+        self.nominal_outer_diameter = nominal_outer_diameter
+        self.base_body_height = base_body_height
+        self.rib_distance = rib_distance
+        self.rib_width = rib_width
+        self.rib_flank_angle = rib_flank_angle
+
+
         pad_angle = np.deg2rad(pad_angle)
         rib_angle = np.deg2rad(rib_angle)
 

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

@@ -2,7 +2,8 @@ from typing import Union, Tuple, Iterable, Optional
 
 import numpy as np
 import scipy.interpolate
-from shapely.geometry import Polygon, LineString
+from ezdxf import readfile
+from shapely.geometry import Polygon, LineString, Point
 
 from pyroll.core.grooves import GrooveBase
 
@@ -18,7 +19,7 @@ class SplineGroove(GrooveBase):
     ):
         """
         :param contour_points: an iterable of contour points to be used for the spline
-        :param classifiers: an interable of string keys used as type classifiers
+        :param classifiers: an iterable of string keys used as type classifiers
         :param usable_width: the usable width to assume for this instance, if None, the maximum width will be used
         """
         contour_points = np.asarray(contour_points, dtype="float64")
@@ -90,3 +91,48 @@ class SplineGroove(GrooveBase):
 
     def local_depth(self, z) -> Union[float, np.ndarray]:
         return self._local_depth(z)
+
+    @classmethod
+    def from_dxf_drawing(cls, filepath: str, 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.
+
+        :param filepath: the filepath to the drawing
+        :param classifiers: an iterable of string keys used as type classifiers
+        :param usable_width: the usable width to assume for this instance, if None, the maximum width will be used
+        :param arc_discretization: discretization of arcs of the dxf drawing, default is 1000.
+        """
+
+        doc = readfile(filepath)
+        msp = doc.modelspace()
+
+        points = []
+        for entity in msp:
+            if entity.dxftype() == 'LINE':
+                points.append((entity.dxf.start[0], entity.dxf.start[1]))
+                points.append((entity.dxf.end[0], entity.dxf.end[1]))
+
+            elif entity.dxftype() == 'ARC':
+                center = (entity.dxf.center[0], entity.dxf.center[1])
+                radius = entity.dxf.radius
+                start_angle = np.radians(entity.dxf.start_angle)
+                end_angle = np.radians(entity.dxf.end_angle)
+
+                arc_points = [
+                    (
+                        center[0] + radius * np.cos(start_angle + (end_angle - start_angle) * i / arc_discretization),
+                        center[1] + radius * np.sin(start_angle + (end_angle - start_angle) * i / arc_discretization),
+                    )
+                    for i in range(arc_discretization + 1)
+                ]
+                points.extend(arc_points)
+
+        points.sort(key=lambda p: p[0])
+
+        distance_to_y_0 = -points[0][1]
+
+        shifted_points = [(x, y + distance_to_y_0) for x, y in points]
+        shifted_points.sort(key=lambda p: p[0])
+
+        return SplineGroove(contour_points=shifted_points, classifiers=classifiers, usable_width=usable_width)

{pyroll_core-2.1.2.post0 → pyroll_core-2.1.3}/pyroll/core/hooks.py

@@ -491,9 +491,26 @@ class HookHost(ReprMixin, LogMixin, metaclass=_HookHostMeta):
         return result
 
 
-root_hooks = set()  # filled in __init__.py due to circular imports
+class _RootHooksList(list):
+    def add(self, item):
+        self.append(item)
+
+    def insert_before(self, position, item):
+        i = self.index(position)
+        self.insert(i, item)
+
+    def insert_after(self, position, item):
+        i = self.index(position) + 1
+        self.insert(i, item)
+
+    def remove_last(self, item):
+        i = list(reversed(self)).index(item)
+        del self[-1 - i]
+
+
+root_hooks = _RootHooksList()  # filled in __init__.py due to circular imports
 """
-Set of hooks to call explicitly in each solution iteration.
+List of hooks to call explicitly in each solution iteration.
 Their values will be treated as explicitly set but reevaluated in every iteration.
 They will not be deleted during cache clearing.
 They serve as root for the calling tree and persistent iterational variables.

{pyroll_core-2.1.2.post0 → pyroll_core-2.1.3}/pyroll/core/profile/hookimpls.py

@@ -38,6 +38,11 @@ def equivalent_width(self: Profile):
     return np.sqrt(self.cross_section.area * self.width / self.height)
 
 
+@Profile.equivalent_radius
+def equivalent_radius(self: Profile):
+    return np.sqrt(self.cross_section.area / np.pi)
+
+
 @Profile.equivalent_rectangle
 def equivalent_rectangle(self: Profile):
     return rectangle(self.equivalent_width, self.equivalent_height)
@@ -55,11 +60,11 @@ def core_temperature(self: Profile):
 
 @Profile.heat_penetration_number
 def heat_penetration_number(self: Profile):
-    if hasattr(self, "thermal_conductivity") and hasattr(self, "density") and hasattr(self, "thermal_capacity"):
-        return np.sqrt(self.thermal_conductivity * self.density * self.thermal_capacity)
+    if hasattr(self, "thermal_conductivity") and hasattr(self, "density") and hasattr(self, "specific_heat_capacity"):
+        return np.sqrt(self.thermal_conductivity * self.density * self.specific_heat_capacity)
 
 
 @Profile.thermal_diffusivity
 def thermal_diffusivity(self: Profile):
-    if hasattr(self, "thermal_conductivity") and hasattr(self, "density") and hasattr(self, "thermal_capacity"):
-        return self.thermal_conductivity / (self.density * self.thermal_capacity)
+    if hasattr(self, "thermal_conductivity") and hasattr(self, "density") and hasattr(self, "specific_heat_capacity"):
+        return self.thermal_conductivity / (self.density * self.specific_heat_capacity)

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

@@ -47,6 +47,9 @@ class Profile(HookHost):
     equivalent_width = Hook[float]()
     """Width of the equivalent rectangle."""
 
+    equivalent_radius = Hook[float]()
+    """Radius of a equivalent round."""
+
     temperature = Hook[float]()
     """Mean temperature of the profile cross-section."""
 
@@ -314,6 +317,32 @@ class Profile(HookHost):
 
         return DiamondProfile(height, width, corner_radius, **kwargs)
 
+    @classmethod
+    def hexagon(
+            cls,
+            side: Optional[float] = None,
+            height: Optional[float] = None,
+            diagonal: Optional[float] = None,
+            corner_radius: float = 0,
+            **kwargs
+    ) -> 'HexagonProfile':
+        """
+        Creates a hexagonal shaped profile (a real hexagonal shape with rounded corners,
+        without imperfections of hexagonal grooves). A hexagon is oriented to stand on its side.
+        Give exactly one of ``side``, ``height`` and ``diagonal``.
+
+        :param side: the side length of the hexagonal profile, must be > 0
+        :param height: the height of the hexagonal profile when standing on the flat base, must be > 0
+        :param diagonal: the diagonal length of the hexagonal profile (corner-to-corner distance)
+        :param corner_radius: the radius of the hexagon's corners, must be >= 0, <= diagonal / 2
+        :param kwargs: additional keyword arguments to be passed to the Profile constructor
+        :raises TypeError: on invalid argument combinations
+        :raises ValueError: if arguments are out of range
+        """
+
+
+        return HexagonProfile(side, height, diagonal, corner_radius, **kwargs)
+
     def local_height(self, z: float) -> float:
         coords = np.array([(1, -1), (1, 1)]) * (z, self.height)
 
@@ -619,3 +648,94 @@ class SquareProfile(Profile):
             diagonal=self._diagonal,
             corner_radius=self._corner_radius
         )
+
+
+class HexagonProfile(Profile):
+    def __init__(
+            self,
+            side: Optional[float] = None,
+            height: Optional[float] = None,
+            diagonal: Optional[float] = None,
+            corner_radius: float = 0,
+            **kwargs
+    ):
+        """
+        Creates a hexagonal shaped profile (a real hexagonal shape with rounded corners,
+        without imperfections of hexagonal grooves). A hexagon is oriented to stand on its side.
+        Give exactly one of ``side``, ``height`` and ``diagonal``.
+
+        :param side: the side length of the hexagonal profile, must be > 0
+        :param height: the height of the hexagonal profile when standing on the flat base, must be > 0
+        :param diagonal: the diagonal length of the hexagonal profile (corner-to-corner distance)
+        :param corner_radius: the radius of the hexagon's corners, must be >= 0, <= diagonal / 2
+        :param kwargs: additional keyword arguments to be passed to the Profile constructor
+        :raises TypeError: on invalid argument combinations
+        :raises ValueError: if arguments are out of range
+        """
+
+        if side is not None and diagonal is None and height is None:
+            height = side * np.sqrt(3)
+            diagonal = side * 2
+        elif diagonal is not None and side is None and height is None:
+            side = diagonal / 2
+            height = side / np.sqrt(3)
+        elif height is not None and side is None and diagonal is None:
+            side = height / np.sqrt(3)
+            diagonal = side * 2
+        else:
+            raise TypeError("either 'side', 'height' or 'diagonal' must be given")
+
+        if (
+                side <= 0
+                or height <= 0
+                or diagonal <= 0
+                or corner_radius < 0
+                or corner_radius > side / 2
+        ):
+            raise ValueError("argument value(s) out of range")
+
+        self._corner_radius = corner_radius
+        self._side = side
+        self._diagonal = diagonal
+
+        line = LinearRing(
+            np.array([
+                (-1, 0),
+                (-1 / 2, np.sqrt(3) / 2),
+                (1 / 2, np.sqrt(3) / 2),
+                (1, 0),
+                (1 / 2, -np.sqrt(3) / 2),
+                (-1 / 2, -np.sqrt(3) / 2),
+            ])
+            * (side, side)
+        )
+        polygon = Polygon(line)
+        polygon = polygon.buffer(corner_radius)
+
+        super().__init__(
+            cross_section=polygon,
+            classifiers={"hexagon"},
+            **kwargs
+        )
+
+    @property
+    def side(self):
+        """The side length of the hexagon profile."""
+        return self._side
+
+    @property
+    def diagonal(self):
+        """The diagonal between two flat sides of the hexagon profile."""
+        return self._diagonal
+
+    @property
+    def corner_radius(self):
+        """The radius of the profile's corners resp. edges."""
+        return self._corner_radius
+
+    @property
+    def __attrs__(self):
+        return super().__attrs__ | dict(
+            side=self._side,
+            diagonal=self._diagonal,
+            corner_radius=self._corner_radius)

{pyroll_core-2.1.2.post0 → pyroll_core-2.1.3}/pyroll/core/roll/hookimpls.py

@@ -67,11 +67,11 @@ def surface_y(self: Roll):
 
 @Roll.heat_penetration_number
 def heat_penetration_number(self: Roll):
-    if hasattr(self, "thermal_conductivity") and hasattr(self, "density") and hasattr(self, "thermal_capacity"):
-        return np.sqrt(self.thermal_conductivity * self.density * self.thermal_capacity)
+    if hasattr(self, "thermal_conductivity") and hasattr(self, "density") and hasattr(self, "specific_heat_capacity"):
+        return np.sqrt(self.thermal_conductivity * self.density * self.specific_heat_capacity)
 
 
 @Roll.thermal_diffusivity
 def thermal_diffusivity(self: Roll):
-    if hasattr(self, "thermal_conductivity") and hasattr(self, "density") and hasattr(self, "thermal_capacity"):
-        return self.thermal_conductivity / (self.density * self.thermal_capacity)
+    if hasattr(self, "thermal_conductivity") and hasattr(self, "density") and hasattr(self, "specific_heat_capacity"):
+        return self.thermal_conductivity / (self.density * self.specific_heat_capacity)

{pyroll_core-2.1.2.post0 → pyroll_core-2.1.3}/pyroll/core/roll_pass/hookimpls/roll.py

@@ -36,13 +36,13 @@ def center(self: RollPass.Roll):
 @RollPass.Roll.neutral_angle
 def neutral_angle(self: RollPass.Roll):
     if self.has_value("neutral_point"):
-        return -np.arcsin(self.neutral_point / self.working_radius)
+        return np.arcsin(self.neutral_point / self.working_radius)
 
 
 @RollPass.Roll.neutral_point
 def neutral_point(self: RollPass.Roll):
     if self.has_set_or_cached("neutral_angle"):
-        return -np.sin(self.neutral_angle) * self.working_radius
+        return np.sin(self.neutral_angle) * self.working_radius
 
 
 @RollPass.Roll.surface_velocity
@@ -51,4 +51,4 @@ def surface_velocity(self: RollPass.Roll):
         if self.has_value("neutral_angle"):
             return self.roll_pass.velocity / np.cos(self.neutral_angle)
         else:
-            return self.roll_pass.velocity / np.cos(0)
+            return self.roll_pass.velocity / np.cos(self.roll_pass.exit_point)

{pyroll_core-2.1.2.post0 → pyroll_core-2.1.3}/pyroll/core/roll_pass/hookimpls/roll_pass.py

@@ -97,6 +97,33 @@ def gap(self: RollPass):
         return self.height - 2 * self.roll.groove.depth
 
 
+@ThreeRollPass.inscribed_circle_diameter
+def inscribed_circle_diameter_from_gap(self: ThreeRollPass):
+    if self.has_set_or_cached("gap"):
+        half = self.roll.groove.usable_width / 2 / np.sqrt(3) + self.gap / np.sqrt(3) + self.roll.groove.depth
+        return half * 2
+
+
+@ThreeRollPass.gap
+def gap3_from_height(self: ThreeRollPass):
+    if self.has_set_or_cached("height"):
+        return (
+                self.height / 2
+                - self.roll.groove.usable_width / 2 / np.sqrt(3)
+                - self.roll.groove.depth
+        ) * np.sqrt(3)
+
+
+@ThreeRollPass.gap
+def gap3_from_icd(self: ThreeRollPass):
+    if self.has_set_or_cached("inscribed_circle_diameter"):
+        return (
+                self.inscribed_circle_diameter / 2
+                - self.roll.groove.usable_width / 2 / np.sqrt(3)
+                - self.roll.groove.depth
+        ) * np.sqrt(3)
+
+
 @RollPass.height
 def height(self):
     if self.has_set_or_cached("gap"):
@@ -223,6 +250,21 @@ def roll_power_3(self: ThreeRollPass):
     return 3 * self.roll.roll_power
 
 
+@RollPass.entry_point
+def entry_point(self: RollPass):
+    return - self.roll.contact_length
+
+
 @RollPass.entry_angle
 def entry_angle(self: RollPass):
-    return -np.arcsin(self.roll.contact_length / self.roll.working_radius)
+    return np.arcsin(self.entry_point / self.roll.working_radius)
+
+
+@RollPass.exit_point
+def exit_point(self: RollPass):
+    return 0
+
+
+@RollPass.exit_angle
+def exit_angle(self: RollPass):
+    return np.arcsin(self.exit_point / self.roll.working_radius)

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

@@ -60,9 +60,18 @@ class RollPass(DiskElementUnit, DeformationUnit):
     roll_force = Hook[float]()
     """Vertical roll force."""
 
+    entry_point = Hook[float]()
+    """Point where the material enters the roll gap."""
+
     entry_angle = Hook[float]()
     """Angle at which the material enters the roll gap."""
 
+    exit_point = Hook[float]()
+    """Point where the material exits the roll gap."""
+
+    exit_angle = Hook[float]()
+    """Angle at which the material exits the roll gap."""
+
     front_tension = Hook[float]()
     """Front tension acting on the current roll pass."""
 
@@ -84,6 +93,9 @@ class RollPass(DiskElementUnit, DeformationUnit):
     target_cross_section_filling_ratio = Hook[float]()
     """Target cross-section filling ratio of the out profile."""
 
+    forward_slip_ratio = Hook[float]()
+    """Ratio of forward slip of the roll gap."""
+
     def __init__(
             self,
             roll: BaseRoll,

{pyroll_core-2.1.2.post0 → pyroll_core-2.1.3}/pyroll/core/roll_pass/three_roll_pass.py

@@ -12,6 +12,9 @@ from ..roll import Roll as BaseRoll
 class ThreeRollPass(RollPass):
     """Represents a roll pass with three working rolls and 3-fold symmetry."""
 
+    inscribed_circle_diameter = Hook[float]()
+    """Diameter of inscribed circle between roll barrels as alternative to roll gap definition."""
+
     @property
     def contour_lines(self) -> List[LineString]:
         if self._contour_lines:

{pyroll_core-2.1.2.post0 → pyroll_core-2.1.3}/pyroll/core/sequence/sequence.py

@@ -2,6 +2,8 @@ from collections.abc import Sequence
 from typing import overload, List, cast
 
 from ..unit import Unit
+from ..roll_pass import RollPass
+from ..transport import Transport
 from ..hooks import Hook
 
 
@@ -56,22 +58,52 @@ class PassSequence(Unit, Sequence[Unit]):
         return self._subunits.__iter__()
 
     @overload
-    def __getitem__(self, index: int) -> Unit:
+    def __getitem__(self, key: int) -> Unit:
+        """Gets unit item by index."""
         ...
 
     @overload
-    def __getitem__(self, index: slice) -> list[Unit]:
+    def __getitem__(self, key: str) -> Unit:
+        """Gets unit item by label."""
         ...
 
-    def __getitem__(self, index: int) -> Unit:
-        return self._subunits.__getitem__(index)
+    @overload
+    def __getitem__(self, key: slice) -> list[Unit]:
+        """Gets a slice of units."""
+        ...
+
+    def __getitem__(self, key):
+        if isinstance(key, str):
+            try:
+                return next(u for u in self._subunits if u.label == key)
+            except StopIteration:
+                raise KeyError(f"No unit with label '{key}' found.")
+
+        if isinstance(key, int) or isinstance(key, slice):
+            return self._subunits.__getitem__(key)
+
+        raise TypeError("Key must be int, slice or str")
 
     @property
     def units(self) -> List[Unit]:
-        return self._subunits
+        """Returns a list of all units in this sequence."""
+        return list(self._subunits)
+
+    @property
+    def roll_passes(self) -> List[RollPass]:
+        """Returns a list of all roll passes in this sequence."""
+        return list(u for u in self._subunits if isinstance(u, RollPass))
+
+    @property
+    def transports(self) -> List[Transport]:
+        """Returns a list of all transports in this sequence."""
+        return list(u for u in self._subunits if isinstance(u, Transport))
 
     @property
     def __attrs__(self):
         return super().__attrs__ | {
             "units": self.units
         }
+    
+    def _ipython_key_completions_(self):
+        return [u.label for u in self._subunits]

{pyroll_core-2.1.2.post0 → pyroll_core-2.1.3}/pyroll/core/transport/__init__.py

@@ -1,3 +1,4 @@
 from .transport import Transport
+from .cooling_pipe import CoolingPipe
 
 from . import hookimpls

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

@@ -0,0 +1,64 @@
+from typing import List, cast
+
+from ..hooks import Hook
+from .transport import Transport
+
+
+class CoolingPipe(Transport):
+    """Represents a smooth cooling pipe."""
+
+    inner_diameter = Hook[float]()
+    """Inner diameter of the cooling pipe"""
+
+    cooling_water_volume_flux = Hook[float]()
+    """Volume flux of the cooling water"""
+
+    cooling_water_temperature = Hook[float]()
+    """Temperature of the cooling water"""
+
+
+    @property
+    def disk_elements(self) -> List['CoolingPipe.DiskElement']:
+        """A list of disk elements used to subdivide this unit."""
+        return list(self._subunits)
+
+    class Profile(Transport.Profile):
+        """Represents a profile in context of a transport unit."""
+
+        @property
+        def cooling_pipe(self) -> 'CoolingPipe':
+            """Reference to the transport. Alias for ``self.unit``."""
+            return cast(CoolingPipe, self.unit)
+
+    class InProfile(Profile, Transport.InProfile):
+        """Represents an incoming profile of a transport unit."""
+
+    class OutProfile(Profile, Transport.OutProfile):
+        """Represents an outgoing profile of a transport unit."""
+
+    class DiskElement(Transport.DiskElement):
+        """Represents a disk element in a roll pass."""
+
+        @property
+        def cooling_pipe(self) -> 'CoolingPipe':
+            """Reference to the transport. Alias for ``self.parent``."""
+            return cast(CoolingPipe, self.parent)
+
+        class Profile(Transport.DiskElement.Profile):
+            """Represents a profile in context of a disk element unit."""
+
+            @property
+            def disk_element(self) -> 'CoolingPipe.DiskElement':
+                """Reference to the disk element. Alias for ``self.unit``"""
+                return cast(CoolingPipe.DiskElement, self.unit)
+
+            @property
+            def cooling_pipe(self) -> 'CoolingPipe':
+                """Reference to the transport. Alias for ``self.unit.parent``"""
+                return cast(CoolingPipe, self.unit.parent)
+
+        class InProfile(Profile, Transport.DiskElement.InProfile):
+            """Represents an incoming profile of a disk element unit."""
+
+        class OutProfile(Profile, Transport.DiskElement.OutProfile):
+            """Represents an outgoing profile of a disk element unit."""

{pyroll_core-2.1.2.post0 → pyroll_core-2.1.3}/pyroll/core/transport/transport.py

@@ -13,7 +13,7 @@ class Transport(DiskElementUnit):
     @property
     def disk_elements(self) -> List['Transport.DiskElement']:
         """A list of disk elements used to subdivide this unit."""
-        return self._subunits
+        return list(self._subunits)
 
     class Profile(DiskElementUnit.Profile):
         """Represents a profile in context of a transport unit."""