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

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

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

@@ -29,15 +29,8 @@ from .grooves import (
     butterfly_grooves,
     create_groove_by_type_name,
 )
-from .transport import Transport, CoolingPipe, Spooler
-from .roll_pass import (
-    BaseRollPass,
-    DeformationUnit,
-    ThreeRollPass,
-    SymmetricRollPass,
-    TwoRollPass,
-    AsymmetricTwoRollPass,
-)
+from .transport import Transport, CoolingPipe, Spooler, StelmorConveyor, InductionFurnace
+from .roll_pass import BaseRollPass, DeformationUnit, ThreeRollPass, SymmetricRollPass, TwoRollPass, AsymmetricTwoRollPass
 from .roll_pass import TwoRollPass as RollPass
 from .unit import Unit
 from .roll import Roll
@@ -55,7 +48,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.0b2"
+VERSION = "3.2.0b3"
 
 __all__ = [
     # grooves
@@ -98,6 +91,8 @@ __all__ = [
     "Transport",
     "CoolingPipe",
     "Spooler",
+    "StelmorConveyor",
+    "InductionFurnace",
     # roll_pass
     "RollPass",
     "BaseRollPass",
@@ -129,6 +124,7 @@ __all__ = [
 
 root_hooks.extend(
     [
+        AsymmetricTwoRollPass.InProfile.pass_line,
         AsymmetricTwoRollPass.InProfile.cross_section,
         BaseRollPass.roll_force,
         SymmetricRollPass.Roll.roll_torque,

{pyroll_core-3.2.0b2 → pyroll_core-3.2.0b3}/pyroll/core/engine/hookimpls.py

@@ -3,6 +3,10 @@ import numpy as np
 from .engine import Engine
 from ..transport import Transport
 
+@Engine.gear_ratio
+def default_gear_ratio(self: Engine):
+    return 1
+
 @Engine.gear_box_efficiency
 def gear_box_efficiency_becker(self: Engine):
     return 0.95

{pyroll_core-3.2.0b2 → pyroll_core-3.2.0b3}/pyroll/core/hooks.py

@@ -448,27 +448,44 @@ class HookHost(ReprMixin, LogMixin, metaclass=_HookHostMeta):
         return None
 
     def evaluate_and_set_hooks(self):
-        """Evaluate functions of root hooks and set the results explicitly as attributes."""
+        """Evaluate functions of root hooks and set the results explicitly as attributes.
+
+        All applicable root hooks are evaluated first, against the state left by the previous
+        call (so their hook functions never observe a partially updated mix of this iteration's
+        and the previous iteration's root hook values), and only afterward set as attributes.
+        Committing them one by one instead would make the result depend on the arbitrary order
+        of ``root_hooks``: a hook function reading another root hook registered later in that
+        list would always see last iteration's value, while one reading a hook registered
+        earlier would see this iteration's, an inconsistency root hook functions must not have to
+        account for.
+        """
 
-        def _gen():
-            for h in root_hooks:
-                if issubclass(type(self), h.owner):
-                    h = getattr(type(self), h.name)
-                    result = h.get_result(self)
+        applicable_hooks = [
+            getattr(type(self), h.name) for h in root_hooks if issubclass(type(self), h.owner)
+        ]
+
+        results = {}
+        for h in applicable_hooks:
+            result = h.get_result(self)
 
-                    if result is None:
-                        result = self.root_hook_fallback(h)
+            if result is None:
+                result = self.root_hook_fallback(h)
 
-                    if result is None:
-                        raise AttributeError(f"Call for root hook '{h.name}' on '{self}' resulted in None.")
+            if result is None:
+                raise AttributeError(f"Call for root hook '{h.name}' on '{self}' resulted in None.")
 
-                    setattr(self, h.name, result)
+            results[h.name] = result
 
-                    try:
-                        arr = np.array(result)
-                        yield from arr[np.isfinite(arr) | np.isinf(arr) | np.isnan(arr)].flat
-                    except TypeError:  # yield only numeric values
-                        continue
+        for name, result in results.items():
+            setattr(self, name, result)
+
+        def _gen():
+            for result in results.values():
+                try:
+                    arr = np.array(result)
+                    yield from arr[np.isfinite(arr) | np.isinf(arr) | np.isnan(arr)].flat
+                except TypeError:  # yield only numeric values
+                    continue
 
         return list(_gen())
 
@@ -516,9 +533,3 @@ class _RootHooksList(list):
 
 
 root_hooks = _RootHooksList()  # filled in __init__.py due to circular imports
-"""
-List of hooks to call explicitly in each solution iteration.
-Their values will be treated as explicitly set but reevaluated in every iteration.
-They will not be deleted during cache clearing.
-They serve as root for the calling tree and persistent iterational variables.
-"""

pyroll_core-3.2.0b3/pyroll/core/roll_pass/hookimpls/asymmetric_two_roll_pass.py

@@ -0,0 +1,175 @@
+import numpy as np
+import scipy.optimize
+import shapely.affinity
+from shapely import Polygon
+
+from . import helpers
+from ..asymmetric_two_roll_pass import AsymmetricTwoRollPass
+from ...grooves import GenericElongationGroove
+
+
+@AsymmetricTwoRollPass.usable_width
+def usable_width(self: AsymmetricTwoRollPass):
+    return min(self.upper_roll.groove.usable_width, self.lower_roll.groove.usable_width)
+
+
+@AsymmetricTwoRollPass.tip_width
+def tip_width(self: AsymmetricTwoRollPass):
+    if isinstance(self.upper_roll.groove, GenericElongationGroove) and isinstance(
+        self.lower_roll.groove, GenericElongationGroove
+    ):
+        return min(
+            self.upper_roll.groove.usable_width + self.gap / 2 / np.tan(self.upper_roll.groove.flank_angle),
+            self.lower_roll.groove.usable_width + self.gap / 2 / np.tan(self.lower_roll.groove.flank_angle),
+        )
+
+
+@AsymmetricTwoRollPass.usable_cross_section
+def usable_cross_section(self: AsymmetricTwoRollPass) -> Polygon:
+    return helpers.out_cross_section(self, self.usable_width)
+
+
+@AsymmetricTwoRollPass.tip_cross_section
+def tip_cross_section(self: AsymmetricTwoRollPass) -> Polygon:
+    return helpers.out_cross_section(self, self.tip_width)
+
+
+@AsymmetricTwoRollPass.gap
+def gap(self: AsymmetricTwoRollPass):
+    if self.has_set_or_cached("height"):
+        return self.height - self.upper_roll.groove.depth - self.lower_roll.groove.depth
+
+
+@AsymmetricTwoRollPass.height
+def height(self: AsymmetricTwoRollPass):
+    if self.has_set_or_cached("gap"):
+        return self.gap + self.upper_roll.groove.depth + self.lower_roll.groove.depth
+
+
+@AsymmetricTwoRollPass.contact_area
+def contact_area(self: AsymmetricTwoRollPass):
+    return self.upper_roll.contact_area + self.lower_roll.contact_area
+
+
+@AsymmetricTwoRollPass.target_cross_section_area
+def target_cross_section_area_from_target_width(self: AsymmetricTwoRollPass):
+    if self.has_value("target_width"):
+        target_cross_section = helpers.out_cross_section(self, self.target_width)
+        return target_cross_section.area
+
+
+@AsymmetricTwoRollPass.power
+def roll_power(self: AsymmetricTwoRollPass):
+    return self.upper_roll.roll_power + self.lower_roll.roll_power
+
+
+@AsymmetricTwoRollPass.velocity
+def velocity(self: AsymmetricTwoRollPass):
+    if self.upper_roll.has_value("neutral_angle") and self.lower_roll.has_value("neutral_angle"):
+        return (
+            self.upper_roll.working_velocity * np.cos(self.upper_roll.neutral_angle)
+            + self.lower_roll.working_velocity * np.cos(self.lower_roll.neutral_angle)
+        ) / 2
+    else:
+        return (self.upper_roll.working_velocity + self.lower_roll.working_velocity) / 2
+
+
+@AsymmetricTwoRollPass.roll_force
+def roll_force(self: AsymmetricTwoRollPass):
+    return (
+        (self.in_profile.flow_stress + 2 * self.out_profile.flow_stress)
+        / 3
+        * (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]:
+    """Places the incoming profile's cross-section within the roll gap: a vertical (``y``) and
+    transverse (``z``) shift, evaluated against the nominal roll-barrel contours (``contour_lines``,
+    the same fixed throat geometry ``draught``/``entry_point`` already use elsewhere). The rolling
+    direction is not a coordinate of a 2-D cross-section and plays no role here.
+
+    ``y`` is where the raw (undeformed) profile overlaps the upper and lower roll by exactly
+    *equal* area. If the rolls are large enough for the profile to touch both without overlapping
+    either, that zero-overlap placement falls out of this same condition automatically (equal
+    *and* zero); if not (e.g. an oversized profile against a strongly depth-asymmetric groove
+    pair), it is the placement where the initial squeeze is balanced evenly between both rolls
+    rather than concentrated on one side. As ``y`` increases the upper overlap area grows
+    monotonically while the lower overlap area shrinks monotonically, so there is always exactly
+    one such ``y`` -- a plain 1-D root find, no convergence caveats.
+
+    ``z`` is left at 0: both grooves in the currently supported use cases are left-right symmetric,
+    so the balanced placement is trivially centered."""
+    rp = self.roll_pass
+
+    # ``self.roll_pass.in_profile`` *is* ``self`` (this hook lives on the in-profile role of the
+    # roll pass), and ``in_cross_section`` (registered below) computes ``self.cross_section`` as
+    # this same raw shape translated by ``pass_line`` -- so reading ``self.cross_section`` here
+    # would normally be circular. As a root hook, every root hook function is evaluated against
+    # the state left by the *previous* iteration before any of this iteration's results are
+    # written back (see ``Hook.evaluate_and_set_hooks``), so on the very first call
+    # ``self.cross_section`` genuinely is the untranslated base profile -- capture it once, here,
+    # and reuse that same cached reference on every later call. Re-deriving it from
+    # ``self.cross_section`` on later calls would not work: each iteration's ``in_cross_section``
+    # also reads ``self.cross_section`` as its own input (same circularity), so it stacks a new
+    # translation on top of all previous ones rather than replacing them -- undoing only the most
+    # recent increment leaves the earlier accumulated ones baked in.
+    if not self.has_set_or_cached("pass_line"):
+        self._raw_in_cross_section = rp.in_profile.cross_section
+    raw_cross_section = self._raw_in_cross_section
+    raw_height = raw_cross_section.bounds[3] - raw_cross_section.bounds[1]
+
+    upper_contour, lower_contour = rp.contour_lines.geoms
+
+    def overlap_areas(y: float) -> tuple[float, float]:
+        shifted = shapely.affinity.translate(raw_cross_section, yoff=y)
+        a_upper = helpers.overlap_area(shifted, upper_contour.coords, direction=1)
+        a_lower = helpers.overlap_area(shifted, lower_contour.coords, direction=-1)
+        return a_upper, a_lower
+
+    # A fixed multiple of ``raw_height`` is not a safe bracket at all profile/roll scales: for a
+    # large profile it can end up so wide that ``brentq`` lands on a spurious point near the
+    # bracket edge instead of the true (much closer) root. Derive a tight, exactly-scaled bracket
+    # instead: shift the profile down until its top is fully below the lower contour's lowest
+    # point (guaranteeing full penetration into the lower roll, zero overlap with the upper one),
+    # and up until its bottom is fully above the upper contour's highest point (the mirror case).
+    # These are the true, guaranteed-sign-change bounds -- not an estimate.
+    box_bottom, box_top = raw_cross_section.bounds[1], raw_cross_section.bounds[3]
+    upper_contour_y = np.asarray(upper_contour.coords)[:, 1]
+    lower_contour_y = np.asarray(lower_contour.coords)[:, 1]
+    margin = 0.01 * raw_height + 1e-9
+    y_lo = lower_contour_y.min() - box_top - margin
+    y_hi = upper_contour_y.max() - box_bottom + margin
+    y = scipy.optimize.brentq(
+        lambda y: overlap_areas(y)[0] - overlap_areas(y)[1], y_lo, y_hi, xtol=1e-9,
+    )
+
+    common_overlap_area = overlap_areas(y)[0]
+    if common_overlap_area > 0:
+        self.logger.info(
+            "Hook %s.pass_line: the profile cannot touch both rolls without overlapping one of "
+            "them; settled at the placement with the evenly balanced overlap (%.3g mm^2 on each "
+            "side).",
+            type(self).__qualname__, common_overlap_area * 1e6,
+        )
+
+    return 0, y, 0
+
+
+@AsymmetricTwoRollPass.InProfile.cross_section
+def in_cross_section(self: AsymmetricTwoRollPass.InProfile):
+    # ``self.roll_pass.in_profile`` *is* ``self``, so translating ``self.cross_section`` (this
+    # hook's own previous result) would stack a new translation on top of all previous ones every
+    # iteration instead of replacing them (the same circularity ``pass_line`` avoids by caching
+    # the true raw shape in ``self._raw_in_cross_section`` -- reuse that same stable reference
+    # here rather than re-reading ``self.cross_section``). Accessing ``self.pass_line`` first
+    # guarantees that cache is populated.
+    pass_line = self.pass_line
+    return shapely.affinity.translate(self._raw_in_cross_section, xoff=pass_line[2], yoff=pass_line[1])
+
+
+@AsymmetricTwoRollPass.entry_point
+def entry_point(self: AsymmetricTwoRollPass):
+    return min(self.upper_roll.entry_point, self.lower_roll.entry_point)

{pyroll_core-3.2.0b2 → pyroll_core-3.2.0b3}/pyroll/core/roll_pass/hookimpls/deformation_unit.py

@@ -20,9 +20,13 @@ def spread(self: DeformationUnit):
 def elongation(self: DeformationUnit):
     return self.in_profile.cross_section.area / self.out_profile.cross_section.area
 
+
 @DeformationUnit.reduction
 def reduction(self: DeformationUnit):
-    return (self.in_profile.cross_section.area - self.in_profile.cross_section.area) / self.in_profile.cross_section.area
+    return (
+        self.in_profile.cross_section.area - self.out_profile.cross_section.area
+    ) / self.in_profile.cross_section.area
+
 
 @DeformationUnit.log_draught
 def log_draught(self: DeformationUnit):

{pyroll_core-3.2.0b2 → pyroll_core-3.2.0b3}/pyroll/core/roll_pass/hookimpls/engine.py

@@ -5,14 +5,15 @@ from ..asymmetric_two_roll_pass import AsymmetricTwoRollPass
 
 
 @TwoRollPass.Engine.torque
-def engine_torque(self: TwoRollPass.Engine):
-    return 2 * self.roll_pass.roll.roll_torque / (self.spindle_efficiency * self.gear_box_efficiency) + self.idle_torque
+def engine_torque_gear_corrected(self: TwoRollPass.Engine):
+    return 2 * self.roll_pass.roll.roll_torque / (self.gear_ratio * self.spindle_efficiency * self.gear_box_efficiency
+    ) + self.idle_torque
 
 
 @ThreeRollPass.Engine.torque
-def engine_torque_three(self: ThreeRollPass.Engine):
-    return 3 * self.roll_pass.roll.roll_torque / (self.spindle_efficiency * self.gear_box_efficiency) + self.idle_torque
-
+def engine_torque_gear_corrected(self: ThreeRollPass.Engine):
+    return 3 * self.roll_pass.roll.roll_torque / ( self.gear_ratio * self.spindle_efficiency * self.gear_box_efficiency
+    ) + self.idle_torque
 
 @AsymmetricTwoRollPass.Engine.torque
 def engine_torque_asymmetric(self: AsymmetricTwoRollPass.Engine):
@@ -29,7 +30,6 @@ def engine_rotational_frequency(self: BaseRollPass.Engine):
     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"):

{pyroll_core-3.2.0b2 → pyroll_core-3.2.0b3}/pyroll/core/roll_pass/hookimpls/helpers.py

@@ -55,6 +55,24 @@ def max_vertical_penetration(cross_section: Polygon, contour_coords, direction:
     return max(float(penetrations.max(initial=0)), 0)
 
 
+def overlap_area(cross_section: Polygon, contour_coords, direction: int) -> float:
+    """
+    Area of the profile cross-section that overlaps the roll material behind a contour line.
+
+    :param cross_section: the (already positioned) profile cross-section
+    :param contour_coords: coordinate sequence of the (already positioned) contour line
+    :param direction: ``1`` for an upper roll (material above the contour), ``-1`` for a lower roll (material below)
+    """
+    coords = np.asarray(contour_coords)
+    y_far = 10.0 if direction > 0 else -10.0
+    forbidden_region = Polygon(
+        np.concatenate([coords, [[coords[-1, 0], y_far], [coords[0, 0], y_far]]])
+    )
+    if not forbidden_region.is_valid:
+        forbidden_region = shapely.make_valid(forbidden_region)
+    return shapely.intersection(cross_section, forbidden_region).area
+
+
 def out_cross_section3(rp: ThreeRollPass, width: float) -> Polygon:
     poly = Polygon(np.concatenate([cl.coords for cl in rp.contour_lines.geoms]))
 

{pyroll_core-3.2.0b2 → pyroll_core-3.2.0b3}/pyroll/core/roll_pass/hookimpls/profile.py

@@ -72,7 +72,8 @@ def cross_section(self: BaseRollPass.OutProfile) -> Polygon:
         cs = helpers.out_cross_section(self.roll_pass, self.width)
         if cs.width * 1.01 < self.width:
             raise ValueError(
-                "Profile's width can not be larger than its contour lines." "May be caused by critical overfilling."
+                "Profile's width can not be larger than its contour lines."
+                "May be caused by critical overfilling."
             )
         return cs
 
@@ -98,7 +99,7 @@ def cross_section(self: BaseRollPass.OutProfile) -> Polygon:
         half_cross_section_1 = union(intermediate_section, filling_rectangle)
         half_cross_section_2 = scale(half_cross_section_1, xfact=-1, yfact=-1, origin=(0, 0))
         cs = union(half_cross_section_1, half_cross_section_2)
-    except GEOSException:
+    except GEOSException as e:
         cs = helpers.out_cross_section(self.roll_pass, self.width)
 
     if cs.width * 1.01 < self.width:

{pyroll_core-3.2.0b2 → pyroll_core-3.2.0b3}/pyroll/core/sequence/sequence.py

@@ -205,6 +205,10 @@ class PassSequence(Unit, Sequence[Unit]):
         )
         set_velocities_to_roll_passes(roll_passes=copied_sequence.roll_passes, velocities=initial_roll_pass_velocities)
 
+        in_profile.velocity = (
+            initial_roll_pass_velocities[0] * usable_cross_section_areas[0] / in_profile.cross_section.area
+        )
+
         copied_sequence.solve(in_profile)
 
         for i in range(self.max_iteration_count):
@@ -217,6 +221,8 @@ class PassSequence(Unit, Sequence[Unit]):
                 roll_passes=copied_sequence.roll_passes, velocities=current_roll_pass_velocities
             )
 
+            in_profile.velocity = current_roll_pass_velocities[0] * profile_areas[0] / in_profile.cross_section.area
+
             copied_sequence.solve(in_profile)
 
             difference = np.abs(prior_roll_pass_velocities - current_roll_pass_velocities)
@@ -235,6 +241,8 @@ class PassSequence(Unit, Sequence[Unit]):
         :param final_cross_section_area: area of the final cross-section
         """
 
+        in_profile.velocity = initial_speed
+
         copied_sequence = copy.deepcopy(self)
 
         def calculate_velocities_array(velocities: np.ndarray[float], cross_sections_areas: np.ndarray[float]):
@@ -279,52 +287,6 @@ 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
-    ):
-        """
-        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(self.roll_passes):
-            roll_pass.back_tension = tensions[2 * index]
-            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"

pyroll_core-3.2.0b3/pyroll/core/transport/__init__.py

@@ -0,0 +1,9 @@
+from .transport import Transport
+from .cooling_pipe import CoolingPipe
+from .spooler import Spooler
+from .stelmor_conveyor import StelmorConveyor
+from .induction_furnace import InductionFurnace
+
+from . import hookimpls  # noqa: F401
+
+__all__ = ["Transport", "CoolingPipe", "Spooler", "StelmorConveyor", "InductionFurnace"]

{pyroll_core-3.2.0b2 → pyroll_core-3.2.0b3}/pyroll/core/transport/hookimpls/__init__.py

@@ -1,3 +1,5 @@
 from . import transport
 from . import cooling_pipe
 from . import spooler
+from . import stelmor_conveyor
+from . import induction_furnace

{pyroll_core-3.2.0b2 → pyroll_core-3.2.0b3}/pyroll/core/transport/hookimpls/cooling_pipe.py

@@ -1,4 +1,5 @@
 import numpy as np
+
 from ..cooling_pipe import CoolingPipe
 
 
@@ -11,7 +12,7 @@ def inner_radius(self: CoolingPipe):
 @CoolingPipe.cross_section_area
 def cross_section_area(self: CoolingPipe):
     if self.has_set_or_cached("inner_radius"):
-        return self.inner_radius**2 * np.pi
+        return self.inner_radius ** 2 * np.pi
 
 
 @CoolingPipe.coolant_flow_cross_section

pyroll_core-3.2.0b3/pyroll/core/transport/hookimpls/induction_furnace.py

@@ -0,0 +1,23 @@
+from ..induction_furnace import InductionFurnace
+
+
+@InductionFurnace.electrical_efficiency
+def default_electrical_efficiency(self: InductionFurnace):
+    return 0.6
+
+
+@InductionFurnace.generator_power
+def generator_power_from_target_temperature(self: InductionFurnace):
+    if self.has_value("target_temperature"):
+        delta_t = self.target_temperature - self.in_profile.temperature
+        return self.mass_flux * self.in_profile.specific_heat_capacity * delta_t / self.electrical_efficiency
+
+
+@InductionFurnace.absorbed_power
+def absorbed_power(self: InductionFurnace):
+    return self.generator_power * self.electrical_efficiency
+
+
+@InductionFurnace.power_density
+def power_density(self: InductionFurnace):
+    return self.absorbed_power / self.volume