pyroll-core 3.1.0__tar.gz → 3.1.2__tar.gz

{pyroll_core-3.1.0 → pyroll_core-3.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyroll-core
-Version: 3.1.0
+Version: 3.1.2
 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.0 → pyroll_core-3.1.2}/pyroll/core/__init__.py

@@ -45,7 +45,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.0"
+VERSION = "3.1.2"
 
 __all__ = [
     # grooves
@@ -134,6 +134,6 @@ root_hooks.extend(
         BaseRollPass.InProfile.velocity,
         PassSequence.log_elongation,
         BaseRollPass.OutProfile.technologically_orientated_cross_section,
-        BaseRollPass.technologically_orientated_contour_lines
+        BaseRollPass.technologically_orientated_contour_lines,
     ]
 )

{pyroll_core-3.1.0 → pyroll_core-3.1.2}/pyroll/core/disk_elements/hookimpls.py

@@ -24,3 +24,11 @@ def in_x(self: DiskElementUnit.DiskElement.InProfile):
     except IndexError:
         # is first disk: get from parent in_profile
         return self.disk_element.parent.in_profile.x
+
+
+@DiskElementUnit.DiskElement.InProfile.position
+def in_position(self: DiskElementUnit.DiskElement.InProfile):
+    try:
+        return self.disk_element.prev.out_profile.position
+    except IndexError:
+        return self.disk_element.parent.in_profile.position

{pyroll_core-3.1.0 → pyroll_core-3.1.2}/pyroll/core/engine/engine.py

@@ -10,9 +10,18 @@ __all__ = ["Engine"]
 class Engine(HookHost):
     """Represents an engine of a roll pass."""
 
+    label = Hook[str]()
+    """Type of the engine (DC or AC)"""
+
     rotational_frequency = Hook[float]()
     """Rotational frequency (revolutions per time)."""
 
+    base_rotational_frequency = Hook[float]()
+    """Knee point were a DC engine switches from anchor range to field weakening range."""
+
+    maximum_rotational_frequency = Hook[float]()
+    """Maximum rotational frequency of the engine."""
+
     torque = Hook[float]()
     """Engine torque."""
 
@@ -34,11 +43,11 @@ class Engine(HookHost):
     maximum_power = Hook[float]()
     """Maximum power of the engine."""
 
-    maximum_rotational_frequency = Hook[float]()
-    """Maximum rotational frequency of the engine."""
+    available_power = Hook[float]()
+    """Available power of the engine only relevant for DC engines."""
 
-    base_speed = Hook[float]()
-    """Knee point were a DC engine switches from anchor range to field weakening range."""
+    mean_power = Hook[float]()
+    """Mean power of the engine incorporating roll pass and transport durations."""
 
 
     def __init__(self, **kwargs):

pyroll_core-3.1.2/pyroll/core/engine/hookimpls.py

@@ -0,0 +1,29 @@
+import numpy as np
+
+from .engine import Engine
+from ..transport import Transport
+
+@Engine.gear_box_efficiency
+def gear_box_efficiency_becker(self: Engine):
+    return 0.95
+
+@Engine.spindle_efficiency
+def spindle_efficiency_becker(self: Engine):
+    return 0.98
+
+@Engine.idle_torque
+def default_idle_torque(self: Engine):
+    return 0
+
+@Engine.power
+def roll_power(self: Engine):
+    return self.torque * self.rotational_frequency * 2 * np.pi
+
+@Engine.mean_power
+def mean_power(self: Engine):
+    try:
+        next_transport = self.roll_pass.next_of(Transport)
+    except (IndexError, ValueError):
+        return np.sqrt(self.torque ** 2 * self.roll_pass.duration / self.roll_pass.duration)
+
+    return np.sqrt(self.torque ** 2 * self.roll_pass.duration / (next_transport.duration + self.roll_pass.duration))

{pyroll_core-3.1.0 → pyroll_core-3.1.2}/pyroll/core/grooves/generic_elongation.py

@@ -31,6 +31,7 @@ class GenericElongationGroove(GrooveBase, ReprMixin):
             rel_pad: float = Config.GROOVE_PADDING,
             pad_angle: float = 0,
             classifiers: Sequence[str] = (),
