pyroll-core 2.0.0__py3-none-any.whl

pyroll/core/__init__.py

@@ -0,0 +1,38 @@
+VERSION = "2.0.0"
+
+from . import shapes as _
+
+from .grooves import (
+    BoxGroove, ConstrictedBoxGroove, UpsetBoxGroove, ConstrictedUpsetBoxGroove,
+    SquareGroove, DiamondGroove, GothicGroove,
+    RoundGroove, FalseRoundGroove,
+    CircularOvalGroove, FlatOvalGroove, SwedishOvalGroove, ConstrictedSwedishOvalGroove, Oval3RadiiGroove,
+    Oval3RadiiFlankedGroove, UpsetOvalGroove, ConstrictedCircularOvalGroove,
+    SplineGroove,
+    GenericElongationGroove,
+    FlatGroove,
+    HexagonalGroove
+)
+from .transport import Transport
+from .roll_pass import RollPass, DeformationUnit, ThreeRollPass
+from .unit import Unit
+from .roll import Roll
+from .profile import Profile
+from .rotator import Rotator
+from .sequence import PassSequence
+from .hooks import Hook, HookHost, HookFunction, root_hooks
+from .disk_elements import DiskElementUnit
+from .config import Config, config
+
+root_hooks.update(
+    {
+        RollPass.roll_force,
+        RollPass.Roll.roll_torque,
+        Unit.OutProfile.cross_section,
+        Unit.OutProfile.strain,
+        Unit.OutProfile.length,
+        Unit.OutProfile.classifiers,
+        Unit.OutProfile.t,
+        PassSequence.total_elongation,
+    }
+)

pyroll/core/config.py

