pyroll-core 2.0.0__py3-none-any.whl

pyroll/core/grooves/flat.py

@@ -0,0 +1,31 @@
+import numpy as np
+from numpy import deg2rad
+
+from .generic_elongation import GenericElongationGroove
+
+
+class FlatGroove(GenericElongationGroove):
+    """Represents a flat groove aka no groove."""
+
+    def __init__(
+            self,
+            usable_width: float,
+            r1: float = 0,
+            pad_angle: float = 0,
+            **kwargs
+    ):
+        """
+        :param usable_width: usable width of the roll face
+        :param kwargs: more keyword arguments passed to the GenericElongationGroove constructor
+        """
+        pad_angle = deg2rad(pad_angle)
+
+        super().__init__(
+            usable_width=usable_width, r1=r1, r2=0, depth=0, flank_angle=0,
+            pad_angle=pad_angle,
+            **kwargs
+        )
+
+    @property
+    def classifiers(self):
+        return {"flat",} | super().classifiers

pyroll/core/grooves/generic_elongation.py

@@ -0,0 +1,258 @@
+from typing import Union, Tuple, Sequence, Optional
+
+import numpy as np
+from shapely.geometry import LineString, Polygon
+
+from pyroll.core.grooves import GrooveBase
+from pyroll.core.repr import ReprMixin
+from ..config import Config
+
+
+class GenericElongationGroove(GrooveBase, ReprMixin):
+    """Represents a groove defined by the generic elongation groove geometry."""
+
+    def __init__(
+            self,
+
+            r1: float,
+            r2: float,
+
+            flank_angle: Optional[float] = None,
+            usable_width: Optional[float] = None,
+            ground_width: Optional[float] = None,
+            depth: Optional[float] = None,
+
+            r3: float = 0,
+            alpha3: float = 0,
+
+            r4: float = 0,
+            alpha4: float = 0,
+
+            indent: float = 0,
+            even_ground_width: float = 0,
+
+            pad: float = 0,
+            rel_pad: float = Config.GROOVE_PADDING,
+            pad_angle: float = 0,
+
+            classifiers: Sequence[str] = ()
+    ):
+        """
+        Give any three of ``usable_width``, ``ground_width``, ``flank_angle`` and ``depth``.
+        All angles are measured in radians.
+        All measures must be non-negative.
+
+        :param r1: radius 1 (face/flank)
+        :param r2: radius 2 (flank/radius 3)
+
+        :param usable_width: width of flank/face intersections
+        :param ground_width: width of flank/ground-line intersections
+        :param flank_angle: angle of the flanks to the z-axis
+        :param depth: maximum depth
+
+        :param r3: radius 3 (radius 2/radius 4)
+        :param r4: radius 4 (radius 3/ground)
+        :param alpha3: angle corresponding to ``r3``
+        :param alpha4: angle corresponding to ``r4``
+
+
+        :param indent: indent of the ground
+
+        :param pad: absolute padding at roll face
+        :param rel_pad: padding at roll face relative to ``usable_width``
+        :param pad_angle: angle of the face padding from horizontal line
+            (commonly 0 for two-roll, π/6 for three-roll and π/4 for four-roll)
+
+        :param classifiers: sequence of additional type classifiers
+        """
+
+        try:
+            if usable_width is None:
+                usable_width = ground_width + 2 * depth / np.tan(flank_angle)
+            elif ground_width is None:
+                ground_width = usable_width - 2 * depth / np.tan(flank_angle)
+            elif flank_angle is None:
+                flank_angle = np.arctan(depth / (usable_width - ground_width) * 2)
+            elif depth is None:
+                depth = (usable_width - ground_width) / 2 * np.tan(flank_angle)
+            else:
+                raise TypeError("Too many arguments given.")
+
+        except TypeError:
+            raise TypeError("Exactly three of usable_width, ground_width, flank_angle and depth must be given.")
+
+        self.r1 = r1
+        self.r2 = r2
+        self.r3 = r3
+        self.r4 = r4
+
+        self.alpha1 = alpha1 = flank_angle + pad_angle
+        self.alpha3 = alpha3
+        self.alpha4 = alpha4
+        self.alpha2 = alpha2 = flank_angle + self.alpha4 - self.alpha3
+
+        self.indent = indent
+        self.even_ground_width = even_ground_width
+        self._usable_width = usable_width
+        self.ground_width = ground_width
+        self.flank_angle = flank_angle
+        self._depth = depth
+        self._classifiers = set(classifiers)
+        pad = pad if pad else usable_width * rel_pad
+        self.pad_angle = pad_angle
+
+        self.z2 = usable_width / 2
+        self.y2 = 0
+
+        l12 = r1 * np.tan(alpha1 / 2)
+        self.z1 = self.z2 + l12 * np.cos(pad_angle)
+        self.y1 = l12 * np.sin(pad_angle)
+
+        self.z0 = self.z1 + pad * np.cos(pad_angle)
+        self.y0 = self.y1 + pad * np.sin(pad_angle)
+
+        self.z12 = self.z1 - r1 * np.sin(pad_angle)
+        self.y12 = self.y1 + r1 * np.cos(pad_angle)
+
+        self.z3 = self.z12 - r1 * np.sin(flank_angle)
+        self.y3 = self.y12 - r1 * np.cos(flank_angle)
+
+        self.z9 = 0
+        self.y9 = depth - indent
+
+        self.z7 = self.even_ground_width / 2
+        self.y7 = self.y9
+
+        self.z8 = self.z7
+        self.y8 = self.y9 + r4
+
+        self.z6 = self.z8 + r4 * np.sin(alpha4)
+        self.y6 = self.y8 - r4 * np.cos(alpha4)
+
+        self.beta = beta = alpha4 - alpha3 / 2
+
+        self.z10 = self.z6 + r3 * np.sin(alpha3 / 2 + beta)
+        self.y10 = self.y6 - r3 * np.cos(alpha3 / 2 + beta)
+
+        self.z5 = self.z10 + r3 * np.sin(alpha3 / 2 - beta)
+        self.y5 = self.y10 + r3 * np.cos(alpha3 / 2 - beta)
+
+        self.z11 = self.z10 + (r3 - r2) * np.sin(alpha3 / 2 - beta)
+        self.y11 = self.y10 + (r3 - r2) * np.cos(alpha3 / 2 - beta)
+
+        self.gamma = gamma = np.pi / 2 - alpha2 - alpha3 + alpha4
+
+        self.z4 = self.z11 + r2 * np.cos(gamma)
+        self.y4 = self.y11 + r2 * np.sin(gamma)
+
+        right_side = np.array(list(self._enumerate_contour_points()))
+        left_side = right_side[:-1].copy()
+        left_side[:, 0] *= -1
+
+        self._contour_points = np.concatenate([left_side, right_side[::-1]])
+        self._contour_line = LineString(self._contour_points)
+        self._cross_section = Polygon(self._contour_line)
+
+        self.test_plausibility()
+
+    def _r1_contour_line(self, z):
+        return self.y12 - np.sqrt(self.r1 ** 2 - (z - self.z12) ** 2)
+
+    def _r2_contour_line(self, z):
+        return self.y11 + np.sqrt(self.r2 ** 2 - (z - self.z11) ** 2)
+
+    def _r3_contour_line(self, z):
+        return self.y10 + np.sqrt(self.r3 ** 2 - (z - self.z10) ** 2)
+
+    def _r4_contour_line(self, z):
+        return self.y8 - np.sqrt(self.r4 ** 2 - (z - self.z8) ** 2)
+
+    def _flank_contour_line(self, z):
+        return self.y3 - np.tan(self.flank_angle) * (z - self.z3)
+
+    def _ground_contour_line(self, z):
+        return np.ones_like(z) * (self.depth - self.indent)
+
+    @staticmethod
+    def _face_contour_line(z):
+        return np.zeros_like(z)
+
+    def _enumerate_contour_points(self):
+        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):
+                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):
+                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):
+                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):
+                yield z, self._r4_contour_line(z)
+
+        yield self.z9, self.y9
+
+    @property
+    def contour_points(self):
+        return self._contour_points
+
+    @property
+    def contour_line(self) -> LineString:
+        return self._contour_line
+
+    @property
+    def cross_section(self) -> Polygon:
+        return self._cross_section
+
+    def local_depth(self, z) -> Union[float, np.ndarray]:
+        z = np.abs(z)
+
+        return np.piecewise(
+            z,
+            [z < self.z7, (self.z7 <= z) & (z < self.z6), (self.z6 <= z) & (z < self.z5),
+             (self.z5 <= z) & (z < self.z4), (self.z4 <= z) & (z < self.z3), (self.z3 <= z) & (z < self.z1)],
+            [self._ground_contour_line, self._r4_contour_line, self._r3_contour_line, self._r2_contour_line,
+             self._flank_contour_line, self._r1_contour_line, self._face_contour_line]
+        )
+
+    @property
+    def classifiers(self):
+        return {"generic_elongation"} | self._classifiers
+
+    @property
+    def usable_width(self) -> float:
+        return self._usable_width
+
+    @property
+    def width(self) -> float:
+        return 2 * self.z1
+
+    @property
+    def depth(self) -> float:
+        return self._depth
+
+    def test_plausibility(self):
+        if (self.flank_angle + self.alpha4 - self.alpha2 - self.alpha3) > 0.01:
+            raise ValueError("given angles should fulfill α1 + α4 = α2 + α3 to be geometrically plausible")
+
+        if self.y4 - self._flank_contour_line(self.z4) > 0.001 * self.depth:
+            raise ValueError("under given conditions a step appears in z4")
+
+    @property
+    def __attrs__(self):
+        return {
+            n: v for n in ["r1", "r2", "r3", "r4", "alpha1", "alpha2", "alpha3", "alpha4", "depth", "indent",
+                           "even_ground_width", "usable_width", "classifiers", "flank_angle", "pad_angle",
+                           "ground_width",
+                           "contour_line"]
+            if (v := getattr(self, n))
+        }

