pyroll-core 3.0.2.post2__tar.gz → 3.0.3__tar.gz

{pyroll_core-3.0.2.post2 → pyroll_core-3.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyroll-core
-Version: 3.0.2.post2
+Version: 3.0.3
 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.0.2.post2 → pyroll_core-3.0.3}/pyroll/core/__init__.py

@@ -44,7 +44,7 @@ from .hooks import Hook, HookHost, HookFunction, root_hooks
 from .disk_elements import DiskElementUnit
 from .config import Config, config, PlottingBackend, ConfigValue, ConfigMeta
 
-VERSION = "3.0.2.post2"
+VERSION = "3.0.3"
 
 __all__ = [
     # grooves
@@ -132,5 +132,7 @@ root_hooks.extend(
         PassSequence.log_elongation,
         BaseRollPass.OutProfile.technologically_orientated_cross_section,
         BaseRollPass.technologically_orientated_contour_lines,
+        # BaseRollPass.back_tension,
+        # BaseRollPass.front_tension
     ]
 )

{pyroll_core-3.0.2.post2 → pyroll_core-3.0.3}/pyroll/core/profile/profile.py

@@ -191,13 +191,13 @@ class Profile(HookHost):
 
     @classmethod
     def from_groove(
-        cls,
-        groove: GrooveBase,
-        width: Optional[float] = None,
-        filling: Optional[float] = None,
-        height: Optional[float] = None,
-        gap: Optional[float] = None,
-        **kwargs,
+            cls,
+            groove: GrooveBase,
+            width: Optional[float] = None,
+            filling: Optional[float] = None,
+            height: Optional[float] = None,
+            gap: Optional[float] = None,
+            **kwargs,
     ) -> "Profile":
         """
         Create a profile instance based on a given groove.
@@ -242,8 +242,8 @@ class Profile(HookHost):
         poly = Polygon(np.concatenate([upper_contour_line.coords, lower_contour_line.coords]))
 
         if (
-            # one percent tolerance to bypass discretization issues
-            -width / 2 < poly.bounds[0] * 1.01 or width / 2 > poly.bounds[2] * 1.01
+                # one percent tolerance to bypass discretization issues
+                -width / 2 < poly.bounds[0] * 1.01 or width / 2 > poly.bounds[2] * 1.01
         ):
             raise ValueError(
                 "Profile's width can not be larger than its contour lines." "May be caused by critical overfilling."
@@ -294,7 +294,7 @@ class Profile(HookHost):
 
     @classmethod
     def square(
-        cls, side: Optional[float] = None, diagonal: Optional[float] = None, corner_radius: float = 0, **kwargs
+            cls, side: Optional[float] = None, diagonal: Optional[float] = None, corner_radius: float = 0, **kwargs
     ) -> "SquareProfile":
         """
         Creates a square shaped profile (a real square with rounded corners, without imperfections of square grooves).
@@ -347,12 +347,12 @@ class Profile(HookHost):
 
     @classmethod
     def hexagon(
-        cls,
-        side: Optional[float] = None,
-        height: Optional[float] = None,
-        diagonal: Optional[float] = None,
-        corner_radius: float = 0,
-        **kwargs,
+            cls,
+            side: Optional[float] = None,
+            height: Optional[float] = None,
+            diagonal: Optional[float] = None,
+            corner_radius: float = 0,
+            **kwargs,
     ) -> "HexagonProfile":
         """
         Creates a hexagonal shaped profile (a real hexagonal shape with rounded corners,
@@ -567,7 +567,7 @@ class DiamondProfile(Profile):
 
 class SquareProfile(Profile):
     def __init__(
-        self, side: Optional[float] = None, diagonal: Optional[float] = None, corner_radius: float = 0, **kwargs
+            self, side: Optional[float] = None, diagonal: Optional[float] = None, corner_radius: float = 0, **kwargs
     ):
         """
         Creates a square shaped profile (a real square with rounded corners, without imperfections of square grooves).
@@ -626,12 +626,12 @@ class SquareProfile(Profile):
 
 class HexagonProfile(Profile):
     def __init__(
-        self,
-        side: Optional[float] = None,
-        height: Optional[float] = None,
-        diagonal: Optional[float] = None,
-        corner_radius: float = 0,
-        **kwargs,
+            self,
+            side: Optional[float] = None,
+            height: Optional[float] = None,
+            diagonal: Optional[float] = None,
+            corner_radius: float = 0,
+            **kwargs,
     ):
         """
         Creates a hexagonal shaped profile (a real hexagonal shape with rounded corners,
@@ -680,7 +680,7 @@ class HexagonProfile(Profile):
             * (side, side)
         )
         polygon = Polygon(line)
-        polygon = polygon.buffer(corner_radius)
+        polygon = polygon.buffer(-corner_radius).buffer(2 * corner_radius).buffer(-corner_radius)
 
         super().__init__(cross_section=refine_cross_section(polygon), classifiers={"hexagon"}, **kwargs)
 

{pyroll_core-3.0.2.post2 → pyroll_core-3.0.3}/pyroll/core/sequence/sequence.py

@@ -1,3 +1,5 @@
+import copy
+
 import numpy as np
 
 from collections.abc import Sequence
@@ -144,6 +146,8 @@ class PassSequence(Unit, Sequence[Unit]):
         :param final_cross_section_area: area of the final cross-section
         """
 
