impl pass line finding for asym RPs

Author: axtimhaus

pyroll/core/__init__.py

@@ -2,7 +2,7 @@
 
 from .grooves import *
 from .transport import Transport, CoolingPipe
-from .roll_pass import BaseRollPass, RollPass, DeformationUnit, ThreeRollPass, AsymmetricRollPass
+from .roll_pass import BaseRollPass, RollPass, DeformationUnit, ThreeRollPass, AsymmetricTwoRollPass
 from .unit import Unit
 from .roll import Roll
 from .profile import *
@@ -16,6 +16,8 @@
 
 root_hooks.extend(
     [
+        AsymmetricTwoRollPass.InProfile.pass_line,
+        AsymmetricTwoRollPass.InProfile.cross_section,
         BaseRollPass.roll_force,
         BaseRollPass.Roll.roll_torque,
         BaseRollPass.elongation_efficiency,

pyroll/core/roll/hookimpls.py

@@ -51,7 +51,7 @@ def contour_points(self: Roll):
 
 @Roll.surface_x
 def surface_x(self: Roll):
-    padded_contact_angle = np.arcsin(1.1 * self.contact_length / self.min_radius)
+    padded_contact_angle = np.arcsin(1.1 * self.contact_length / self.min_radius) if self.has_set_or_cached("contact_length") else np.pi / 4
     points = np.concatenate([
         np.linspace(0, padded_contact_angle, Config.ROLL_SURFACE_DISCRETIZATION_COUNT, endpoint=False),
         np.linspace(padded_contact_angle, np.pi / 2, Config.ROLL_SURFACE_DISCRETIZATION_COUNT),

pyroll/core/roll_pass/asymmetric_two_roll_pass.py

@@ -1,5 +1,6 @@
 from typing import List, cast
 
+import numpy as np
 from shapely.affinity import translate, scale
 from shapely.geometry import LineString
 
@@ -33,7 +34,7 @@ def contour_lines(self) -> List[LineString]:
 
         upper = translate(self.upper_roll.contour_line, yoff=self.gap / 2)
         lower = scale(
-            translate(self.lower_roll.contour_line, yoff=self.gap / 2),
+            translate(self.lower_roll.contour_line.reverse(), yoff=self.gap / 2),
             xfact=1, yfact=-1, origin=(0, 0)
         )
 
@@ -51,6 +52,18 @@ def disk_elements(self) -> List['AsymmetricTwoRollPass.DiskElement']:
         """A list of disk elements used to subdivide this unit."""
         return list(self._subunits)
 
+    def get_root_hook_results(self):
+        super_results = super().get_root_hook_results()
+        upper_roll_results = self.upper_roll.evaluate_and_set_hooks()
+        lower_roll_results = self.lower_roll.evaluate_and_set_hooks()
+        return np.concatenate([super_results, upper_roll_results, lower_roll_results], axis=0)
+
+    def reevaluate_cache(self):
+        super().reevaluate_cache()
+        self.upper_roll.reevaluate_cache()
+        self.lower_roll.reevaluate_cache()
+        self._contour_lines = None
+
     class Profile(BaseRollPass.Profile):
         """Represents a profile in context of a roll pass."""
 
@@ -62,7 +75,8 @@ def roll_pass(self) -> 'AsymmetricTwoRollPass':
     class InProfile(Profile, BaseRollPass.InProfile):
         """Represents an incoming profile of a roll pass."""
 
-        vertical_displacement = Hook[float]
+        pass_line = Hook[tuple[float, float, float]]()
+        """Point (x, y, z) where the incoming profile centroid enters the roll pass."""
 
     class OutProfile(Profile, BaseRollPass.OutProfile):
         """Represents an outgoing profile of a roll pass."""

pyroll/core/roll_pass/base.py

@@ -109,6 +109,12 @@ def __init__(
 
         self._contour_lines = None
 
+        self.given_in_profile: BaseProfile | None = None
+        """The incoming profile as was given to the ``solve`` method."""
+
+        self.rotated_in_profile: BaseProfile | None = None
+        """The incoming profile after rotation."""
+
     @property
     @abstractmethod
     def contour_lines(self):
@@ -128,6 +134,8 @@ def disk_elements(self) -> List['BaseRollPass.DiskElement']:
         return list(self._subunits)
 
     def init_solve(self, in_profile: BaseProfile):
+        self.given_in_profile = in_profile
+
         if self.rotation:
             rotator = Rotator(
                 # make True determining from hook functions
@@ -136,14 +144,15 @@ def init_solve(self, in_profile: BaseProfile):
                 duration=0, length=0, parent=self
             )
             rotator.solve(in_profile)
-            in_profile = rotator.out_profile
+            self.rotated_in_profile = rotator.out_profile
+        else:
+            self.rotated_in_profile = in_profile
 
-        super().init_solve(in_profile)
+        super().init_solve(self.rotated_in_profile)
         self.out_profile.cross_section = self.usable_cross_section
 
     def reevaluate_cache(self):
         super().reevaluate_cache()
-        self.roll.reevaluate_cache()
         self._contour_lines = None
 
     class Profile(DiskElementUnit.Profile, DeformationUnit.Profile):

pyroll/core/roll_pass/hookimpls/__init__.py

@@ -1,5 +1,6 @@
 from . import base_roll_pass
 from . import two_roll_pass
+from . import asymmetric_two_roll_pass
 from . import three_roll_pass
 from . import profile
 from . import roll

pyroll/core/roll_pass/hookimpls/asymmetric_two_roll_pass.py

@@ -1,4 +1,6 @@
 import numpy as np
+import scipy.optimize
+import shapely.affinity
 from shapely import Polygon
 
 from . import helpers
@@ -61,37 +63,6 @@ def roll_power(self: AsymmetricTwoRollPass):
     return self.upper_roll.roll_power + self.lower_roll.roll_power
 
 
-@AsymmetricTwoRollPass.entry_point
-def entry_point(self: AsymmetricTwoRollPass):
-    height_change = self.in_profile.height - self.height
-    return (
-        np.sqrt(height_change)
-        * np.sqrt(
-            (2 * self.upper_roll.min_radius - height_change)
-            * (2 * self.lower_roll.min_radius - height_change)
-            * (2 * self.upper_roll.min_radius + 2 * self.lower_roll.min_radius - height_change)
-        )
-    ) / (2 * (self.upper_roll.min_radius + self.lower_roll.min_radius - height_change))
-
-
-@AsymmetricTwoRollPass.entry_point
-def entry_point_square_oval(self: AsymmetricTwoRollPass):
-    if "square" in self.in_profile.classifiers and "oval" in self.classifiers:
-        upper_depth = self.upper_roll.groove.local_depth(self.in_profile.width / 2)
-        lower_depth = self.lower_roll.groove.local_depth(self.in_profile.width / 2)
-        height_change = self.in_profile.height - self.gap - upper_depth - lower_depth
-        upper_radius = self.upper_roll.max_radius - upper_depth
-        lower_radius = self.lower_roll.max_radius - lower_depth
-        return (
-                np.sqrt(height_change)
-                * np.sqrt(
-            (2 * upper_radius - height_change)
-            * (2 * lower_radius - height_change)
-            * (2 * upper_radius + 2 * lower_radius - height_change)
-        )
-        ) / (2 * (upper_radius + lower_radius - height_change))
-
-
 @AsymmetricTwoRollPass.velocity
 def velocity(self: AsymmetricTwoRollPass):
     if self.upper_roll.has_value("neutral_angle") and self.lower_roll.has_value("neutral_angle"):
@@ -111,3 +82,59 @@ def roll_force(self: AsymmetricTwoRollPass):
         * (self.upper_roll.contact_area + self.lower_roll.contact_area)
         / 2
     )
+
+
+@AsymmetricTwoRollPass.InProfile.pass_line
+def pass_line(self: AsymmetricTwoRollPass.InProfile) -> tuple[float, float, float]:
+    rp = self.roll_pass
+
+    if not self.has_set("pass_line"):
+        height_change = self.height - rp.height
+        x_guess = -(
+            np.sqrt(height_change)
+            * np.sqrt(
+                (2 * rp.upper_roll.min_radius - height_change)
+                * (2 * rp.lower_roll.min_radius - height_change)
+                * (2 * rp.upper_roll.min_radius + 2 * rp.lower_roll.min_radius - height_change)
+            )
+        ) / (2 * (rp.upper_roll.min_radius + rp.lower_roll.min_radius - height_change))
+        y_guess = 0
+    else:
+        x_guess, y_guess, _ = self.pass_line
+
+    def contact_objective(xy):
+        shifted_cross_section = shapely.affinity.translate(rp.rotated_in_profile.cross_section, yoff=xy[1])
+
+        upper_contour = shapely.geometry.LineString(np.stack([
+            rp.upper_roll.surface_z,
+            rp.upper_roll.surface_interpolation(xy[0], rp.upper_roll.surface_z).squeeze(axis=1)
+        ], axis=1))
+        upper_contour = shapely.affinity.translate(upper_contour,yoff=self.roll_pass.gap / 2)
+        lower_contour = shapely.geometry.LineString(np.stack([
+            rp.lower_roll.surface_z,
+            rp.lower_roll.surface_interpolation(xy[0], rp.lower_roll.surface_z).squeeze(axis=1)
+        ], axis=1))
+        lower_contour = shapely.affinity.scale(shapely.affinity.translate(lower_contour, yoff=self.roll_pass.gap / 2), xfact=1, yfact=-1, origin=(0,0))
+
+        upper_intersection = shapely.intersection(upper_contour, shifted_cross_section)
+        lower_intersection = shapely.intersection(lower_contour, shifted_cross_section)
+
+        upper_value = upper_intersection.length if not upper_intersection.is_empty else shapely.shortest_line(upper_contour, shifted_cross_section).length
+        lower_value = lower_intersection.length if not lower_intersection.is_empty else shapely.shortest_line(lower_contour, shifted_cross_section).length
+
+        return upper_value ** 2 + lower_value ** 2
+
+    sol = scipy.optimize.minimize(contact_objective, (x_guess, y_guess), method="BFGS", options=dict(xrtol=1e-2))
+
+    return sol.x[0], sol.x[1], 0
+
+
+@AsymmetricTwoRollPass.InProfile.cross_section
+def in_cross_section(self:AsymmetricTwoRollPass.InProfile):
+    return shapely.affinity.translate(self.roll_pass.rotated_in_profile.cross_section, xoff=self.pass_line[2], yoff=self.pass_line[1])
+
+
+@AsymmetricTwoRollPass.entry_point
+def entry_point(self: AsymmetricTwoRollPass):
+    return self.in_profile.pass_line[0]
+

pyroll/core/roll_pass/hookimpls/deformation_unit.py

@@ -1,11 +1,8 @@
 import numpy as np
 
-from shapely.ops import linemerge
 from shapely.geometry import LineString
-from shapely.affinity import translate, rotate
 
 from ..deformation_unit import DeformationUnit
-from ..roll_pass import RollPass
 from ...config import Config
 
 

pyroll/core/roll_pass/hookimpls/helpers.py

@@ -1,18 +1,20 @@
 import math
 
 import numpy as np
+import shapely
 from shapely import Polygon, clip_by_rect
 from shapely.affinity import rotate
 
-from ..roll_pass import RollPass
+from ..two_roll_pass import TwoRollPass
 from ..three_roll_pass import ThreeRollPass
-from ..asymmetric_roll_pass import AsymmetricRollPass
+from ..asymmetric_two_roll_pass import AsymmetricTwoRollPass
 from ...profile.profile import refine_cross_section
 
 
-def out_cross_section(rp: RollPass | AsymmetricRollPass, width: float) -> Polygon:
+def out_cross_section(rp: TwoRollPass | AsymmetricTwoRollPass, width: float) -> Polygon:
     poly = Polygon(np.concatenate([cl.coords for cl in rp.contour_lines]))
-    return refine_cross_section(clip_by_rect(poly, -width / 2, -math.inf, width / 2, math.inf))
+    poly = clip_by_rect(poly, -width / 2, -math.inf, width / 2, math.inf)
+    return refine_cross_section(poly)
 
 
 def out_cross_section3(rp: ThreeRollPass, width: float) -> Polygon:

pyroll/core/roll_pass/hookimpls/roll.py

@@ -1,7 +1,7 @@
 import numpy as np
 
 from ..base import BaseRollPass
-from ..roll_pass import RollPass
+from ..two_roll_pass import TwoRollPass
 from ..three_roll_pass import ThreeRollPass
 
 
@@ -15,8 +15,8 @@ def contact_length(self: BaseRollPass.Roll):
     return self.roll_pass.exit_point - self.roll_pass.entry_point
 
 
-@RollPass.Roll.contact_area
-def contact_area(self: RollPass.Roll):
+@BaseRollPass.Roll.contact_area
+def contact_area(self: TwoRollPass.Roll):
     return (self.roll_pass.in_profile.width + self.roll_pass.out_profile.width) / 2 * self.contact_length
 
 

pyroll/core/roll_pass/hookimpls/symmetric_roll_pass.py

@@ -6,7 +6,7 @@
 @SymmetricRollPass.entry_point
 def entry_point(self: SymmetricRollPass):
     height_change = self.in_profile.height - self.height
-    return np.sqrt(self.roll.min_radius * height_change - height_change ** 2 / 4)
+    return -np.sqrt(self.roll.min_radius * height_change - height_change ** 2 / 4)
 
 
 @SymmetricRollPass.entry_point
@@ -15,7 +15,7 @@ def entry_point_square_oval(self: SymmetricRollPass):
         depth = self.roll.groove.local_depth(self.in_profile.width / 2)
         height_change = self.in_profile.height - self.gap - 2 * depth
         radius = self.roll.max_radius - depth
-        return np.sqrt(radius * height_change - height_change ** 2 / 4)
+        return -np.sqrt(radius * height_change - height_change ** 2 / 4)
 
 
 @SymmetricRollPass.velocity