pyroll-core 3.2.0b1__tar.gz → 3.2.0b2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyroll-core
-Version: 3.2.0b1
+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.2.0b1 → pyroll_core-3.2.0b2}/pyroll/core/__init__.py

@@ -24,15 +24,8 @@ from .grooves import (
     FlatGroove,
     HexagonalGroove,
     EquivalentRibbedGroove,
-    PreformingGroove,
-    EdgerGroove,
-    FinisherGroove,
-    ClosedGroove,
     ButterflyGroove,
     GroovePair,
-    precontour_grooves,
-    finisher_grooves,
-    closed_grooves,
     butterfly_grooves,
     create_groove_by_type_name,
 )
@@ -62,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.2.0b1"
+VERSION = "3.2.0b2"
 
 __all__ = [
     # grooves
@@ -89,15 +82,8 @@ __all__ = [
     "FlatGroove",
     "HexagonalGroove",
     "EquivalentRibbedGroove",
-    "PreformingGroove",
-    "EdgerGroove",
-    "FinisherGroove",
-    "ClosedGroove",
     "ButterflyGroove",
     "GroovePair",
-    "precontour_grooves",
-    "finisher_grooves",
-    "closed_grooves",
     "butterfly_grooves",
     "create_groove_by_type_name",
     # profile

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

@@ -8,15 +8,8 @@ from .boxes import BoxGroove, ConstrictedBoxGroove, UpsetBoxGroove, ConstrictedU
 
 from .diamonds import DiamondGroove, SquareGroove, GothicGroove
 from .angles import (
-    PreformingGroove,
-    EdgerGroove,
-    FinisherGroove,
-    ClosedGroove,
     ButterflyGroove,
     GroovePair,
-    precontour_grooves,
-    finisher_grooves,
-    closed_grooves,
     butterfly_grooves,
 )
 from .ovals import (
@@ -62,15 +55,8 @@ __all__ = [
     "FlatGroove",
     "HexagonalGroove",
     "EquivalentRibbedGroove",
-    "PreformingGroove",
-    "EdgerGroove",
-    "FinisherGroove",
-    "ClosedGroove",
     "ButterflyGroove",
     "GroovePair",
-    "precontour_grooves",
-    "finisher_grooves",
-    "closed_grooves",
     "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.0b1 → pyroll_core-3.2.0b2}/pyroll/core/grooves/angles/_geometry.py

@@ -1,15 +1,3 @@
-"""
-Constructive geometry toolkit for building groove contours from lines, fillets and arcs.
-
-Port of the Matlab angle roll pass design suite by Christian Overhagen (UDE),
-see ``winkelkaliber_matlab/``. Lines are represented in homogeneous coordinates
-``(a, b, c)`` with ``a * z + b * y + c = 0``. Points are ``numpy`` arrays ``(z, y)``.
-
-Instead of the Matlab origin-relative offset flags (``'i'``/``'a'``/``tausch``),
-all constructions take explicit hint points (``toward``) selecting the side on
-which an offset, fillet or intersection lies.
-"""
-
 from typing import Tuple
 
 import numpy as np
@@ -48,7 +36,7 @@ def line_through(p1, p2) -> Line:
 
 
 def line_point_angle(p, angle: float) -> Line:
-    """Line through a point with given angle measured from the vertical axis (Matlab ``gpw``).
+    """Line through a point with given angle measured from the vertical axis.
 
     :param angle: angle to the y-axis in radians
     """
@@ -68,7 +56,7 @@ def vertical_line(z: float) -> Line:
 
 
 def intersect(g1: Line, g2: Line) -> Point:
-    """Intersection point of two lines (Matlab ``schnittg``)."""
+    """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.")
@@ -90,7 +78,7 @@ def signed_distance(g: Line, p) -> float:
 
 
 def offset_toward(g: Line, dist: float, toward) -> Line:
-    """Parallel line at given distance, shifted towards the hint point (Matlab ``parger``)."""
+    """Parallel line at given distance, shifted towards the hint point."""
     g = _normalized(g)
     side = np.sign(signed_distance(g, toward))
     if side == 0:
@@ -107,7 +95,7 @@ def perpendicular_foot(g: Line, p) -> Point:
 
 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 (Matlab ``spgkg``).
+    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``
@@ -146,7 +134,7 @@ def fillet_corner(g1: Line, g2: Line, radius: float, along1, along2) -> Tuple[Po
 
 
 def line_circle_intersection(g: Line, k: Circle, toward) -> Point:
-    """Intersection of a line and a circle nearest to the hint point (Matlab ``spkg``)."""
+    """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]
@@ -157,7 +145,7 @@ def line_circle_intersection(g: Line, k: Circle, toward) -> Point:
 
     foot_point = m - d * g[:2]
     half_chord = np.sqrt(max(r**2 - d**2, 0))
-    direction = np.array([-g[1], g[0]])  # unit vector along the line
+    direction = np.array([-g[1], g[0]])
 
     candidates = [foot_point + half_chord * direction, foot_point - half_chord * direction]
     toward = np.asarray(toward, dtype=float)
@@ -191,7 +179,7 @@ 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 (Matlab ``spgkk``).
+    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
@@ -214,7 +202,7 @@ def fillet_line_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 (Matlab ``kreis_kon``).
+    always sweeping the smaller angle.
 
     :return: array of shape (count, 2) including start and end point
     """

{pyroll_core-3.2.0b1 → pyroll_core-3.2.0b2}/pyroll/core/grooves/angles/_path.py

@@ -1,26 +1,3 @@
-"""
-Common contour construction method for the angle groove family.
-
-All groove designs of the Matlab suite (``winkelkaliber_matlab``) and of the Startschenko
-angle profile method (``Winkelprofile_CR/calculations.py``) construct their contours the
-same way: as a chain of straight segments and circular arcs, where the arcs are either
-
-- *fillets* tangent to their two neighboring carriers (Matlab ``spgkg``/``spgkk``), or
-- *carrier arcs* on explicitly placed circles (ground arcs, Startschenko ``Rf``/``Rt``/``Ri``).
-
-This module provides that method as two layers:
-
-- :py:func:`chain_contour` — low level: assemble a point array from explicit
-  line/arc steps (mirrors the Matlab ``gerade_kon``/``kreis_kon`` assembly and the
-  piecewise contour functions of the Startschenko method), and
-- :py:func:`build_filleted_contour` — high level: declare carriers (lines and circles)
-  with a transition radius at each junction; tangent points are resolved automatically.
-
-Carriers are the primitives of :py:mod:`._geometry`: lines as homogeneous coordinate
-``numpy`` arrays, circles as ``(center_z, center_y, radius)`` tuples. The distinction is
-made by type: ``numpy.ndarray`` → line, ``tuple`` → circle.
-"""
-
 from typing import Sequence, Union
 
 import numpy as np
@@ -77,14 +54,12 @@ def _nominal_vertex(c1: Carrier, c2: Carrier, toward) -> np.ndarray:
         try:
             return geo.line_circle_intersection(line, circle, toward)
         except ValueError:
-            # separated: nominal junction between the closest points
             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
 
-    # circle-circle: tangency point on the center line
     m1 = np.array([c1[0], c1[1]])
     m2 = np.array([c2[0], c2[1]])
     direction = m2 - m1
@@ -178,20 +153,16 @@ def build_filleted_contour(start, path: Sequence, end, hints: dict = None) -> np
     start = np.asarray(start, dtype=float)
     end = np.asarray(end, dtype=float)
 
-    # nominal junction vertices, resolved sequentially from the start
     vertices = []
     ref = start
     for c1, c2 in zip(carriers[:-1], carriers[1:]):
         if not _is_line(c1):
-            # the contour left the circle carrier on the far side of where it entered:
-            # take the entry's antipode as the proximity hint
             ref = 2 * np.array([c1[0], c1[1]]) - ref
         ref = _nominal_vertex(c1, c2, ref)
         vertices.append(ref)
 
     ref_points = [start, *vertices, end]
 
-    # resolve each junction to (entry point, arc steps, exit point)
     steps = []
     for i, radius in enumerate(radii):
         c1, c2 = carriers[i], carriers[i + 1]
@@ -225,7 +196,6 @@ def build_filleted_contour(start, path: Sequence, end, hints: dict = None) -> np
         approach = [("line", t1)] if _is_line(c1) else [("arc", (c1[0], c1[1]), t1)]
         steps.append((approach + [("arc", center, t2)], t2))
 
-    # final leg on the last carrier
     last = carriers[-1]
     final_step = ("line", end) if _is_line(last) else ("arc", (last[0], last[1]), end)