pyroll-core 2.0.0__py3-none-any.whl

pyroll/core/grooves/hexagonal.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 HexagonalGroove(GenericElongationGroove):
+    """Represents a hexagonal-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 {"hexagonal"} | super().classifiers

pyroll/core/grooves/ovals/__init__.py

@@ -0,0 +1,8 @@
+from .circular_oval import CircularOvalGroove
+from .flat_oval import FlatOvalGroove
+from .swedish_oval import SwedishOvalGroove
+from .constricted_swedish_oval import ConstrictedSwedishOvalGroove
+from .oval_3radii import Oval3RadiiGroove
+from .oval_3radii_flanked import Oval3RadiiFlankedGroove
+from .upset_oval import UpsetOvalGroove
+from .constricted_circular_oval import ConstrictedCircularOvalGroove

pyroll/core/grooves/ovals/circular_oval.py

@@ -0,0 +1,43 @@
+from typing import Optional
+
+import numpy as np
+
+from ..generic_elongation import GenericElongationGroove
+from ..generic_elongation_solvers import solve_r124
+
+
+class CircularOvalGroove(GenericElongationGroove):
+    """Represents an oval-shaped groove with one main radius."""
+
+    def __init__(
+            self,
+            r1: float,
+            r2: Optional[float] = None,
+            depth: Optional[float] = None,
+            usable_width: Optional[float] = None,
+            pad_angle: float = 0,
+            **kwargs
+    ):
+        """
+        Give exactly two of ``r2``, ``depth`` or ``usable_width``.
+
+        :param r1: radius 1 (face/flank)
+        :param r2: radius 2 (flank/ground)
+        :param depth: maximum depth
+        :param usable_width: usable width
+        :param pad_angle: angle between z-axis and the roll face padding
+        :param kwargs: more keyword arguments passed to the GenericElongationGroove constructor
+        """
+        pad_angle = np.deg2rad(pad_angle)
+
+        sol = solve_r124(r1=r1, r2=r2, depth=depth, width=usable_width, pad_angle=pad_angle)
+
+        super().__init__(
+            r2=sol["r2"], depth=sol["depth"], usable_width=sol["width"], flank_angle=sol["alpha"],
+            r1=r1, pad_angle=pad_angle,
+            **kwargs
+        )
+
+    @property
+    def classifiers(self):
+        return {"oval", "circular_oval"} | super().classifiers

pyroll/core/grooves/ovals/constricted_circular_oval.py

@@ -0,0 +1,53 @@
+from typing import Optional
+
+import numpy as np
+
+from ..generic_elongation import GenericElongationGroove
+from ..generic_elongation_solvers import solve_r1234
+
+
+class ConstrictedCircularOvalGroove(GenericElongationGroove):
+    """Represents an oval-shaped groove with one main radius."""
+
+    def __init__(
+            self,
+            r1: float,
+            r2: float,
+            r3: float,
+            r4: float,
+            depth: float,
+            usable_width: float,
+            indent: float,
+            even_ground_width: float = 0,
+            pad_angle: float = 0,
+            **kwargs
+    ):
+        """
+        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 r4: radius 4 (indent)
+        :param depth: maximum depth
+        :param usable_width: usable width of the groove
+        :param even_ground_width: width of the even ground line
+        :param pad_angle: angle between z-axis and the roll face padding
+        :param kwargs: more keyword arguments passed to the GenericElongationGroove constructor
+        """
+
+        pad_angle = np.deg2rad(pad_angle)
+
+        sol = solve_r1234(r1, r2, r3, r4, depth, usable_width - even_ground_width, indent, pad_angle)
+
+        super().__init__(
+            usable_width=usable_width, depth=depth, indent=indent,
+            even_ground_width=even_ground_width,
+            r1=r1, r2=r2, r3=r3, r4=r4,
+            flank_angle=sol["flank_angle"], alpha3=sol["alpha3"], alpha4=sol["alpha4"], pad_angle=pad_angle,
+            **kwargs
+        )
+
+    @property
+    def classifiers(self):
+        return {"oval", "circular_oval", "constricted"} | super().classifiers

pyroll/core/grooves/ovals/constricted_swedish_oval.py

@@ -0,0 +1,61 @@
+from typing import Optional
+
+import numpy as np
+
+from ..generic_elongation import GenericElongationGroove
+from ..generic_elongation_solvers import solve_box_like
+
+
+class ConstrictedSwedishOvalGroove(GenericElongationGroove):
+    """Represents a hexagonal-shaped groove with an indented ground that is used like an oval groove (swedish oval)."""
+
+    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
+        )
+
+        super().__init__(
+            r1=r1, r2=r2, r4=r4, pad_angle=np.deg2rad(pad_angle), indent=indent,
+            **sol,
+            **kwargs
+        )
+
+    @property
+    def classifiers(self):
+        return {"oval", "swedish_oval", "constricted_swedish_oval"} | super().classifiers

pyroll/core/grooves/ovals/flat_oval.py

@@ -0,0 +1,56 @@
+from typing import Optional
+
+import numpy as np
+
+from ..generic_elongation import GenericElongationGroove
+from ..generic_elongation_solvers import solve_r124
+
+
+class FlatOvalGroove(GenericElongationGroove):
+    """Represent an oval-shaped groove with a flat ground."""
+
+    def __init__(
+            self,
+            r1: float,
+            r2: float,
+            depth: float,
+            usable_width: Optional[float] = None,
+            even_ground_width: Optional[float] = None,
+            pad_angle: float = 0,
+            **kwargs
+    ):
+        """
+        Give exactly one of ``usable_width`` and ``even_ground_width``.
+
+        :param r1: radius 1 (face/flank)
+        :param r2: radius 2 (flank/ground)
+        :param depth: maximum depth
+        :param usable_width: usable width
+        :param even_ground_width: width of the straight ground line
+        :param pad_angle: angle between z-axis and the roll face padding
+        :param kwargs: more keyword arguments passed to the GenericElongationGroove constructor
+        """
+        pad_angle = np.deg2rad(pad_angle)
+
+        sol = solve_r124(r1=r1, r2=r2, depth=depth, width=None, pad_angle=pad_angle)
+
+        if usable_width is None and even_ground_width is not None:
+            super().__init__(
+                r2=sol["r2"], depth=sol["depth"], usable_width=even_ground_width + sol["width"],
+                flank_angle=sol["alpha"], even_ground_width=even_ground_width,
+                r1=r1, pad_angle=pad_angle,
+                **kwargs
+            )
+        elif even_ground_width is None and usable_width is not None:
+            super().__init__(
+                r2=sol["r2"], depth=sol["depth"], usable_width=usable_width, flank_angle=sol["alpha"],
+                even_ground_width=usable_width - sol["width"],
+                r1=r1, pad_angle=pad_angle,
+                **kwargs
+            )
+        else:
+            raise TypeError("Give exactly one of usable_width and even_ground_width.")
+
+    @property
+    def classifiers(self):
+        return {"oval", "flat_oval"} | super().classifiers

pyroll/core/grooves/ovals/oval_3radii.py

@@ -0,0 +1,47 @@
+from typing import Optional
+import numpy as np
+from scipy.optimize import minimize, Bounds
+from numpy import sin, cos, tan, pi, array
+from ..generic_elongation import GenericElongationGroove
+from ..generic_elongation_solvers import solve_r123
+
+
+class Oval3RadiiGroove(GenericElongationGroove):
+    """Represents an oval-shaped groove with 3 main radii."""
+
+    def __init__(
+            self,
+            r1: float,
+            r2: float,
+            r3: float,
+            depth: float,
+            usable_width: float,
+            pad_angle: float = 0,
+            **kwargs
+    ):
+        """
+        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
+        :param kwargs: more keyword arguments passed to the GenericElongationGroove constructor
+        """
+
+        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,
+            **kwargs
+        )
+
+    @property
+    def classifiers(self):
+        return {"oval", "oval_3_radii"} | super().classifiers

pyroll/core/grooves/ovals/oval_3radii_flanked.py

@@ -0,0 +1,65 @@
+from typing import Optional
+
+import numpy as np
+from scipy.optimize import brentq
+from numpy import sin, cos, tan, pi
+
+from ..generic_elongation import GenericElongationGroove
+from ..generic_elongation_solvers import solve_r123
+
+
+class Oval3RadiiFlankedGroove(GenericElongationGroove):
+    """Represents an oval-shaped groove with 3 main radii and a dedicated flank."""
+
+    def __init__(
+            self,
+            r1: float,
+            r2: float,
+            r3: float,
+            depth: float,
+            usable_width: float,
+            flank_angle: Optional[float] = None,
+            flank_width: Optional[float] = None,
+            flank_height: Optional[float] = None,
+            flank_length: Optional[float] = None,
+            pad_angle: float = 0,
+            **kwargs
+    ):
+        """
+        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 r3: radius 3 (ground)
+        :param depth: maximum depth
+        :param usable_width: usable width of the groove
+
+        :param flank_angle: inclination angle of the flanks
+        :param flank_width: horizontal extent of the flanks
+        :param flank_height: vertical extent of the flanks
+        :param flank_length: length 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
+        """
+
+        if flank_angle is not None:
+            flank_angle = np.deg2rad(flank_angle)
+
+        pad_angle = np.deg2rad(pad_angle)
+
+        sol = solve_r123(
+            r1, r2, r3, depth, usable_width, pad_angle, flank_angle, flank_width, flank_height, flank_length
+        )
+
+        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,
+            **kwargs
+        )
+
+    @property
+    def classifiers(self):
+        return {"oval", "oval_3_radii", "oval_3_radii_flanked"} | super().classifiers

pyroll/core/grooves/ovals/swedish_oval.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 SwedishOvalGroove(GenericElongationGroove):
+    """Represents a hexagonal-shaped groove that is used like an oval groove (swedish oval)."""
+
+    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 {"oval", "swedish_oval"} | super().classifiers

pyroll/core/grooves/ovals/upset_oval.py

@@ -0,0 +1,47 @@
+import numpy as np
+from ..generic_elongation import GenericElongationGroove
+from ..generic_elongation_solvers import solve_r123
+
+
+class UpsetOvalGroove(GenericElongationGroove):
+    """Represents an upright oval-shaped groove."""
+
+    def __init__(
+            self,
+            r1: float,
+            r2: float,
+            r3: float,
+            depth: float,
+            usable_width: float,
+            pad_angle: float = 0,
+            **kwargs
+    ):
+        """
+        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 kwargs: more keyword arguments passed to the GenericElongationGroove constructor
+        :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)
+
+        if sol["flank_angle"] > np.pi / 2:
+            raise ValueError("under the given conditions the flank angle is > 90°")
+
+        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,
+            **kwargs
+        )
+
+    @property
+    def classifiers(self):
+        return {"oval", "upset"} | super().classifiers

