pyroll-core 2.0.0__py3-none-any.whl

pyroll/core/rotator/hookimpls.py

@@ -0,0 +1,71 @@
+from .rotator import Rotator
+from shapely.affinity import rotate
+
+
+@Rotator.OutProfile.cross_section
+def rotated_cross_section(self: Rotator.OutProfile):
+    return rotate(self.rotator.in_profile.cross_section, angle=self.rotator.rotation, origin=(0, 0))
+
+
+@Rotator.OutProfile.classifiers
+def classifiers(self: Rotator.OutProfile):
+    r = self.rotator
+    t: set = r.in_profile.classifiers | {"rotated"}
+
+    if r.rotation == 45:
+        t.add("edged")
+
+    elif r.rotation == 90:
+        t.add("vertical")
+
+    elif r.rotation == 180:
+        t.add("mirrored")
+
+    return t
+
+
+@Rotator.rotation
+def default_90(self: Rotator):
+    return 90
+
+
+@Rotator.rotation
+def square_oval_45(self: Rotator):
+    if "square" in self.in_profile.classifiers and "oval" in self.next_roll_pass.classifiers:
+        return 45
+
+
+@Rotator.rotation
+def square_box_45(self: Rotator):
+    if "square" in self.in_profile.classifiers and "box" in self.next_roll_pass.classifiers:
+        return 45
+
+
+@Rotator.rotation
+def box_diamond_45(self: Rotator):
+    if "box" in self.in_profile.classifiers and "diamond" in self.next_roll_pass.classifiers:
+        return 45
+
+
+@Rotator.rotation
+def square_flat_45(self: Rotator):
+    if "square" in self.in_profile.classifiers and "flat" in self.next_roll_pass.classifiers:
+        return 45
+
+
+@Rotator.rotation
+def oval_flat_0(self: Rotator):
+    if "oval" in self.in_profile.classifiers and "flat" in self.next_roll_pass.classifiers:
+        return 0
+
+
+@Rotator.rotation
+def upset_in_0(self: Rotator):
+    if "upset" in self.in_profile.classifiers:
+        return 0
+
+
+@Rotator.rotation
+def three_roll_pass_180(self: Rotator):
+    if "3fold" in self.next_roll_pass.classifiers:
+        return 180

pyroll/core/rotator/rotator.py

@@ -0,0 +1,65 @@
+from typing import cast
+
+from ..hooks import Hook
+from ..unit import Unit
+
+
+class Rotator(Unit):
+    """Represents a unit rotating a profile around the rolling axis (mostly for feeding into next roll pass)."""
+
+    rotation = Hook[float]()
+    """Rotation applied to the profile in ° (degree)."""
+
+    @property
+    def prev_roll_pass(self):
+        """
+        Returns a reference to the first preceding roll pass of this unit in the sequence.
+        If the parent of this unit is a roll pass,
+        it is considered as the next roll pass, so the preceding of this is searched.
+
+        :raises ValueError: if this unit has no parent unit
+        """
+        from ..roll_pass import RollPass
+
+        if isinstance(self.parent, RollPass):
+            prev = self.parent.prev
+        else:
+            prev = self.prev
+
+        while True:
+            if isinstance(prev, RollPass):
+                return prev
+            prev = prev.prev
+
+    @property
+    def next_roll_pass(self):
+        """
+        Returns a reference to the first succeeding roll pass of this unit in the sequence.
+        If the parent of this unit is a roll pass, it is considered as the next roll pass.
+
+        :raises ValueError: if this unit has no parent unit
+        """
+        from ..roll_pass import RollPass
+
+        if isinstance(self.parent, RollPass):
+            return self.parent
+
+        next_ = self.next
+        while True:
+            if isinstance(next_, RollPass):
+                return next_
+            next_ = next_.next
+
+    class Profile(Unit.Profile):
+        """Represents a profile in context of a rotator."""
+
+        @property
+        def rotator(self) -> 'Rotator':
+            """Reference to the rotator. Alias for ``self.unit``."""
+            return cast(Rotator, self.unit)
+
+    class InProfile(Profile, Unit.InProfile):
+        """Represents an incoming profile of a rotator."""
+
+    class OutProfile(Profile, Unit.OutProfile):
+        """Represents an outgoing profile of a rotator."""