+            label: str = ""
     ):
         """
         Give any three of ``usable_width``, ``ground_width``, ``flank_angle`` and ``depth``.
@@ -99,6 +100,7 @@ class GenericElongationGroove(GrooveBase, ReprMixin):
         except TypeError:
             raise TypeError("Exactly three of usable_width, ground_width, flank_angle and depth must be given.")
 
+        self.label = label
         self.r1 = r1
         self.r2 = r2
         self.r3 = r3

{pyroll_core-3.1.0 → pyroll_core-3.1.2}/pyroll/core/grooves/ovals/constricted_swedish_oval.py

@@ -62,4 +62,4 @@ class ConstrictedSwedishOvalGroove(GenericElongationGroove):
 
     @property
     def classifiers(self):
-        return {"oval", "swedish_oval", "constricted_swedish_oval"} | super().classifiers
+        return {"oval", "swedish_oval", "constricted"} | super().classifiers

{pyroll_core-3.1.0 → pyroll_core-3.1.2}/pyroll/core/profile/profile.py

@@ -32,11 +32,17 @@ class Profile(HookHost):
     classifiers = Hook[Set[str]]()
     """Classifiers of the profile's shape's type."""
 
+    position = Hook[float]()
+    """Global spacial coordinate in rolling direction."""
+
+    time = Hook[float]()
+    """Global time in rolling direction."""
+
     x = Hook[float]()
-    """Spacial coordinate in rolling direction."""
+    """Local spacial coordinate in rolling direction."""
 
     t = Hook[float]()
-    """Temporal coordinate."""
+    """Local temporal coordinate."""
 
     velocity = Hook[float]()
     """Mean material flow velocity."""
@@ -191,13 +197,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 +248,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 +300,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 +353,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 +573,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 +632,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,

{pyroll_core-3.1.0 → pyroll_core-3.1.2}/pyroll/core/roll_pass/hookimpls/base_roll_pass.py

@@ -135,6 +135,10 @@ def default_back_tension(self: BaseRollPass):
 def technologically_correctly_orientated_contour_lines(self: BaseRollPass):
     return MultiLineString([self._get_oriented_geom(cl) for cl in self.contour_lines.geoms])
 
+@BaseRollPass.InProfile.technologically_orientated_cross_section
+def technologically_correctly_orientated_cross_section(self: BaseRollPass.InProfile):
+    return self.roll_pass._get_oriented_geom(self.cross_section, orientation=self.roll_pass.orientation)
+
 
 @BaseRollPass.OutProfile.technologically_orientated_cross_section
 def technologically_correctly_orientated_cross_section(self: BaseRollPass.OutProfile):

{pyroll_core-3.1.0 → pyroll_core-3.1.2}/pyroll/core/roll_pass/hookimpls/engine.py

@@ -19,3 +19,10 @@ def engine_rotational_frequency(self: BaseRollPass.Engine):
         return self.roll_pass.roll.rotational_frequency * self.gear_ratio
     else:
         return self.roll_pass.roll.rotational_frequency
+
+@BaseRollPass.Engine.available_power
+def available_power(self: BaseRollPass.Engine):
+    if self.has_set_or_cached("base_rotational_frequency"):
+        return self.maximum_power * (self.rotational_frequency / self.base_rotational_frequency)
+    else:
+        return self.maximum_power

{pyroll_core-3.1.0 → pyroll_core-3.1.2}/pyroll/core/roll_pass/hookimpls/profile.py

@@ -75,6 +75,10 @@ def cross_section(self: BaseRollPass.OutProfile) -> Polygon:
         if width_at_y0 < in_profile_width:
             in_profile_width = width_at_y0
 
+    if "constricted" in self.roll_pass.classifiers:
+        cs = helpers.out_cross_section(self.roll_pass, self.width)
+        return cs
+
     half_abs_spread = (self.width - in_profile_width) / 2
     half_in_profile = clip_by_rect(self.roll_pass.in_profile.cross_section, 0, -np.inf, np.inf, np.inf)
     out_profile_side_contour_translated = translate(half_in_profile, xoff=half_abs_spread)

{pyroll_core-3.1.0 → pyroll_core-3.1.2}/pyroll/core/sequence/sequence.py

@@ -4,7 +4,9 @@ import numpy as np
 
 from collections.abc import Sequence
 from typing import overload, List, cast
+from scipy.interpolate import interp1d
 
+from .. import CoolingPipe
 from ..unit import Unit
 from ..roll_pass import BaseRollPass
 from ..transport import Transport
@@ -130,6 +132,11 @@ class PassSequence(Unit, Sequence[Unit]):
         """Returns a list of all transports in this sequence."""
         return list(u for u in self._subunits if isinstance(u, Transport))
 
+    @property
+    def cooling_pipes(self) -> List[CoolingPipe]:
+        """Returns a list of all cooling pipes in this sequence."""
+        return list(u for u in self._subunits if isinstance(u, CoolingPipe))
+
     @property
     def __attrs__(self):
         return super().__attrs__ | {"units": self.units}
@@ -137,6 +144,32 @@ class PassSequence(Unit, Sequence[Unit]):
     def _ipython_key_completions_(self):
         return [u.label for u in self._subunits]
 
+    def solve_velocities_from_elongations(self, in_profile: Profile, final_speed: float, elongations: np.ndarray):
+        """
+        Solve method, that calculates all velocities of the roll pass starting from the very last roll_pass of the sequence using given elongations.
+
+        :param in_profile: incoming profile
+        :param final_speed: speed of the last stand
+        :param elongations: array of the elongations per pass, starting from the first roll pass
+        """
+
+        if len(elongations) != len(self.roll_passes) - 1:
+            raise ValueError("Number of Elongations doesn't match the number of roll passes.")
+
+        speed = final_speed
+        speeds = [final_speed]
+
+        for e in elongations:
+            speed = speed / e
+            speeds.append(speed)
+
+        speeds = np.array(speeds)
+
+        for rp, speed in zip(self.roll_passes, speeds[::-1]):
+            rp.velocity = speed
+
+        self.solve(in_profile)
+
     def solve_velocities_backward(self, in_profile: Profile, final_speed: float, final_cross_section_area: float):
         """
         Solve method, that calculates all velocities of the roll pass starting from the very last roll_pass of the sequence.