pyroll/core/grooves/rounds/__init__.py

@@ -0,0 +1,2 @@
+from .round import RoundGroove
+from .false_round import FalseRoundGroove

pyroll/core/grooves/rounds/false_round.py

@@ -0,0 +1,65 @@
+from typing import Optional
+
+import numpy as np
+
+from ..generic_elongation import GenericElongationGroove
+from ..generic_elongation_solvers import solve_r124
+
+
+class FalseRoundGroove(GenericElongationGroove):
+    """Represents a round-shaped groove with a dedicated flank (false round)."""
+
+    def __init__(
+            self,
+            r1: float,
+
+            r2: Optional[float] = None,
+            depth: Optional[float] = None,
+            usable_width: Optional[float] = None,
+
+            flank_angle: Optional[float] = None,
+            flank_width: Optional[float] = None,
+            flank_height: Optional[float] = None,
+            flank_length: Optional[float] = None,
+
+            pad_angle: float = 0,
+            **kwargs
+    ):
+        """
+        All angles are measured in ° (degree).
+        Give exactly two of ``r2``, ``depth`` or ``usable_width``.
+        Give exactly one of ``flank_angle``, ``flank_width``, ``flank_height`` or ``flank_length``.
+
+        :param r1: radius 1 (face/flank)
+        :param r2: radius 2 (flank/ground)
+        :param depth: maximum depth
+        :param usable_width: usable width
+
+        :param flank_angle: inclination angle of the flanks
+        :param flank_width: horizontal extent of the flanks
+        :param flank_height: vertical extent of the flanks
+        :param flank_length: length 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
+        """
+        pad_angle = np.deg2rad(pad_angle)
+
+        if flank_angle is not None:
+            flank_angle = np.deg2rad(flank_angle)
+
+        sol = solve_r124(
+            r1=r1,
+            r2=r2, depth=depth, width=usable_width,
+            pad_angle=pad_angle,
+            flank_angle=flank_angle, flank_width=flank_width, flank_height=flank_height, flank_length=flank_length
+        )
+
+        super().__init__(
+            r2=sol["r2"], depth=sol["depth"], usable_width=sol["width"], flank_angle=sol["alpha"],
+            r1=r1, pad_angle=pad_angle,
+            **kwargs
+        )
+
+    @property
+    def classifiers(self):
+        return {"round", "false_round"} | super().classifiers