pyroll/core/sequence/__init__.py

@@ -0,0 +1,3 @@
+from .sequence import PassSequence
+
+from. import hookimpls

pyroll/core/sequence/hookimpls.py

@@ -0,0 +1,18 @@
+import numpy as np
+
+from .sequence import PassSequence
+
+
+@PassSequence.total_elongation
+def total_elongation(self: PassSequence):
+    return self.in_profile.cross_section.area / self.out_profile.cross_section.area
+
+
+@PassSequence.duration
+def duration(self: PassSequence):
+    return np.sum([u.duration for u in self.units])
+
+
+@PassSequence.length
+def length(self: PassSequence):
+    return np.sum([u.length for u in self.units])

pyroll/core/sequence/sequence.py

@@ -0,0 +1,68 @@
+from collections.abc import Sequence
+from typing import overload, List, cast
+
+from ..unit import Unit
+from ..hooks import Hook
+
+
+class PassSequence(Unit, Sequence[Unit]):
+    """
+    Represents a sequence of other units.
+    Main container for defining rolling processes.
+    Can be nested to define distinct rolling lines or similar.
+    """
+
+    total_elongation = Hook[float]()
+    """Total elongation of the workpiece within the sequence."""
+
+    def __init__(self, units: Sequence[Unit], label: str = "", **kwargs):
+        """
+        :param units: sequence of unit objects
+        :param label: label for human identification
+        :param kwargs: additional hook values as keyword arguments to set explicitly
+        """
+
+        super().__init__(label=label)
+        self.__dict__.update(kwargs)
+        self._subunits = self._SubUnitsList(self, units)
+
+    class Profile(Unit.Profile):
+        """Represents a profile in context of a pass sequence unit."""
+
+        @property
+        def pass_sequence(self) -> 'PassSequence':
+            """Reference to the pass sequence. Alias for ``self.unit``."""
+            return cast(PassSequence, self.unit)
+
+    class InProfile(Profile, Unit.InProfile):
+        """Represents an incoming profile of a pass sequence unit."""
+
+    class OutProfile(Profile, Unit.OutProfile):
+        """Represents an outgoing profile of a pass sequence unit."""
+
+    def __len__(self) -> int:
+        return self._subunits.__len__()
+
+    def __iter__(self):
+        return self._subunits.__iter__()
+
+    @overload
+    def __getitem__(self, index: int) -> Unit:
+        ...
+
+    @overload
+    def __getitem__(self, index: slice) -> list[Unit]:
+        ...
+
+    def __getitem__(self, index: int) -> Unit:
+        return self._subunits.__getitem__(index)
+
+    @property
+    def units(self) -> List[Unit]:
+        return self._subunits
+
+    @property
+    def __attrs__(self):
+        return super().__attrs__ | {
+            "units": self.units
+        }

pyroll/core/shapes.py