@@ -0,0 +1,155 @@
+import os
+from pathlib import Path
+from typing import Optional, Iterable, Mapping, Any, Callable
+
+
+class ConfigValue:
+    """Helper descriptor for storing configuration values, able to determine the value from explictly set values,
+     environment variables and default values."""
+
+    def __init__(self, default, env_var: Optional[str] = None, env_var_prefix: Optional[str] = None,
+                 parser: Optional[Callable[[str], Any]] = None):
+        self.default = default
+        self.type = type(default)
+        self.parser = parser
+
+        self._env_var = env_var
+        self._env_var_prefix = env_var_prefix
+
+    def __set_name__(self, owner: type, name: str):
+        self.owner = owner
+        self.name = name
+        if not self._env_var_prefix:
+            self._env_var_prefix = self.owner.__module__.upper().replace('.', '_')
+
+    @property
+    def env_var(self):
+        """The name of the related environment variable."""
+        if self._env_var:
+            return self._env_var
+
+        return f"{self._env_var_prefix}_{self.name.upper()}"
+
+    def __get__(self, instance, owner):
+        value = getattr(instance, "_" + self.name, None)
+
+        if value is not None:
+            return value
+
+        value = os.getenv(self.env_var, None)
+
+        if value is not None:
+            return self._parse(value)
+
+        return self.default
+
+    def __set__(self, instance, value):
+        setattr(instance, "_" + self.name, value)
+
+    def __delete__(self, instance):
+        delattr(instance, "_" + self.name)
+
+    def _parse(self, s: str):
+        """Parse value from string."""
+        if self.parser:
+            return self.parser(s)
+        if self.type is bool:
+            if s.lower().strip() == "true":
+                return True
+            elif s.lower().strip() == "false":
+                return False
+            raise ValueError(f"{s} could not be parsed to bool")
+        if self.type is Path:
+            return Path(s)
+        if self.type is str:
+            return s
+        if issubclass(self.type, Mapping):
+            return self.type((p2.strip() for p2 in p.strip().split("=")) for p in s.split(","))
+        if issubclass(self.type, Iterable):
+            return self.type(p.strip() for p in s.split(","))
+
+        return self.type(s)
+
+
+class ConfigMeta(type):
+    def to_dict(cls):
+        """Return the config values of this class as dict."""
+        return {
+            n: v
+            for n, v in type(cls).__dict__.items()
+            if isinstance(v, ConfigValue)
+        }
+
+    def update(cls, d: dict[str, Any]):
+        """
+        Update the config values of this class from a dict.
+
+        :return: the updated contents
+        """
+        for n, v in d.items():
+            cv = type(cls).__dict__.get(n, None)
+            if isinstance(cv, ConfigValue):
+                setattr(cls, n, v)
+            else:
+                AttributeError(f"{cls} has no config value {n}")
+
+        return cls.to_dict()
+
+
+def config(env_var_prefix):
+    """
+    Decorator for creating config classes.
+    Automatically creates a metaclass with respective :py:class:`ConfigValue` descriptors for class attributes with
+    uppercase names that do not start with underscore.
+
+    Use it as follows::
+
+        @config("PREFIX")
+        class Config:
+            VAR1 = 42
+            VAR2 = "abc"
+
+            # not modified
+            _PRIV_VAR = None
+            normal_var = None
+
+
+    :param env_var_prefix: prefix for the respective env vars, should be uppercase and delimited by underscores
+    """
+
+    def dec(cls):
+        meta_dict = {}
+        cls_dict = dict(cls.__dict__)
+
+        for n, v in cls.__dict__.items():
+            if n.isupper() and not n.startswith("_"):
+                del cls_dict[n]
+                if not isinstance(v, ConfigValue):
+                    meta_dict[n] = ConfigValue(default=v, env_var_prefix=env_var_prefix)
+                else:
+                    meta_dict[n] = ConfigValue(default=v.default, env_var_prefix=env_var_prefix)
+
+        meta = type(cls.__name__ + "Meta", (ConfigMeta,), meta_dict)
+        cls = meta(cls.__name__, cls.__bases__, cls_dict)
+        return cls
+
+    return dec
+
+
+@config("PYROLL_CORE")
+class Config:
+    """Configuration class for ``pyroll.core``."""
+    ROLL_PASS_AUTO_ROTATION = True
+    """Whether to enable automatic rotation of incoming profiles in roll passes by default."""
+
+    GROOVE_PADDING = 0.2
+    """Fraction of the total groove width that is added at the sides of the groove contour to represent the roll face."""
+
+    DEFAULT_MAX_ITERATION_COUNT = 100
+    """Default maximum count of iterations before aborting the loop."""
+
+    DEFAULT_ITERATION_PRECISION = 1e-2
+    """Default precision of iteration loops required to break successfully."""
+
+    ROLL_SURFACE_DISCRETIZATION_COUNT = 100
+    """Count of discrete points used to describe the roll surface."""

pyroll/core/disk_elements/__init__.py

@@ -0,0 +1,2 @@
+from . import hookimpls
+from .disk_element_unit import DiskElementUnit

pyroll/core/disk_elements/disk_element_unit.py

@@ -0,0 +1,73 @@
+from typing import List, cast
+
+from ..unit import Unit
+from ..hooks import Hook
+from ..profile import Profile as BaseProfile
+
+
+class DiskElementUnit(Unit):
+    """Base class for units that can be divided in disk elements."""
+
+    disk_element_count = Hook[int]()
+    """Number of intermediate profiles to create during unit solution (in and out profiles are not counted within)."""
+
+    class Profile(Unit.Profile):
+        """Represents a profile in context of a disked unit."""
+
+    class InProfile(Profile, Unit.InProfile):
+        """Represents an incoming profile of a disked unit."""
+
+    class OutProfile(Profile, Unit.OutProfile):
+        """Represents an outgoing profile of a disked unit."""
+
+    class DiskElement(Unit):
+        """
+        Represents a disk element unit, a unit used to subdivide other units in rolling direction.
+        The basic disk element is not intended to be used directly.
+        Use the specialized disk elements of the respective parent unit instead.
+        """
+
+        def __init__(
+                self,
+                parent: 'Unit',
+                index: int,
+                **kwargs
+        ):
+            """
+            :param label: label for human identification
+            :param kwargs: additional hook values as keyword arguments to set explicitly
+            """
+
+            super().__init__(label=f"{parent}[{index}]", parent=parent, **kwargs)
+
+        class Profile(Unit.Profile):
+            """Represents a profile in context of a disk element unit."""
+
+            @property
+            def disk_element(self) -> 'DiskElementUnit.DiskElement':
+                """Reference to the disk element. Alias for ``self.unit``"""
+                return cast(DiskElementUnit.DiskElement, self.unit)
+
+        class InProfile(Profile, Unit.InProfile):
+            """Represents an incoming profile of a disk element unit."""
+
+        class OutProfile(Profile, Unit.OutProfile):
+            """Represents an outgoing profile of a disk element unit."""
+
+    @property
+    def disk_elements(self) -> List['DiskElement']:
+        """A list of disk elements used to subdivide this unit."""
+        return self._subunits
+
+    @property
+    def __attrs__(self):
+        return super().__attrs__ | {
+            "disk_elements": self.disk_elements
+        }
+
+    def init_solve(self, in_profile: BaseProfile):
+        super().init_solve(in_profile)
+        if not self._subunits:
+            self._subunits = self._SubUnitsList(
+                self, [self.DiskElement(self, i) for i in range(self.disk_element_count)]
+                )

