pyroll-core 3.1.13__tar.gz → 3.2.0b2__tar.gz

{pyroll_core-3.1.13 → pyroll_core-3.2.0b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyroll-core
-Version: 3.1.13
+Version: 3.2.0b2
 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

{pyroll_core-3.1.13 → pyroll_core-3.2.0b2}/pyroll/core/__init__.py

@@ -24,10 +24,20 @@ from .grooves import (
     FlatGroove,
     HexagonalGroove,
     EquivalentRibbedGroove,
+    ButterflyGroove,
+    GroovePair,
+    butterfly_grooves,
     create_groove_by_type_name,
 )
-from .transport import Transport, CoolingPipe, Spooler, StelmorConveyor, InductionFurnace
-from .roll_pass import BaseRollPass, DeformationUnit, ThreeRollPass, SymmetricRollPass, TwoRollPass
+from .transport import Transport, CoolingPipe, Spooler
+from .roll_pass import (
+    BaseRollPass,
+    DeformationUnit,
+    ThreeRollPass,
+    SymmetricRollPass,
+    TwoRollPass,
+    AsymmetricTwoRollPass,
+)
 from .roll_pass import TwoRollPass as RollPass
 from .unit import Unit
 from .roll import Roll
@@ -45,7 +55,7 @@ from .hooks import Hook, HookHost, HookFunction, root_hooks
 from .disk_elements import DiskElementUnit
 from .config import Config, config, PlottingBackend, ConfigValue, ConfigMeta
 
-VERSION = "3.1.13"
+VERSION = "3.2.0b2"
 
 __all__ = [
     # grooves
@@ -72,6 +82,9 @@ __all__ = [
     "FlatGroove",
     "HexagonalGroove",
     "EquivalentRibbedGroove",
+    "ButterflyGroove",
+    "GroovePair",
+    "butterfly_grooves",
     "create_groove_by_type_name",
     # profile
     "Profile",
@@ -85,8 +98,6 @@ __all__ = [
     "Transport",
     "CoolingPipe",
     "Spooler",
-    "StelmorConveyor",
-    "InductionFurnace",
     # roll_pass
     "RollPass",
     "BaseRollPass",
@@ -118,8 +129,10 @@ __all__ = [
 
 root_hooks.extend(
     [
+        AsymmetricTwoRollPass.InProfile.cross_section,
         BaseRollPass.roll_force,
-        BaseRollPass.Roll.roll_torque,
+        SymmetricRollPass.Roll.roll_torque,
+        AsymmetricTwoRollPass.Roll.roll_torque,
         BaseRollPass.Engine.power,
         BaseRollPass.elongation_efficiency,
         Unit.power,

{pyroll_core-3.1.13 → pyroll_core-3.2.0b2}/pyroll/core/engine/hookimpls.py

@@ -3,10 +3,6 @@ import numpy as np
 from .engine import Engine
 from ..transport import Transport
 
-@Engine.gear_ratio
-def default_gear_ratio(self: Engine):
-    return 1
-
 @Engine.gear_box_efficiency
 def gear_box_efficiency_becker(self: Engine):
     return 0.95

{pyroll_core-3.1.13 → pyroll_core-3.2.0b2}/pyroll/core/grooves/__init__.py

@@ -2,11 +2,16 @@ from .base import GrooveBase
 
 from .spline import SplineGroove
 from .generic_elongation import GenericElongationGroove
+from .generic_angle import GenericAngleGroove
 
 from .boxes import BoxGroove, ConstrictedBoxGroove, UpsetBoxGroove, ConstrictedUpsetBoxGroove
 
 from .diamonds import DiamondGroove, SquareGroove, GothicGroove
-
+from .angles import (
+    ButterflyGroove,
+    GroovePair,
+    butterfly_grooves,
+)
 from .ovals import (
     CircularOvalGroove,
     FlatOvalGroove,
@@ -50,6 +55,10 @@ __all__ = [
     "FlatGroove",
     "HexagonalGroove",
     "EquivalentRibbedGroove",
+    "ButterflyGroove",
+    "GroovePair",
+    "butterfly_grooves",
+    "GenericAngleGroove",
     "create_groove_by_type_name",
 ]
 

pyroll_core-3.2.0b2/pyroll/core/grooves/angles/__init__.py

@@ -0,0 +1,8 @@
+from .butterfly_groove import ButterflyGroove
+from .factories import GroovePair, butterfly_grooves
+
+__all__ = [
+    "ButterflyGroove",
+    "GroovePair",
+    "butterfly_grooves",
+]

pyroll_core-3.2.0b2/pyroll/core/grooves/angles/_geometry.py

@@ -0,0 +1,224 @@
+from typing import Tuple
+
+import numpy as np
+
+__all__ = [
+    "line_through",
+    "line_point_angle",
+    "horizontal_line",
+    "vertical_line",
+    "intersect",
+    "offset_toward",
+    "perpendicular_foot",
+    "fillet_line_line",
+    "fillet_line_circle",
+    "line_circle_intersection",
+    "circle_circle_intersection",
+    "arc_points",
+    "Circle",
+]
+
+Line = np.ndarray
+Point = np.ndarray
+
+Circle = Tuple[float, float, float]
+"""Circle as tuple ``(center_z, center_y, radius)``."""
+
+
+def line_through(p1, p2) -> Line:
+    """Line through two points (Matlab ``gpp``)."""
+    p1 = np.asarray(p1, dtype=float)
+    p2 = np.asarray(p2, dtype=float)
+    a = p2[1] - p1[1]
+    b = p1[0] - p2[0]
+    c = -a * p1[0] - b * p1[1]
+    return np.array([a, b, c])
+
+
+def line_point_angle(p, angle: float) -> Line:
+    """Line through a point with given angle measured from the vertical axis.
+
+    :param angle: angle to the y-axis in radians
+    """
+    p = np.asarray(p, dtype=float)
+    p2 = p + np.array([-np.sin(angle), np.cos(angle)])
+    return line_through(p, p2)
+
+
+def horizontal_line(y: float) -> Line:
+    """Horizontal line at given y."""
+    return np.array([0.0, 1.0, -float(y)])
+
+
+def vertical_line(z: float) -> Line:
+    """Vertical line at given z."""
+    return np.array([1.0, 0.0, -float(z)])
+
+
+def intersect(g1: Line, g2: Line) -> Point:
+    """Intersection point of two lines."""
+    d = g1[0] * g2[1] - g2[0] * g1[1]
+    if np.isclose(d, 0):
+        raise ValueError("Lines are parallel, no intersection exists.")
+    z = (g2[2] * g1[1] - g1[2] * g2[1]) / d
+    y = (g1[2] * g2[0] - g2[2] * g1[0]) / d
+    return np.array([z, y])
+
+
+def _normalized(g: Line) -> Line:
+    n = np.hypot(g[0], g[1])
+    return g / n
+
+
+def signed_distance(g: Line, p) -> float:
+    """Signed distance of a point from a line."""
+    g = _normalized(g)
+    p = np.asarray(p, dtype=float)
+    return g[0] * p[0] + g[1] * p[1] + g[2]
+
+
+def offset_toward(g: Line, dist: float, toward) -> Line:
+    """Parallel line at given distance, shifted towards the hint point."""
+    g = _normalized(g)
+    side = np.sign(signed_distance(g, toward))
+    if side == 0:
+        raise ValueError("Hint point lies on the line, offset side is ambiguous.")
+    return np.array([g[0], g[1], g[2] - side * dist])
+
+
+def perpendicular_foot(g: Line, p) -> Point:
+    """Foot of the perpendicular from a point onto a line."""
+    g = _normalized(g)
+    p = np.asarray(p, dtype=float)
+    return p - signed_distance(g, p) * g[:2]
+
+
+def fillet_line_line(g1: Line, g2: Line, radius: float, toward, toward2=None) -> Tuple[Point, Point, Point]:
+    """
+    Fillet circle of given radius tangent to two lines.
+
+    :param toward: hint point on the side of ``g1`` where the fillet center lies
+    :param toward2: hint point on the side of ``g2`` where the fillet center lies, defaults to ``toward``
+    :return: tuple of (center, tangent point on g1, tangent point on g2)
+    """
+    if toward2 is None:
+        toward2 = toward
+    center = intersect(offset_toward(g1, radius, toward), offset_toward(g2, radius, toward2))
+    return center, perpendicular_foot(g1, center), perpendicular_foot(g2, center)
+
+
+def fillet_corner(g1: Line, g2: Line, radius: float, along1, along2) -> Tuple[Point, Point, Point]:
+    """
+    Fillet circle smoothing the corner between two lines, selecting the branch by the
+    retained line segments: the fillet lies inside the wedge spanned by the half-lines
+    from the corner towards ``along1`` and ``along2``.
+
+    :param along1: point on (or towards) the retained part of ``g1``
+    :param along2: point on (or towards) the retained part of ``g2``
+    :return: tuple of (center, tangent point on g1, tangent point on g2)
+    """
+    corner = intersect(g1, g2)
+
+    d1 = np.asarray(along1, dtype=float) - corner
+    d2 = np.asarray(along2, dtype=float) - corner
+    d1 = d1 / np.hypot(*d1)
+    d2 = d2 / np.hypot(*d2)
+
+    bisector = d1 + d2
+    norm = np.hypot(*bisector)
+    if np.isclose(norm, 0):
+        raise ValueError("Retained segments are opposite, fillet side is ambiguous.")
+
+    hint = corner + bisector / norm
+    return fillet_line_line(g1, g2, radius, toward=hint)
+
+
+def line_circle_intersection(g: Line, k: Circle, toward) -> Point:
+    """Intersection of a line and a circle nearest to the hint point."""
+    g = _normalized(g)
+    m = np.array([k[0], k[1]])
+    r = k[2]
+
+    d = signed_distance(g, m)
+    if abs(d) > r:
+        raise ValueError("Line and circle do not intersect.")
+
+    foot_point = m - d * g[:2]
+    half_chord = np.sqrt(max(r**2 - d**2, 0))
+    direction = np.array([-g[1], g[0]])
+
+    candidates = [foot_point + half_chord * direction, foot_point - half_chord * direction]
+    toward = np.asarray(toward, dtype=float)
+    return min(candidates, key=lambda p: np.hypot(*(p - toward)))
+
+
+def circle_circle_intersection(k1: Circle, k2: Circle, toward) -> Point:
+    """Intersection of two circles nearest to the hint point; tangency point if they just touch."""
+    m1 = np.array([k1[0], k1[1]])
+    m2 = np.array([k2[0], k2[1]])
+    d = np.hypot(*(m2 - m1))
+
+    if d > k1[2] + k2[2] and not np.isclose(d, k1[2] + k2[2]):
+        raise ValueError("Circles do not intersect.")
+    if d < abs(k1[2] - k2[2]) and not np.isclose(d, abs(k1[2] - k2[2])):
+        raise ValueError("One circle lies inside the other, no intersection exists.")
+
+    a = (k1[2] ** 2 - k2[2] ** 2 + d**2) / (2 * d)
+    h = np.sqrt(max(k1[2] ** 2 - a**2, 0))
+
+    direction = (m2 - m1) / d
+    base = m1 + a * direction
+    perp = np.array([-direction[1], direction[0]])
+
+    candidates = [base + h * perp, base - h * perp]
+    toward = np.asarray(toward, dtype=float)
+    return min(candidates, key=lambda p: np.hypot(*(p - toward)))
+
+
+def fillet_line_circle(
+    g: Line, k: Circle, radius: float, toward, externally: bool = True
+) -> Tuple[Point, Point, Point]:
+    """
+    Fillet circle of given radius tangent to a line and a circle.
+
+    :param toward: hint point selecting the offset side of the line and the solution branch
+    :param externally: whether the fillet touches the circle from outside (default) or inside
+    :return: tuple of (center, tangent point on the line, tangent point on the circle)
+    """
+    g_offset = offset_toward(g, radius, toward)
+    expanded = (k[0], k[1], k[2] + radius if externally else k[2] - radius)
+    center = line_circle_intersection(g_offset, expanded, toward)
+
+    tangent_line = perpendicular_foot(g, center)
+
+    circle_center = np.array([k[0], k[1]])
+    direction = center - circle_center
+    direction = direction / np.hypot(*direction)
+    tangent_circle = circle_center + k[2] * direction
+
+    return center, tangent_line, tangent_circle
+
+
+def arc_points(center, start, end, count: int) -> np.ndarray:
+    """
+    Discretize the circular arc from start to end point around center,
+    always sweeping the smaller angle.
+
+    :return: array of shape (count, 2) including start and end point
+    """
+    center = np.asarray(center, dtype=float)
+    v1 = np.asarray(start, dtype=float) - center
+    v2 = np.asarray(end, dtype=float) - center
+
+    radius = np.hypot(*v1)
+    phi1 = np.arctan2(v1[1], v1[0])
+    phi2 = np.arctan2(v2[1], v2[0])
+
+    sweep = phi2 - phi1
+    if sweep > np.pi:
+        sweep -= 2 * np.pi
+    elif sweep < -np.pi:
+        sweep += 2 * np.pi
+
+    phi = phi1 + np.linspace(0, sweep, count)
+    return center + radius * np.stack([np.cos(phi), np.sin(phi)], axis=1)

pyroll_core-3.2.0b2/pyroll/core/grooves/angles/_path.py

@@ -0,0 +1,203 @@
+from typing import Sequence, Union
+
+import numpy as np
+
+from . import _geometry as geo
+from ...config import Config
+
+__all__ = ["chain_contour", "build_filleted_contour"]
+
+Carrier = Union[np.ndarray, geo.Circle]
+
+
+def _is_line(carrier: Carrier) -> bool:
+    return isinstance(carrier, np.ndarray)
+
+
+def chain_contour(start, steps: Sequence[tuple]) -> np.ndarray:
+    """
+    Assemble a contour point array from explicit steps.
+
+    :param start: starting point of the contour
+    :param steps: sequence of steps, each either ``("line", point)`` for a straight
+        segment to ``point`` or ``("arc", center, point)`` for a circular arc around
+        ``center`` to ``point`` (sweeping the smaller angle)
+    :return: array of shape (n, 2)
+    """
+    n = Config.GROOVE_RADIUS_POINT_COUNT
+    current = np.asarray(start, dtype=float)
+    parts = [current.reshape(1, 2)]
+
+    for step in steps:
+        if step[0] == "line":
+            target = np.asarray(step[1], dtype=float)
+            parts.append(target.reshape(1, 2))
+        elif step[0] == "arc":
+            center, target = step[1], np.asarray(step[2], dtype=float)
+            arc = geo.arc_points(center, current, target, n)[1:]
+            arc[-1] = target  # snap the recomputed arc end onto the exact target
+            parts.append(arc)
+        else:
+            raise ValueError(f"Unknown contour step type: {step[0]!r}")
+        current = target
+
+    return np.vstack(parts)
+
+
+def _nominal_vertex(c1: Carrier, c2: Carrier, toward) -> np.ndarray:
+    """Nominal junction point of two carriers: intersection resp. tangency nearest the hint."""
+    if _is_line(c1) and _is_line(c2):
+        return geo.intersect(c1, c2)
+
+    if _is_line(c1) or _is_line(c2):
+        line, circle = (c1, c2) if _is_line(c1) else (c2, c1)
+        try:
+            return geo.line_circle_intersection(line, circle, toward)
+        except ValueError:
+            center = np.array([circle[0], circle[1]])
+            foot = geo.perpendicular_foot(line, center)
+            direction = foot - center
+            direction = direction / np.hypot(*direction)
+            return (foot + center + circle[2] * direction) / 2
+
+    m1 = np.array([c1[0], c1[1]])
+    m2 = np.array([c2[0], c2[1]])
+    direction = m2 - m1
+    direction = direction / np.hypot(*direction)
+    return m1 + c1[2] * direction
+
+
+def _arc_midpoint(circle: geo.Circle, p1, p2) -> np.ndarray:
+    """Midpoint of the smaller arc of the circle between the projections of two points onto it."""
+    center = np.array([circle[0], circle[1]])
+    phi = []
+    for p in (p1, p2):
+        d = np.asarray(p, dtype=float) - center
+        phi.append(np.arctan2(d[1], d[0]))
+
+    sweep = phi[1] - phi[0]
+    if sweep > np.pi:
+        sweep -= 2 * np.pi
+    elif sweep < -np.pi:
+        sweep += 2 * np.pi
+
+    mid = phi[0] + sweep / 2
+    return center + circle[2] * np.array([np.cos(mid), np.sin(mid)])
+
+
+def _fillet_line_circle_auto(
+    line: np.ndarray, circle: geo.Circle, radius: float, vertex, line_ref, circle_ref, hint=None
+):
+    """
+    Fillet between a line and a circle with automatic branch selection.
+
+    The offset side hint is taken along the bisector between the retained line direction
+    and the direction to the midpoint of the retained circle arc (or from the explicit
+    ``hint`` point); the internal/external branch by the solution whose tangent points
+    lie nearest to the nominal junction vertex.
+    """
+    if hint is None:
+        d1 = np.asarray(line_ref, dtype=float) - vertex
+        d2 = _arc_midpoint(circle, vertex, circle_ref) - vertex
+        d1 = d1 / np.hypot(*d1)
+        norm2 = np.hypot(*d2)
+        if np.isclose(norm2, 0):
+            # junction vertex coincides with the retained arc midpoint: tangent line and circle,
+            # the fillet side degenerates to the circle side of the line
+            d2 = np.array([circle[0], circle[1]]) - vertex
+            norm2 = np.hypot(*d2)
+        d2 = d2 / norm2
+        bisector = d1 + d2
+        norm = np.hypot(*bisector)
+        if np.isclose(norm, 0):
+            raise ValueError("Retained segments are opposite, fillet side is ambiguous.")
+        hint = vertex + bisector / norm * radius
+
+    solutions = []
+    for externally in (True, False):
+        try:
+            center, t_line, t_circle = geo.fillet_line_circle(line, circle, radius, toward=hint, externally=externally)
+        except ValueError:
+            continue
+        score = np.hypot(*(t_line - vertex)) + np.hypot(*(t_circle - vertex))
+        solutions.append((score, center, t_line, t_circle))
+
+    if not solutions:
+        raise ValueError("No fillet between line and circle exists for the given radius.")
+
+    _, center, t_line, t_circle = min(solutions, key=lambda s: s[0])
+    return center, t_line, t_circle
+
+
+def build_filleted_contour(start, path: Sequence, end, hints: dict = None) -> np.ndarray:
+    """
+    Build a contour from a chain of carriers with transition radii at the junctions.
+
+    :param start: starting point, lying on the first carrier
+    :param path: flat alternating sequence ``carrier, radius, carrier, radius, ..., carrier``;
+        lines as ``numpy`` arrays (see :py:mod:`._geometry`), circles as
+        ``(center_z, center_y, radius)`` tuples; a radius of 0 gives a sharp corner
+        (line-line) resp. a direct tangent junction (with a circle carrier)
+    :param end: end point, lying on the last carrier
+    :param hints: optional explicit fillet side hint points by junction index (0-based,
+        counting the radii in ``path``), overriding the automatic side selection for
+        geometrically ambiguous junctions
+    :return: array of shape (n, 2)
+    """
+    hints = hints or {}
+    carriers = list(path[0::2])
+    radii = list(path[1::2])
+    if len(carriers) != len(radii) + 1:
+        raise ValueError("Path must be an alternating sequence carrier, radius, ..., carrier.")
+
+    start = np.asarray(start, dtype=float)
+    end = np.asarray(end, dtype=float)
+
+    vertices = []
+    ref = start
+    for c1, c2 in zip(carriers[:-1], carriers[1:]):
+        if not _is_line(c1):
+            ref = 2 * np.array([c1[0], c1[1]]) - ref
+        ref = _nominal_vertex(c1, c2, ref)
+        vertices.append(ref)
+
+    ref_points = [start, *vertices, end]
+
+    steps = []
+    for i, radius in enumerate(radii):
+        c1, c2 = carriers[i], carriers[i + 1]
+        vertex = vertices[i]
+        prev_ref, next_ref = ref_points[i], ref_points[i + 2]
+
+        if radius == 0:
+            junction_steps = [("line", vertex)] if _is_line(c1) else [("arc", (c1[0], c1[1]), vertex)]
+            steps.append((junction_steps, vertex))
+            continue
+
+        hint = hints.get(i)
+
+        if _is_line(c1) and _is_line(c2):
+            if hint is not None:
+                center, t1, t2 = geo.fillet_line_line(c1, c2, radius, toward=hint)
+            else:
+                center, t1, t2 = geo.fillet_corner(c1, c2, radius, along1=prev_ref, along2=next_ref)
+        elif _is_line(c1) or _is_line(c2):
+            if _is_line(c1):
+                line, circle, line_ref, circle_ref = c1, c2, prev_ref, next_ref
+            else:
+                line, circle, line_ref, circle_ref = c2, c1, next_ref, prev_ref
+            center, t_line, t_circle = _fillet_line_circle_auto(
+                line, circle, radius, vertex, line_ref, circle_ref, hint=hint
+            )
+            t1, t2 = (t_line, t_circle) if _is_line(c1) else (t_circle, t_line)
+        else:
+            raise NotImplementedError("Fillets between two circle carriers are not supported.")
+
+        approach = [("line", t1)] if _is_line(c1) else [("arc", (c1[0], c1[1]), t1)]
+        steps.append((approach + [("arc", center, t2)], t2))
+
+    last = carriers[-1]
+    final_step = ("line", end) if _is_line(last) else ("arc", (last[0], last[1]), end)
+
+    all_steps = [s for junction_steps, _ in steps for s in junction_steps] + [final_step]
+    return chain_contour(start, all_steps)