@@ -0,0 +1,104 @@
+import numpy as np
+
+from pyroll.core.repr import ReprMixin
+from shapely import Polygon, LineString
+
+
+# noinspection PyAbstractClass
+class PatchedPolygon(Polygon):
+    @property
+    def height(self) -> float:
+        """Computes the height of the bounding box."""
+        return self.bounds[3] - self.bounds[1]
+
+    @property
+    def width(self) -> float:
+        """Computes the width of the bounding box."""
+        return self.bounds[2] - self.bounds[0]
+
+    @property
+    def perimeter(self) -> float:
+        """Get the perimeter of the Polygon (alias of ``Polygon.length``)."""
+        return self.length
+
+    @property
+    def __attrs__(self):
+        return {
+            "width": self.width,
+            "height": self.height,
+            "perimeter": self.perimeter,
+            "area": self.area,
+        }
+
+
+Polygon.height = PatchedPolygon.height
+Polygon.width = PatchedPolygon.width
+Polygon.perimeter = PatchedPolygon.perimeter
+Polygon.__attrs__ = PatchedPolygon.__attrs__
+Polygon.__str__ = ReprMixin.__str__
+Polygon.__repr__ = ReprMixin.__repr__
+# noinspection PyProtectedMember
+Polygon._repr_html_ = ReprMixin._repr_html_
+# noinspection PyProtectedMember
+Polygon._repr_pretty_ = ReprMixin._repr_pretty_
+
+_RECTANGLE_CORNERS = np.asarray(
+    [
+        (-0.5, -0.5),
+        (0.5, -0.5),
+        (0.5, 0.5),
+        (-0.5, 0.5)
+    ]
+)
+
+
+def rectangle(width: float, height: float):
+    """
+    Creates an instance of :py:class:`Polygon` with rectangular shape from height and width aligned to the axes.
+
+    :param width: the width of the rectangle
+    :param height: the height of the rectangle
+    """
+
+    try:
+        width = float(width)
+        height = float(height)
+
+    except TypeError as e:
+        raise TypeError("width and height must be convertible to float") from e
+
+    points = _RECTANGLE_CORNERS * (width, height)
+    rect = Polygon(points)
+
+    return rect
+
+
+class PatchedLineString(LineString):
+    @property
+    def depth(self) -> float:
+        """Computes the height of the bounding box."""
+        return self.bounds[3] - self.bounds[1]
+
+    @property
+    def width(self) -> float:
+        """Computes the width of the bounding box."""
+        return self.bounds[2] - self.bounds[0]
+
+    @property
+    def __attrs__(self):
+        return {
+            "width": self.width,
+            "depth": self.depth,
+            "length": self.length,
+        }
+
+
+LineString.depth = PatchedLineString.depth
+LineString.width = PatchedLineString.width
+LineString.__attrs__ = PatchedLineString.__attrs__
+LineString.__str__ = ReprMixin.__str__
+LineString.__repr__ = ReprMixin.__repr__
+# noinspection PyProtectedMember
+LineString._repr_html_ = ReprMixin._repr_html_
+# noinspection PyProtectedMember
+LineString._repr_pretty_ = ReprMixin._repr_pretty_

pyroll/core/transport/__init__.py

@@ -0,0 +1,3 @@
+from .transport import Transport
+
+from . import hookimpls

pyroll/core/transport/hookimpls.py

@@ -0,0 +1,17 @@
+from .transport import Transport
+
+
+@Transport.OutProfile.strain
+def out_strain(self: Transport.OutProfile):
+    """Assume total recrystallization during transport."""
+    return 0
+
+
+@Transport.duration
+def duration(self: Transport):
+    return self.length / self.velocity
+
+
+@Transport.environment_temperature
+def environment_temperature(self):
+    return 293

pyroll/core/transport/transport.py