pyroll/core/disk_elements/hookimpls.py

@@ -0,0 +1,26 @@
+from .disk_element_unit import DiskElementUnit
+
+
+@DiskElementUnit.disk_element_count
+def no_disks(self: DiskElementUnit):
+    return 0
+
+
+@DiskElementUnit.DiskElement.duration
+def disk_duration(self: DiskElementUnit.DiskElement):
+    return self.parent.duration / self.parent.disk_element_count
+
+
+@DiskElementUnit.DiskElement.length
+def disk_length(self: DiskElementUnit.DiskElement):
+    return self.parent.length / self.parent.disk_element_count
+
+
+@DiskElementUnit.DiskElement.InProfile.x
+def in_x(self: DiskElementUnit.DiskElement.InProfile):
+    try:
+        # get from prev disk
+        return self.disk_element.prev.out_profile.x
+    except IndexError:
+        # is first disk: get from parent in_profile
+        return self.disk_element.parent.in_profile.x

pyroll/core/grooves/__init__.py

@@ -0,0 +1,10 @@
+from .base import GrooveBase
+from .spline import SplineGroove
+from .generic_elongation import GenericElongationGroove
+from .boxes import BoxGroove, ConstrictedBoxGroove, UpsetBoxGroove, ConstrictedUpsetBoxGroove
+from .diamonds import DiamondGroove, SquareGroove, GothicGroove
+from .ovals import CircularOvalGroove, FlatOvalGroove, SwedishOvalGroove, ConstrictedSwedishOvalGroove, \
+    Oval3RadiiGroove, Oval3RadiiFlankedGroove, UpsetOvalGroove, ConstrictedCircularOvalGroove
+from .rounds import RoundGroove, FalseRoundGroove
+from .flat import FlatGroove
+from .hexagonal import HexagonalGroove

pyroll/core/grooves/base.py

@@ -0,0 +1,59 @@
+from abc import ABC, abstractmethod
+from typing import Union, Tuple
+
+import numpy as np
+from shapely.geometry import Polygon, LineString
+
+
+class GrooveBase(ABC):
+    """Abstract base class for all grooves."""
+
+    @property
+    @abstractmethod
+    def classifiers(self) -> set[str]:
+        """A tuple of keywords to specify the type classifiers of this groove."""
+        raise NotImplemented
+
+    @property
+    @abstractmethod
+    def cross_section(self) -> Polygon:
+        """A polygon representing the cross-section of this groove limited by the contour line and y=0."""
+        raise NotImplemented
+
+    @property
+    @abstractmethod
+    def usable_width(self) -> float:
+        """The usable width of the groove, meaning the width of ideal filling."""
+        raise NotImplemented
+
+    @property
+    @abstractmethod
+    def width(self) -> float:
+        """The maximum width of the groove representing the definition region in z-direction."""
+        raise NotImplemented
+
+    @property
+    @abstractmethod
+    def depth(self) -> float:
+        """The maximum depth of the groove."""
+        raise NotImplemented
+
+    @property
+    @abstractmethod
+    def contour_line(self) -> LineString:
+        """A line representing the geometry of the groove contour."""
+        raise NotImplemented
+
+    @property
+    @abstractmethod
+    def contour_points(self) -> np.ndarray:
+        """An array of the contour line's points of shape (n, 2)."""
+        raise NotImplemented
+
+    @abstractmethod
+    def local_depth(self, z: Union[float, np.ndarray]) -> Union[float, np.ndarray]:
+        """Function of the local groove depth in dependence on the z-coordinate."""
+        raise NotImplemented
+
+    def __str__(self):
+        return f"{type(self).__name__} {self.usable_width:.4g} x {self.depth:.4g} ({', '.join(self.classifiers)})"