+        copied_sequence = copy.deepcopy(self)
+
         def calculate_velocities_array(velocities: np.ndarray[float], cross_sections_areas: np.ndarray[float]):
             for i in range(len(cross_sections_areas) - 2, -1, -1):
                 velocities[i] = velocities[i + 1] * cross_sections_areas[i + 1] / cross_sections_areas[i]
@@ -152,30 +156,32 @@ class PassSequence(Unit, Sequence[Unit]):
             for roll_pass, velocity in zip(roll_passes, velocities):
                 roll_pass.velocity = velocity
 
-        usable_cross_section_areas = np.asarray([roll_pass.usable_cross_section.area for roll_pass in self.roll_passes])
-        initial_velocities = np.zeros_like(usable_cross_section_areas, dtype=float)
+        usable_cross_section_areas = np.asarray([roll_pass.usable_cross_section.area for roll_pass in copied_sequence.roll_passes])
+        initial_roll_pass_velocities = np.zeros_like(usable_cross_section_areas, dtype=float)
 
-        initial_velocities[-1] = final_speed
+        initial_roll_pass_velocities[-1] = final_speed
         usable_cross_section_areas[-1] = final_cross_section_area
 
-        calculate_velocities_array(velocities=initial_velocities, cross_sections_areas=usable_cross_section_areas)
-        set_velocities_to_roll_passes(roll_passes=self.roll_passes, velocities=initial_velocities)
+        calculate_velocities_array(velocities=initial_roll_pass_velocities, cross_sections_areas=usable_cross_section_areas)
+        set_velocities_to_roll_passes(roll_passes=copied_sequence.roll_passes, velocities=initial_roll_pass_velocities)
 
-        self.solve(in_profile)
+        copied_sequence.solve(in_profile)
 
         for i in range(self.max_iteration_count):
-            prior_velocities = np.asarray([roll_pass.velocity for roll_pass in self.roll_passes])
-            current_velocities = prior_velocities.copy()
-            profile_areas = [roll_pass.out_profile.cross_section.area for roll_pass in self.roll_passes]
+            prior_roll_pass_velocities = np.asarray([roll_pass.velocity for roll_pass in copied_sequence.roll_passes])
+            current_roll_pass_velocities = prior_roll_pass_velocities.copy()
+            profile_areas = [roll_pass.out_profile.cross_section.area for roll_pass in copied_sequence.roll_passes]
 
-            calculate_velocities_array(velocities=current_velocities, cross_sections_areas=profile_areas)
-            set_velocities_to_roll_passes(roll_passes=self.roll_passes, velocities=current_velocities)
+            calculate_velocities_array(velocities=current_roll_pass_velocities, cross_sections_areas=profile_areas)
+            set_velocities_to_roll_passes(roll_passes=copied_sequence.roll_passes, velocities=current_roll_pass_velocities)
 
-            self.solve(in_profile)
+            copied_sequence.solve(in_profile)
 
-            difference = np.abs(prior_velocities - current_velocities)
+            difference = np.abs(prior_roll_pass_velocities - current_roll_pass_velocities)
 
             if np.all(difference < 0.01):
+                set_velocities_to_roll_passes(roll_passes=self.roll_passes, velocities=current_roll_pass_velocities)
+                self.solve(in_profile)
                 break
 
     def solve_velocities_forward(self, in_profile: Profile, initial_speed: float):