pyroll/core/grooves/generic_elongation_solvers.py

@@ -0,0 +1,422 @@
+from typing import Optional
+
+import numpy as np
+from scipy.optimize import root_scalar, root, fixed_point
+
+
+def solve_r124(
+        r1: float,
+
+        r2: Optional[float],
+        depth: Optional[float],
+        width: Optional[float],
+
+        pad_angle: float,
+
+        flank_angle: Optional[float] = None,
+        flank_width: Optional[float] = None,
+        flank_height: Optional[float] = None,
+        flank_length: Optional[float] = None,
+
+        r4: float = 0,
+        indent: float = 0,
+):
+    def l23(_alpha):
+        return r1 * np.tan((_alpha + pad_angle) / 2)
+
+    if flank_angle is None:
+        if flank_length is not None:
+            def fw(_alpha):
+                return flank_length * np.cos(_alpha)
+
+            def fh(_alpha):
+                return flank_length * np.sin(_alpha)
+
+        elif flank_width is not None:
+            def fw(_alpha):
+                return flank_width
+
+            def fh(_alpha):
+                return flank_width * np.tan(_alpha)
+
+        elif flank_height is not None:
+            def fw(_alpha):
+                return flank_height / np.tan(_alpha)
+
+            def fh(_alpha):
+                return flank_height
+
+        else:
+            def fw(_alpha):
+                return 0
+
+            def fh(_alpha):
+                return 0
+
+        if width is None:
+            def f(_alpha):
+                return depth - r2 * (1 - np.cos(_alpha)) - l23(_alpha) * np.sin(_alpha) - fh(_alpha)
+
+            flank_angle = root_scalar(f, bracket=(0, np.pi / 2)).root
+
+        elif depth is None:
+            alpha4 = np.arccos(1 - indent / (r2 + r4))
+
+            def f(_alpha):
+                return (
+                        width / 2 - r2 * np.sin(_alpha) - l23(_alpha) * np.cos(_alpha)
+                        - fw(_alpha) - (r2 + r4) * np.sin(alpha4)
+                )
+
+            raster = np.linspace(0, np.pi / 2, 100)
+            values = f(raster)
+            lower = raster[values > 0][0]
+            upper = raster[values < 0][-1]
+            flank_angle = root_scalar(f, bracket=(lower, upper)).root
+
+        elif r2 is None:
+            def f(_alpha):
+                _r2 = (depth - l23(_alpha) * np.sin(_alpha) - fh(_alpha)) / (1 - np.cos(_alpha))
+                _alpha4 = np.arccos(1 - indent / (_r2 + r4))
+
+                return (
+                        width / 2 - _r2 * np.sin(_alpha) - l23(_alpha) * np.cos(_alpha)
+                        - fw(_alpha) - (_r2 + r4) * np.sin(_alpha4)
+                )
+
+            flank_angle = root_scalar(f, bracket=(0, np.pi / 2)).root
+
+        else:
+            raise TypeError("Give either usable_width or depth.")
+
+    if r2 is not None:
+        alpha4 = np.arccos(1 - indent / (r2 + r4))
+
+        if width is None:
+            width = 2 * (
+                    r2 * np.sin(flank_angle)
+                    + (depth - r2 * (1 - np.cos(flank_angle))) / np.tan(flank_angle)
+                    + (r2 + r4) * np.sin(alpha4)
+            )
+
+        elif depth is None:
+            depth = (
+                    r2 * (1 - np.cos(flank_angle))
+                    + (width / 2 - r2 * np.sin(flank_angle) - (r2 + r4) * np.sin(alpha4)) * np.tan(flank_angle)
+            )
+
+    else:
+        def f(_r2):
+            _alpha4 = np.arccos(1 - indent / (_r2 + r4))
+            return (
+                    (depth - width / 2 * np.tan(flank_angle) + r4 * np.sin(_alpha4))
+                    / (1 - np.cos(flank_angle) - np.sin(flank_angle) * np.tan(flank_angle) - np.sin(_alpha4))
+            )
+        r2 = fixed_point(f, width if width > depth else depth)
+        alpha4 = np.arccos(1 - indent / (r2 + r4))
+
+    return dict(
+        width=width,
+        depth=depth,
+        r2=r2,
+        alpha=flank_angle,
+    )
+
+
+def solve_r123(
+        r1: float,
+        r2: float,
+        r3: float,
+        depth: float,
+        width: float,
+
+        pad_angle: float,
+
+        flank_angle: Optional[float] = None,
+        flank_width: Optional[float] = None,
+        flank_height: Optional[float] = None,
+        flank_length: Optional[float] = None,
+):
+    def l23(_alpha):
+        return r1 * np.tan((_alpha + pad_angle) / 2)
+
+    r32 = r3 - r2
+
+    if flank_angle is None:
+        if flank_length is not None:
+            def fw(_alpha):
+                return flank_length * np.cos(_alpha)
+
+            def fh(_alpha):
+                return flank_length * np.sin(_alpha)
+
+        elif flank_width is not None:
+            def fw(_alpha):
+                return flank_width
+
+            def fh(_alpha):
+                return flank_width * np.tan(_alpha)
+
+        elif flank_height is not None:
+            def fw(_alpha):
+                return flank_height / np.tan(_alpha)
+
+            def fh(_alpha):
+                return flank_height
+
+        else:
+            def fw(_alpha):
+                return 0
+
+            def fh(_alpha):
+                return 0
+
+        def f(_alpha):
+            _alpha2 = _alpha[0]
+            _alpha3 = _alpha[1]
+            _flank_angle = _alpha2 + _alpha3
+            _gamma = np.pi / 2 - _flank_angle
+
+            return np.array(
+                [
+                    (
+                            depth - r3 + r32 * np.cos(_alpha3) + r2 * np.sin(_gamma)
+                            - fh(_flank_angle) - l23(_flank_angle) * np.sin(_flank_angle)
+                    ),
+                    (
+                            width / 2 - r32 * np.sin(_alpha3) - r2 * np.cos(_gamma)
+                            - fw(_flank_angle) - l23(_flank_angle) * np.cos(_flank_angle)
+                    ),
+                ]
+            )
+
+        sol = root(
+            f, np.array([np.pi / 4, np.pi / 4]),
+        )
+
+        if not sol.success:
+            raise RuntimeError("Could not determine geometric values with given input.")
+
+        alpha2 = sol.x[0]
+        alpha3 = sol.x[1]
+        flank_angle = alpha2 + alpha3
+
+    else:
+        def f(_alpha):
+            _alpha2 = _alpha
+            _alpha3 = flank_angle - _alpha
+            _gamma = np.pi / 2 - flank_angle
+
+            _fw = width / 2 - r32 * np.sin(_alpha3) - r2 * np.cos(_gamma) - l23(flank_angle) * np.cos(flank_angle)
+
+            return (
+                    depth - r3 + r32 * np.cos(_alpha3) + r2 * np.sin(_gamma)
+                    - _fw * np.tan(flank_angle) - l23(flank_angle) * np.sin(flank_angle)
+            )
+
+        sol = root_scalar(f, bracket=(0, np.pi / 2)).root
+        alpha2 = sol
+        alpha3 = flank_angle - sol
+
+    return dict(
+        flank_angle=flank_angle,
+        alpha2=alpha2,
+        alpha3=alpha3,
+    )
+
+
+def solve_r1234(
+        r1: float,
+        r2: float,
+        r3: float,
+        r4: float,
+        depth: float,
+        width: float,
+        indent: float,
+
+        pad_angle: float,
+
+        flank_angle: Optional[float] = None,
+        flank_width: Optional[float] = None,
+        flank_height: Optional[float] = None,
+        flank_length: Optional[float] = None,
+):
+    def l23(_alpha):
+        return r1 * np.tan((_alpha + pad_angle) / 2)
+
+    if flank_angle is None:
+        if flank_length is not None:
+            def fw(_alpha):
+                return flank_length * np.cos(_alpha)
+
+            def fh(_alpha):
+                return flank_length * np.sin(_alpha)
+
+        elif flank_width is not None:
+            def fw(_alpha):
+                return flank_width
+
+            def fh(_alpha):
+                return flank_width * np.tan(_alpha)
+
+        elif flank_height is not None:
+            def fw(_alpha):
+                return flank_height / np.tan(_alpha)
+
+            def fh(_alpha):
+                return flank_height
+
+        else:
+            def fw(_alpha):
+                return 0
+
+            def fh(_alpha):
+                return 0
+
+        def f(_alpha):
+            _alpha2 = _alpha[0]
+            _alpha3 = _alpha[1]
+            _alpha4 = _alpha[2]
+            _flank_angle = _alpha2 + _alpha3 - _alpha4
+
+            if _alpha3 > _alpha4:
+                _gamma = np.pi / 2 - _flank_angle
+                return np.array(
+                    [
+                        (
+                                depth - r3 + (r3 - r2) * np.cos(_alpha3 - _alpha4) + r2 * np.sin(_gamma)
+                                - fh(_flank_angle) - l23(_flank_angle) * np.sin(_flank_angle)
+                        ),
+                        (
+                                width / 2 - (r3 - r2) * np.sin(_alpha3 - _alpha4) - r2 * np.cos(_gamma)
+                                - fw(_flank_angle) - l23(_flank_angle) * np.cos(_flank_angle)
+                                - (r3 + r4) * np.sin(_alpha4)
+                        ),
+                        (
+                                indent - (r3 + r4) * (1 - np.cos(_alpha4))
+                        )
+                    ]
+                )
+            else:
+                _gamma = np.pi / 2 - _alpha4
+                return np.array(
+                    [
+                        (
+                                depth - r2 * (1 - np.cos(_flank_angle))
+                                - fh(_flank_angle) - l23(_flank_angle) * np.sin(_flank_angle)
+                        ),
+                        (
+                                width / 2 - r2 * np.sin(_flank_angle)
+                                - fw(_flank_angle) - l23(_flank_angle) * np.cos(_flank_angle)
+                                - r4 * np.sin(_alpha4) - r3 * np.cos(_gamma)
+                                - (r2 - r3) * np.sin(_alpha2 - _flank_angle)
+                        ),
+                        (
+                                indent - r4 * (1 - np.cos(_alpha4)) + r3 * np.sin(_gamma)
+                                + (r2 - r3) * np.cos(_alpha4 - _alpha3) - r2
+                        )
+                    ]
+                )
+
+        sol = root(
+            f, np.array([np.pi / 4, np.pi / 4, np.pi / 4]),
+        )
+
+        if not sol.success:
+            raise RuntimeError("Could not determine geometric values with given input.")
+
+        alpha2 = sol.x[0]
+        alpha3 = sol.x[1]
+        alpha4 = sol.x[2]
+        flank_angle = alpha2 + alpha3 - alpha4
+
+    else:
+        def f(_alpha):
+            _alpha2 = _alpha[0]
+            _alpha3 = _alpha[1]
+            _alpha4 = _alpha2 + _alpha3 - flank_angle
+            _gamma = np.pi / 2 - flank_angle
+
+            _fw = width / 2 - (r3 - r2) * np.sin(_alpha3) - r2 * np.cos(_gamma) - l23(flank_angle) * np.cos(flank_angle)
+
+            return np.array(
+                [
+                    (
+                            depth - r3 + (r3 - r2) * np.cos(_alpha3 - _alpha4) + r2 * np.sin(_gamma)
+                            - _fw * np.tan(flank_angle) - l23(flank_angle) * np.sin(flank_angle)
+                    ),
+                    (
+                            indent - (r3 + r4) * (1 - np.cos(_alpha4))
+                    )
+                ]
+            )
+
+        sol = root(
+            f, np.array([np.pi / 4, np.pi / 4]),
+        )
+
+        if not sol.success:
+            raise RuntimeError("Could not determine geometric values with given input.")
+
+        alpha2 = sol.x[0]
+        alpha3 = sol.x[1]
+        alpha4 = alpha2 + alpha3 - flank_angle
+
+    return dict(
+        flank_angle=flank_angle,
+        alpha2=alpha2,
+        alpha3=alpha3,
+        alpha4=alpha4,
+    )
+
+
+def solve_box_like(
+        r2: float,
+        r4: float,
+        depth: float,
+        indent: float,
+        ground_width: Optional[float],
+        even_ground_width: Optional[float],
+        usable_width: Optional[float],
+        flank_angle: Optional[float],
+):
+    alpha4 = np.arccos(1 - indent / (r2 + r4))
+
+    if flank_angle is None:
+        if usable_width is not None:
+            if ground_width is not None:
+                flank_angle = np.arctan(depth / (usable_width - ground_width) * 2)
+            elif even_ground_width is not None:
+                def f(_alpha):
+                    _ground_width = even_ground_width + 2 * ((r4 + r2) * np.sin(alpha4) + r2 * np.tan(_alpha / 2))
+                    return depth - (usable_width - _ground_width) / 2 * np.tan(_alpha)
+
+                flank_angle = root_scalar(f, bracket=(0, np.pi / 2)).root
+                ground_width = even_ground_width + 2 * ((r4 + r2) * np.sin(alpha4) + r2 * np.tan(flank_angle / 2))
+            else:
+                raise TypeError("either ground_width or even_ground_width must not be None")
+        else:
+            raise TypeError("usable_width must not be None if flank_angle is None")
+    elif ground_width is None and even_ground_width is None:
+        if usable_width is not None:
+            ground_width = usable_width - 2 * depth / np.tan(flank_angle)
+        else:
+            raise TypeError("usable_width must not be None if ground_width and even_ground_width are None")
+    elif usable_width is None:
+        if ground_width is None:
+            ground_width = even_ground_width + 2 * ((r4 + r2) * np.sin(alpha4) + r2 * np.tan(flank_angle / 2))
+
+        usable_width = ground_width + 2 * depth / np.tan(flank_angle)
+    else:
+        raise TypeError("either flank_angle, ground_width or usable_width must be None")
+
+    if even_ground_width is None:
+        even_ground_width = ground_width - 2 * ((r4 + r2) * np.sin(alpha4) + r2 * np.tan(flank_angle / 2))
+
+    return dict(
+        ground_width=ground_width,
+        usable_width=usable_width,
+        flank_angle=flank_angle,
+        even_ground_width=even_ground_width,
+        alpha4=alpha4
+    )