pyroll/core/grooves/boxes/__init__.py

@@ -0,0 +1,3 @@
+from .box import BoxGroove
+from .constricted_box import ConstrictedBoxGroove
+from .upset_box import UpsetBoxGroove, ConstrictedUpsetBoxGroove

pyroll/core/grooves/boxes/box.py

@@ -0,0 +1,57 @@
+from typing import Optional
+
+import numpy as np
+
+from ..generic_elongation import GenericElongationGroove
+from ..generic_elongation_solvers import solve_box_like
+
+
+class BoxGroove(GenericElongationGroove):
+    """Represents a box-shaped groove."""
+
+    def __init__(
+            self,
+            r1: float,
+            r2: float,
+            depth: float,
+            ground_width: Optional[float] = None,
+            even_ground_width: Optional[float] = None,
+            usable_width: Optional[float] = None,
+            flank_angle: Optional[float] = None,
+            pad_angle: float = 0,
+            **kwargs
+    ):
+        """
+        Exactly two of ``ground_width``, ``even_ground_width``, ``usable_width`` and ``flank_angle`` must be given,
+        but not ``ground_width`` and ``even_ground_width`` at the same time.
+        Widths are always measured at the intersection of the extrapolated ground, face and flanks.
+        All angles are measured in ° (degree).
+
+        :param r1: radius 1 (face/flank)
+        :param r2: radius 2 (flank/ground)
+        :param depth: maximum depth
+        :param ground_width: width of the groove ground
+        :param even_ground_width: width of the even ground line
+        :param usable_width: usable width of the groove
+        :param flank_angle: inclination angle of the flanks
+        :param pad_angle: angle between z-axis and the roll face padding
+        :param kwargs: more keyword arguments passed to the GenericElongationGroove constructor
+        :raises ValueError: if not exactly two of ground_width, usable_width and flank_angle are given
+        """
+        if flank_angle is not None:
+            flank_angle = np.deg2rad(flank_angle)
+
+        sol = solve_box_like(
+            r2=r2, r4=0, depth=depth, ground_width=ground_width, usable_width=usable_width, flank_angle=flank_angle,
+            indent=0, even_ground_width=even_ground_width
+        )
+
+        super().__init__(
+            r1=r1, r2=r2, pad_angle=np.deg2rad(pad_angle),
+            **sol,
+            **kwargs
+        )
+
+    @property
+    def classifiers(self):
+        return {"box"} | super().classifiers

pyroll/core/grooves/boxes/constricted_box.py