@@ -0,0 +1,57 @@
+from typing import List, cast
+
+from ..hooks import Hook
+from ..disk_elements import DiskElementUnit
+
+
+class Transport(DiskElementUnit):
+    """Represents a transport unit, e.g. an inter-rolling-stand gap, a furnace or cooling range."""
+
+    environment_temperature = Hook[float]()
+    """Temperature of the surrounding atmosphere."""
+
+    @property
+    def disk_elements(self) -> List['Transport.DiskElement']:
+        """A list of disk elements used to subdivide this unit."""
+        return self._subunits
+
+    class Profile(DiskElementUnit.Profile):
+        """Represents a profile in context of a transport unit."""
+
+        @property
+        def transport(self) -> 'Transport':
+            """Reference to the transport. Alias for ``self.unit``."""
+            return cast(Transport, self.unit)
+
+    class InProfile(Profile, DiskElementUnit.InProfile):
+        """Represents an incoming profile of a transport unit."""
+
+    class OutProfile(Profile, DiskElementUnit.OutProfile):
+        """Represents an outgoing profile of a transport unit."""
+
+    class DiskElement(DiskElementUnit.DiskElement):
+        """Represents a disk element in a roll pass."""
+
+        @property
+        def transport(self) -> 'Transport':
+            """Reference to the transport. Alias for ``self.parent``."""
+            return cast(Transport, self.parent)
+
+        class Profile(DiskElementUnit.DiskElement.Profile):
+            """Represents a profile in context of a disk element unit."""
+
+            @property
+            def disk_element(self) -> 'Transport.DiskElement':
+                """Reference to the disk element. Alias for ``self.unit``"""
+                return cast(Transport.DiskElement, self.unit)
+
+            @property
+            def transport(self) -> 'Transport':
+                """Reference to the transport. Alias for ``self.unit.parent``"""
+                return cast(Transport, self.unit.parent)
+
+        class InProfile(Profile, DiskElementUnit.DiskElement.InProfile):
+            """Represents an incoming profile of a disk element unit."""
+
+        class OutProfile(Profile, DiskElementUnit.DiskElement.OutProfile):
+            """Represents an outgoing profile of a disk element unit."""

pyroll/core/unit/__init__.py

@@ -0,0 +1,3 @@
+from .unit import Unit
+
+from . import hookimpls

pyroll/core/unit/hookimpls.py

@@ -0,0 +1,67 @@
+from ..config import Config
+from .unit import Unit
+
+for h in Unit.OutProfile.__hooks__:
+    @getattr(Unit.OutProfile, h)(trylast=True)
+    def copy_from_in_profile(self: Unit.OutProfile, hook=h):
+        return getattr(self.unit.in_profile, hook, None)
+
+
+    @getattr(Unit.OutProfile, h)
+    def copy_from_last_subunit(self: Unit.OutProfile, hook=h):
+        if self.unit.subunits:
+            return getattr(self.unit.subunits[-1].out_profile, hook, None)
+
+
+@Unit.iteration_precision
+def default_iteration_precision(self: Unit):
+    return Config.DEFAULT_ITERATION_PRECISION
+
+
+@Unit.max_iteration_count
+def default_max_iteration_count(self: Unit):
+    return Config.DEFAULT_MAX_ITERATION_COUNT
+
+
+@Unit.volume
+def volume(self: Unit):
+    return (self.in_profile.cross_section.area + self.out_profile.cross_section.area) / 2 * self.length
+
+
+@Unit.surface_area
+def surface_area(self: Unit):
+    return (self.in_profile.cross_section.perimeter + self.out_profile.cross_section.perimeter) / 2 * self.length
+
+
+@Unit.length
+def length(self: Unit):
+    if self.has_set_or_cached("duration"):
+        return self.velocity * self.duration
+
+
+@Unit.duration
+def duration(self: Unit):
+    if self.has_set_or_cached("length"):
+        return self.length / self.velocity
+
+
+@Unit.velocity
+def velocity(self: Unit):
+    if self.in_profile.has_set_or_cached("velocity"):
+        return self.in_profile.velocity
+
+
+@Unit.OutProfile.velocity
+def out_velocity(self: Unit.OutProfile):
+    if self.unit.in_profile.has_set_or_cached("velocity"):
+        return self.unit.in_profile.velocity * self.unit.in_profile.cross_section.area / self.cross_section.area
+
+
+@Unit.OutProfile.x
+def out_x(self: Unit.OutProfile):
+    return self.unit.in_profile.x + self.unit.length
+
+
+@Unit.OutProfile.t
+def out_t(self: Unit.OutProfile):
+    return self.unit.in_profile.t + self.unit.duration