pyroll/core/grooves/rounds/round.py

@@ -0,0 +1,44 @@
+from typing import Optional
+
+import numpy as np
+from scipy.optimize import root_scalar, minimize_scalar
+
+from ..generic_elongation import GenericElongationGroove
+from ..generic_elongation_solvers import solve_r124
+
+
+class RoundGroove(GenericElongationGroove):
+    """Represents a round-shaped groove."""
+
+    def __init__(
+            self,
+            r1: float,
+            r2: Optional[float] = None,
+            depth: Optional[float] = None,
+            usable_width: Optional[float] = None,
+            pad_angle: float = 0,
+            **kwargs
+    ):
+        """
+        Give exactly two of ``r2``, ``depth`` or ``usable_width``.
+
+        :param r1: radius 1 (face/flank)
+        :param r2: radius 2 (flank/ground)
+        :param depth: maximum depth
+        :param usable_width: usable width
+        :param pad_angle: angle between z-axis and the roll face padding
+        :param kwargs: more keyword arguments passed to the GenericElongationGroove constructor
+        """
+        pad_angle = np.deg2rad(pad_angle)
+
+        sol = solve_r124(r1=r1, r2=r2, depth=depth, width=usable_width, pad_angle=pad_angle)
+
+        super().__init__(
+            r2=sol["r2"], depth=sol["depth"], usable_width=sol["width"], flank_angle=sol["alpha"],
+            r1=r1, pad_angle=pad_angle,
+            **kwargs
+        )
+
+    @property
+    def classifiers(self):
+        return {"round",} | super().classifiers