@@ -0,0 +1,63 @@
+from typing import Optional
+
+import numpy as np
+
+from ..generic_elongation import GenericElongationGroove
+from ..generic_elongation_solvers import solve_box_like
+from .box import BoxGroove
+
+
+class ConstrictedBoxGroove(BoxGroove):
+    """Represents a box-shaped groove with an indented ground."""
+
+    def __init__(
+            self,
+            r1: float,
+            r2: float,
+            r4: float,
+            depth: float,
+            indent: float,
+            ground_width: Optional[float] = None,
+            even_ground_width: Optional[float] = None,
+            usable_width: Optional[float] = None,
+            flank_angle: Optional[float] = None,
+            pad_angle: float = 0,
+            **kwargs
+    ):
+        """
+        Exactly two of ``ground_width``, ``even_ground_width``, ``usable_width`` and ``flank_angle`` must be given,
+        but not ``ground_width`` and ``even_ground_width`` at the same time.
+        Widths are always measured at the intersection of the extrapolated ground, face and flanks.
+        All angles are measured in ° (degree).
+
+        :param r1: radius 1 (face/flank)
+        :param r2: radius 2 (flank)
+        :param r4: radius 4 (indent)
+        :param depth: maximum depth
+        :param indent: depth of the indent
+        :param ground_width: width of the groove ground
+        :param even_ground_width: width of the even ground line
+        :param usable_width: usable width of the groove
+        :param flank_angle: inclination angle of the flanks
+        :param pad_angle: angle between z-axis and the roll face padding
+        :param kwargs: more keyword arguments passed to the GenericElongationGroove constructor
+        :raises ValueError: if not exactly two of ground_width, usable_width and flank_angle are given
+        """
+        if flank_angle is not None:
+            flank_angle = np.deg2rad(flank_angle)
+
+        sol = solve_box_like(
+            r2=r2, r4=r4, depth=depth, ground_width=ground_width, usable_width=usable_width, flank_angle=flank_angle,
+            indent=indent, even_ground_width=even_ground_width
+        )
+
+        GenericElongationGroove.__init__(
+            self,
+            r1=r1, r2=r2, r4=r4, pad_angle=np.deg2rad(pad_angle), indent=indent,
+            **sol,
+            **kwargs
+        )
+
+    @property
+    def classifiers(self):
+        return {"box", "constricted"} | super().classifiers

pyroll/core/grooves/boxes/upset_box.py

@@ -0,0 +1,18 @@
+from .box import BoxGroove
+from .constricted_box import ConstrictedBoxGroove
+
+
+class UpsetBoxGroove(BoxGroove):
+    """Represents a box-shaped groove with a high height/width ratio."""
+
+    @property
+    def classifiers(self):
+        return {"box", "upset"} | super().classifiers
+
+
+class ConstrictedUpsetBoxGroove(ConstrictedBoxGroove, UpsetBoxGroove):
+    """Represents a box-shaped groove with a high height/width ratio and an indented ground."""
+
+    @property
+    def classifiers(self):
+        return {"box", "constricted", "upset"} | super().classifiers

pyroll/core/grooves/diamonds/__init__.py

@@ -0,0 +1,3 @@
+from .diamond import DiamondGroove
+from .square import SquareGroove
+from .gothic import GothicGroove

pyroll/core/grooves/diamonds/diamond.py

@@ -0,0 +1,60 @@
+from typing import Optional
+
+import numpy as np
+from numpy import deg2rad
+
+from ..generic_elongation import GenericElongationGroove
+
+
+class DiamondGroove(GenericElongationGroove):
+    """Represent a diamond-shaped groove."""
+
+    def __init__(
+            self,
+            r1: float,
+            r2: float,
+            usable_width: Optional[float] = None,
+            tip_depth: Optional[float] = None,
+            tip_angle: Optional[float] = None,
+            pad_angle: float = 0
+    ):
+        """
+        Exactly two of usable_width, tip_depth and tip_angle must be given.
+        Widths are always measured at the intersection of the extrapolated ground, face and flanks.
+        All angles are measured in ° (degree).
+
+        :param r1: radius 1 (face/flank)
+        :param r2: radius 2 (flank/ground)
+        :param usable_width: usable width of the groove
+        :param tip_depth: depth of the intersection of the extrapolated flanks
+        :param tip_angle: angle between the flanks
+        :param pad_angle: angle between z-axis and the roll face padding
+        :raises ValueError: if not exactly two of usable_width, tip_depth and tip_angle are given
+        """
+        if tip_angle is not None:
+            tip_angle = np.deg2rad(tip_angle)
+
+        if usable_width and tip_depth and not tip_angle:
+            alpha = np.arctan(tip_depth / (usable_width / 2))
+
+        elif usable_width and tip_angle and not tip_depth:
+            alpha = np.pi / 2 - tip_angle / 2
+            tip_depth = usable_width / 2 * np.tan(alpha)
+
+        elif tip_depth and tip_angle and not usable_width:
+            alpha = np.pi / 2 - tip_angle / 2
+            usable_width = tip_depth / np.tan(alpha) * 2
+        else:
+            raise ValueError(
+                "Exactly two of the following arguments must be given: usable_width, tip_depth, tip_angle."
+            )
+
+        depth = tip_depth - r2 / np.cos(alpha) + r2
+
+        super().__init__(
+            usable_width=usable_width, depth=depth, r1=r1, r2=r2, flank_angle=alpha, pad_angle=deg2rad(pad_angle)
+        )
+
+    @property
+    def classifiers(self):
+        return {"diamond",} | super().classifiers