@@ -156,13 +189,17 @@ 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 copied_sequence.roll_passes])
+        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_roll_pass_velocities[-1] = final_speed
         usable_cross_section_areas[-1] = final_cross_section_area
 
-        calculate_velocities_array(velocities=initial_roll_pass_velocities, cross_sections_areas=usable_cross_section_areas)
+        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)
 
         copied_sequence.solve(in_profile)
@@ -173,7 +210,9 @@ class PassSequence(Unit, Sequence[Unit]):
             profile_areas = [roll_pass.out_profile.cross_section.area for roll_pass in copied_sequence.roll_passes]
 
             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)
+            set_velocities_to_roll_passes(
+                roll_passes=copied_sequence.roll_passes, velocities=current_roll_pass_velocities
+            )
 
             copied_sequence.solve(in_profile)
 
@@ -203,12 +242,18 @@ 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 copied_sequence.roll_passes])
+        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_roll_pass_velocities[0] = initial_speed * in_profile.cross_section.area / copied_sequence.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_roll_pass_velocities, cross_sections_areas=usable_cross_section_areas)
+        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)
 
         copied_sequence.solve(in_profile)
@@ -231,8 +276,9 @@ class PassSequence(Unit, Sequence[Unit]):
                 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):
+    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.
@@ -260,10 +306,12 @@ class PassSequence(Unit, Sequence[Unit]):
         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[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
@@ -273,3 +321,51 @@ class PassSequence(Unit, Sequence[Unit]):
             roll_pass.front_tension = tensions[2 * index + 1]
 
         self.solve(in_profile=in_profile)
+
+    def find_value_by_position_or_time(self, hook_name: str, position: float = None, time: float = None):
+        if position is None:
+            search_coordinate = "t"
+        else:
+            search_coordinate = "position"
+
+        coordinates = []
+        values = []
+
+        for su in self.subunits:
+            if len(su.subunits) > 0:
+                for ssu in su.subunits:
+                    coordinates.append(getattr(ssu.in_profile, search_coordinate, None))
+                    values.append(getattr(ssu.in_profile, hook_name, None))
+
+                    coordinates.append(getattr(ssu.out_profile, search_coordinate, None))
+                    values.append(getattr(ssu.out_profile, hook_name, None))
+            else:
+                coordinates.append(getattr(su.in_profile, search_coordinate, None))
+                values.append(getattr(su.in_profile, hook_name, None))
+
+                coordinates.append(getattr(su.out_profile, search_coordinate, None))
+                values.append(getattr(su.out_profile, hook_name, None))
+
+        if all(v is None for v in values):
+            raise ValueError(f"No hook with name {hook_name} found.")
+
+        closest_pos = min(coordinates, key=lambda p: abs(p - position))
+        closest_index = coordinates.index(closest_pos)
+
+        postion_array = np.array(coordinates)
+        values_array = np.array(values)
+
+        next_element = 1
+        while True:
+            if (closest_index + next_element) >= len(coordinates):
+                raise ValueError(f"Coordinate index {closest_index + next_element} out of sequence range.")
+
+            if coordinates[closest_index + next_element] >= position:
+                break
+            next_element += 1
+
+        val = values_array[closest_index : closest_index + next_element + 1]
+        pos = postion_array[closest_index : closest_index + next_element + 1]
+        interpolation = interp1d(pos, val)
+
+        return interpolation(position)

{pyroll_core-3.1.0 → pyroll_core-3.1.2}/pyroll/core/unit/hookimpls.py

@@ -56,6 +56,11 @@ def out_velocity(self: Unit.OutProfile):
         return self.unit.in_profile.velocity * self.unit.in_profile.cross_section.area / self.cross_section.area
 
 
+@Unit.OutProfile.position
+def out_position(self: Unit.OutProfile):
+    return self.unit.in_profile.position + self.unit.length
+
+
 @Unit.OutProfile.x
 def out_x(self: Unit.OutProfile):
     return self.unit.in_profile.x + self.unit.length

pyroll_core-3.1.0/pyroll/core/engine/hookimpls.py

@@ -1,19 +0,0 @@
-import numpy as np
-
-from .engine import Engine
-
-@Engine.gear_box_efficiency
-def gear_box_efficiency_becker(self: Engine):
-    return 0.95
-
-@Engine.spindle_efficiency
-def spindle_efficiency_becker(self: Engine):
-    return 0.98
-
-@Engine.idle_torque
-def default_idle_torque(self: Engine):
-    return 0
-
-@Engine.power
-def roll_power(self: Engine):
-    return self.torque * self.rotational_frequency * 2 * np.pi