@@ -187,6 +193,8 @@ class PassSequence(Unit, Sequence[Unit]):
         :param final_cross_section_area: area of the final cross-section
         """
 
+        copied_sequence = copy.deepcopy(self)
+
         def calculate_velocities_array(velocities: np.ndarray[float], cross_sections_areas: np.ndarray[float]):
             for i in range(1, len(usable_cross_section_areas)):
                 velocities[i] = velocities[i - 1] * cross_sections_areas[i - 1] / cross_sections_areas[i]
@@ -195,28 +203,73 @@ class PassSequence(Unit, Sequence[Unit]):
             for roll_pass, velocity in zip(roll_passes, velocities):
                 roll_pass.velocity = velocity
 
-        usable_cross_section_areas = np.asarray([roll_pass.usable_cross_section.area for roll_pass in self.roll_passes])
-        initial_velocities = np.zeros_like(usable_cross_section_areas, dtype=float)
+        usable_cross_section_areas = np.asarray([roll_pass.usable_cross_section.area for roll_pass in copied_sequence.roll_passes])
+        initial_roll_pass_velocities = np.zeros_like(usable_cross_section_areas, dtype=float)
 
-        initial_velocities[0] = initial_speed * in_profile.cross_section.area / self.roll_passes[
-            0].usable_cross_section.area
+        initial_roll_pass_velocities[0] = initial_speed * in_profile.cross_section.area / copied_sequence.roll_passes[0].usable_cross_section.area
 
-        calculate_velocities_array(velocities=initial_velocities, cross_sections_areas=usable_cross_section_areas)
-        set_velocities_to_roll_passes(roll_passes=self.roll_passes, velocities=initial_velocities)
+        calculate_velocities_array(velocities=initial_roll_pass_velocities, cross_sections_areas=usable_cross_section_areas)
+        set_velocities_to_roll_passes(roll_passes=copied_sequence.roll_passes, velocities=initial_roll_pass_velocities)
 
-        self.solve(in_profile)
+        copied_sequence.solve(in_profile)
 
         for i in range(self.max_iteration_count):
-            prior_velocities = np.asarray([roll_pass.velocity for roll_pass in self.roll_passes])
-            current_velocities = prior_velocities.copy()
-            profile_areas = [roll_pass.out_profile.cross_section.area for roll_pass in self.roll_passes]
+            prior_velocities = np.asarray([roll_pass.velocity for roll_pass in copied_sequence.roll_passes])
+            profile_areas = [roll_pass.out_profile.cross_section.area for roll_pass in copied_sequence.roll_passes]
+            roll_pass_velocities = np.zeros_like(usable_cross_section_areas, dtype=float)
+            roll_pass_velocities[0] = initial_speed * in_profile.cross_section.area / profile_areas[0]
 
-            calculate_velocities_array(velocities=current_velocities, cross_sections_areas=profile_areas)
-            set_velocities_to_roll_passes(roll_passes=self.roll_passes, velocities=current_velocities)
+            calculate_velocities_array(velocities=roll_pass_velocities, cross_sections_areas=profile_areas)
+            set_velocities_to_roll_passes(roll_passes=copied_sequence.roll_passes, velocities=roll_pass_velocities)
 
-            self.solve(in_profile)
+            copied_sequence.solve(in_profile)
 
-            difference = np.abs(prior_velocities - current_velocities)
+            difference = np.abs(prior_velocities - roll_pass_velocities)
 
             if np.all(difference < 0.01):
+                set_velocities_to_roll_passes(roll_passes=self.roll_passes, velocities=roll_pass_velocities)
+                self.solve(in_profile)
                 break
+
+    def solve_interstand_tensions_with_given_velocity_ratios(self, in_profile: Profile,
+                                                             velocity_ratios: np.ndarray[float], final_speed: float):
+        """
+        Solve method, that calculates the resulting tensions for given reductions.
+        Further, it sets the velocities according to these reductions and the finishing speed.
+
+        :param in_profile: incoming profile
+        :param velocity_ratios: velocity_ratio per stand.
+        :param final_speed: speed of the last stand
+        """
+
+        roll_pass_velocities = [final_speed]
+        for ratio in reversed(velocity_ratios):
+            previous_roll_pass_velocity = roll_pass_velocities[0] / ratio
+            roll_pass_velocities.insert(0, previous_roll_pass_velocity)
+
+        roll_pass_velocities = np.array(roll_pass_velocities)
+        for i, roll_pass in enumerate(self.roll_passes):
+            roll_pass.velocity = roll_pass_velocities[i]
+
+        copied_sequence = copy.deepcopy(self)
+        copied_sequence.solve(in_profile)
+
+        tensions = np.zeros(len(copied_sequence.roll_passes) * 2)
+        engineering_strains = (roll_pass_velocities[1:] - roll_pass_velocities[:-1]) / roll_pass_velocities[:-1]
+
+        for index in range(1, len(self.roll_passes)):
+            engineering_strain = engineering_strains[index - 1]
+
+            tensions[2 * index - 1] = copied_sequence.roll_passes[
+                                          index - 1].in_profile.elastic_modulus * engineering_strain
+            tensions[2 * index] -= copied_sequence.roll_passes[
+                                       index - 1].out_profile.elastic_modulus * engineering_strain
+
+        tensions[0] = 0
+        tensions[-1] = 0
+
+        for index, roll_pass in enumerate(copied_sequence.roll_passes):
+            roll_pass.back_tension = tensions[2 * index]
+            roll_pass.front_tension = tensions[2 * index + 1]
+
+        self.solve(in_profile=in_profile)