pyroll/core/grooves/diamonds/gothic.py

@@ -0,0 +1,41 @@
+import numpy as np
+from ..generic_elongation import GenericElongationGroove
+from ..generic_elongation_solvers import solve_r123
+
+
+class GothicGroove(GenericElongationGroove):
+    """Represents a square-shaped groove with curved flanks similar to a gothic arc."""
+
+    def __init__(
+            self,
+            r1: float,
+            r2: float,
+            r3: float,
+            depth: float,
+            usable_width: float,
+            pad_angle: float = 0
+    ):
+        """
+        Widths are always measured at the intersection of the extrapolated ground, face and flanks.
+
+        :param r1: radius 1 (face/flank)
+        :param r2: radius 2 (flank/ground)
+        :param r3: radius 3 (ground)
+        :param depth: maximum depth
+        :param usable_width: usable width of the groove
+        :param pad_angle: angle between z-axis and the roll face padding
+        """
+
+        pad_angle = np.deg2rad(pad_angle)
+
+        sol = solve_r123(r1, r2, r3, depth, usable_width, pad_angle)
+
+        super().__init__(
+            usable_width=usable_width, depth=depth,
+            r1=r1, r2=r2, r3=r3,
+            flank_angle=sol["flank_angle"], alpha3=sol["alpha3"], pad_angle=pad_angle
+        )
+
+    @property
+    def classifiers(self):
+        return {"diamond", "square", "gothic"} | super().classifiers

pyroll/core/grooves/diamonds/square.py

@@ -0,0 +1,48 @@
+from typing import Optional
+
+import numpy as np
+
+from .diamond import DiamondGroove
+
+
+class SquareGroove(DiamondGroove):
+    """Represents a square-shaped groove (diamond with tip angle near 90°)."""
+
+    def __init__(
+            self,
+            r1: float,
+            r2: float,
+            usable_width: Optional[float] = None,
+            tip_depth: Optional[float] = None,
+            tip_angle: Optional[float] = None,
+            pad_angle: float = 0
+    ):
+        """
+        Exactly two of usable_width, tip_depth and tip_angle must be given.
+        Widths are always measured at the intersection of the extrapolated ground, face and flanks.
+        All angles are measured in ° (degree).
+
+        :param r1: radius 1 (face/flank)
+        :param r2: radius 2 (flank/ground)
+        :param usable_width: usable width of the groove
+        :param tip_depth: depth of the intersection of the extrapolated flanks
+        :param tip_angle: angle between the flanks
+        :param pad_angle: angle between z-axis and the roll face padding
+        :raises ValueError: if not exactly two of usable_width, tip_depth and tip_angle are given
+        :raises ValueError: if tip angle is <85° or >95° (no matter if given or calculated internally)
+        """
+
+        super().__init__(
+            r1=r1, r2=r2, usable_width=usable_width, tip_depth=tip_depth, tip_angle=tip_angle, pad_angle=pad_angle
+        )
+
+        tip_angle_deg = 180 - 2 * np.rad2deg(self.flank_angle)
+        if tip_angle_deg > 95 or tip_angle_deg < 85:
+            raise ValueError(
+                "The tip angle of this SquareGroove significantly deviates from 90°, "
+                "you should use a DiamondGroove instead."
+            )
+
+    @property
+    def classifiers(self):
+        return {"diamond", "square"} | super().classifiers