pyroll-phase-transformation-model 3.1.0__tar.gz

pyroll_phase_transformation_model-3.1.0/.gitignore

@@ -0,0 +1,152 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/

pyroll_phase_transformation_model-3.1.0/LICENSE

@@ -0,0 +1,11 @@
+Copyright 2026 Christoph Renzing
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

pyroll_phase_transformation_model-3.1.0/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: pyroll-phase-transformation-model
+Version: 3.1.0
+Summary: PyRolL plugin computing the austenite-decomposition phase composition (and resulting hardness/mechanical properties) along the reconstructed thermal history of a pass sequence, including a ring-wise distribution.
+Project-URL: Homepage, https://pyroll.readthedocs.io
+Project-URL: Repository, https://github.com/ChRen95/pyroll-phase-transformation-modele
+Project-URL: Documentation, https://github.com/ChRen95/pyroll-phase-transformation-model/blob/main/docs/docs.pdf
+Author-email: Christoph Renzing <christophrenzing@posteo.de>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Hatch
+Classifier: Framework :: IPython
+Classifier: Framework :: Jupyter
+Classifier: Framework :: Pytest
+Classifier: Framework :: Sphinx
+Classifier: Intended Audience :: Manufacturing
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: <4.0,>=3.9
+Requires-Dist: pandas
+Requires-Dist: pyroll-core
+Requires-Dist: pyroll-jmak-recrystallization
+Requires-Dist: pyroll-ring-model-thermal
+Requires-Dist: scipy

pyroll_phase_transformation_model-3.1.0/hatch.toml

@@ -0,0 +1,32 @@
+[build]
+packages = [
+    "pyroll" # place your package in the pyroll namespace
+]
+
+[version]
+path = "pyroll/phase_transformation_model/__init__.py"
+
+[envs.default]
+path = ".venv"
+dependencies = [
+    "pytest ~= 7.0",
+    "pyroll-report"
+]
+
+[envs.docs]
+path = ""
+dependencies = [
+    "pygments ~= 2.0"
+]
+
+[envs.docs.scripts]
+build = "latexmk --cd --pdf --shell-escape docs/docs" # compile LaTeX docs with latexmk
+
+[envs.test]
+path = ""
+
+[envs.test.scripts]
+all = "pytest"
+
+[[envs.test.matrix]]
+python = ["3.9", "3.10", "3.11"]

pyroll_phase_transformation_model-3.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "pyroll-phase-transformation-model"
+description = "PyRolL plugin computing the austenite-decomposition phase composition (and resulting hardness/mechanical properties) along the reconstructed thermal history of a pass sequence, including a ring-wise distribution."
+authors = [
+    { name = "Christoph Renzing", email = "christophrenzing@posteo.de" }
+]
+license = "BSD-3-Clause"
+requires-python = ">=3.9, <4.0"
+
+dependencies = [
+    "pyroll-core",
+    "pyroll-ring-model-thermal",
+    "pyroll-jmak-recrystallization",
+    "scipy",
+    "pandas",
+]
+
+classifiers = [
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Manufacturing",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering",
+    "License :: OSI Approved :: BSD License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Development Status :: 5 - Production/Stable",
+    "Framework :: Hatch",
+    "Framework :: IPython",
+    "Framework :: Jupyter",
+    "Framework :: Pytest",
+    "Framework :: Sphinx",
+    "Natural Language :: English",
+]
+
+dynamic = ["version"]
+
+[project.urls]
+Homepage = "https://pyroll.readthedocs.io"
+
+# change these URLs to your needs
+Repository = "https://github.com/ChRen95/pyroll-phase-transformation-modele"
+Documentation = "https://github.com/ChRen95/pyroll-phase-transformation-model/blob/main/docs/docs.pdf"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

pyroll_phase_transformation_model-3.1.0/pyroll/phase_transformation_model/__init__.py

@@ -0,0 +1,43 @@
+VERSION = "3.1.0"
+
+from . import profile  # noqa: F401  (registers profile hooks)
+from . import microstructure  # noqa: F401  (registers result hooks)
+
+from .sigmoidal_functions import S, I
+from .phase_transformations import (
+    Martensite,
+    Bainite,
+    Ferrite,
+    Perlite,
+    DiffusionalPhaseTransformation,
+)
+from .transformation import (
+    PhaseTransformationSolver,
+    vickers_hardness_martensite,
+    vickers_hardness_bainite,
+    vickers_hardness_ferrite_perlite,
+    tensile_strength_from_hardness,
+    elongation_a50,
+    reduction_of_area,
+    impact_energy_ku,
+)
+from .microstructure import Config
+
+__all__ = [
+    "S",
+    "I",
+    "Martensite",
+    "Bainite",
+    "Ferrite",
+    "Perlite",
+    "DiffusionalPhaseTransformation",
+    "PhaseTransformationSolver",
+    "vickers_hardness_martensite",
+    "vickers_hardness_bainite",
+    "vickers_hardness_ferrite_perlite",
+    "tensile_strength_from_hardness",
+    "elongation_a50",
+    "reduction_of_area",
+    "impact_energy_ku",
+    "Config",
+]

pyroll_phase_transformation_model-3.1.0/pyroll/phase_transformation_model/microstructure.py

@@ -0,0 +1,275 @@
+"""Integration of the phase-transformation model into the PyRoll hook system.
+
+The standalone :class:`~.transformation.PhaseTransformationSolver` works on a
+thermal cycle ``T(t)``. Inside a PyRoll process that cycle is not given
+explicitly; it has to be reconstructed from the solved unit tree. As the bar
+flows through the sequence, every unit's out-profile carries the accumulated
+time :pyattr:`~pyroll.core.Profile.t` and its :pyattr:`temperature`. Cooling
+units (:class:`~pyroll.core.Transport`, :class:`~pyroll.core.CoolingPipe`,
+:class:`~pyroll.core.Spooler`) are :class:`~pyroll.core.DiskElementUnit`\\ s, so
+their disk elements provide the fine-grained ``(t, T)`` samples that resolve the
+cooling rates the kinetics depend on.
+
+This module walks that tree, assembles the thermal history up to and including
+any out-profile, and exposes the resulting microstructure as profile hooks:
+
+* :pyattr:`microstructure_composition` – bulk phase fractions (core hook).
+* :pyattr:`ring_microstructure_compositions` – per-ring phase fractions, using
+  the ``ring_temperatures`` of :mod:`pyroll.ring_model_thermal`.
+* :pyattr:`vickers_hardness` – overall Maynier hardness (core hook).
+* :pyattr:`mechanical_properties` – tensile strength, elongation, etc.
+* :pyattr:`thermal_history` / :pyattr:`ring_thermal_histories` – the
+  reconstructed ``T(t)`` cycles, mainly for inspection.
+
+All result hooks are **lazy**: they are computed (and cached) only when accessed,
+e.g. ``sequence[i].out_profile.microstructure_composition``. They are
+intentionally not registered as root hooks, because root hooks are re-evaluated
+on every convergence iteration of every unit, which would make the per-step
+solver prohibitively expensive. To have them appear in reports, add the desired
+hook to ``pyroll.core.root_hooks`` in your own configuration.
+"""
+
+import numpy as np
+import pandas as pd
+
+from pyroll.core import Unit, Hook, config
+
+from .transformation import PhaseTransformationSolver
+
+#: Phase columns produced by the solver, in report order.
+_PHASES = ("ferrite", "perlite", "bainite", "martensite", "austenite")
+
+#: Key under which the computed solver frame is cached on a profile instance.
+_FRAME_CACHE = "_ptm_frame"
+
+
+@config("PYROLL_PHASE_TRANSFORMATION_MODEL")
+class Config:
+    THERMAL_HISTORY_SAMPLES = 1000
+    """Number of uniform time samples the thermal history is resampled to
+    before it is handed to the kinetics solver. The solver assumes a uniform
+    time grid, while the reconstructed history is non-uniform; this is the grid
+    it is interpolated onto. Higher values are more accurate but slower."""
+
+
+@Unit.OutProfile.extension_class
+class PhaseTransformationOutProfile(Unit.OutProfile):
+    """Result hooks added to every unit out-profile."""
+
+    thermal_history = Hook[dict]()
+    """The reconstructed scalar thermal cycle up to this profile as a dict with
+    the keys ``t`` (time in s) and ``T`` (temperature in K), each a 1-D array."""
+
+    ring_thermal_histories = Hook[np.ndarray]()
+    """The reconstructed per-ring thermal cycles up to this profile as a 2-D
+    array of shape ``(n_samples, n_rings)`` aligned with
+    :pyattr:`~pyroll.ring_model.RingProfile.rings`. Available only if ring
+    temperatures are present (``pyroll-ring-model-thermal`` in use)."""
+
+    ring_microstructure_compositions = Hook[np.ndarray]()
+    """Per-ring phase composition: an object array of ``{phase: fraction}``
+    dicts, one per ring from core to surface. Available only if ring
+    temperatures are present."""
+
+    mechanical_properties = Hook[dict]()
+    """Estimated mechanical properties derived from the final microstructure
+    (``HV``, ``ym``, ``Rm``, ``A50``, ``Z``, ``KU``)."""
+
+
+# ---------------------------------------------------------------------------
+# Thermal-history reconstruction (plain helpers, return None when unavailable)
+# ---------------------------------------------------------------------------
+
+def _root_unit(unit: Unit) -> Unit:
+    """Climb to the outermost unit (typically the :class:`PassSequence`)."""
+    while unit.parent is not None:
+        unit = unit.parent
+    return unit
+
+
+def _leaf_out_profiles(unit: Unit):
+    """Yield the out-profiles of all leaf units in solution order.
+
+    Cooling units are subdivided into disk elements; those disks are the leaves
+    and provide the fine ``(t, T)`` resolution. Units without subunits (e.g.
+    roll passes) contribute their own out-profile.
+    """
+    subunits = unit.subunits
+    if subunits:
+        for sub in subunits:
+            yield from _leaf_out_profiles(sub)
+    elif unit.out_profile is not None:
+        yield unit.out_profile
+
+
+def _ring_temperatures(profile):
+    if profile.has_set_or_cached("ring_temperatures"):
+        value = profile.ring_temperatures
+        if value is not None:
+            return np.asarray(value, dtype=float)
+    return None
+
+
+def _collect_history(target):
+    """Collect ``(t, temperature, ring_temperatures)`` samples up to ``target``.
+
+    Returns a list of ``(t, T, ring_T_or_None)`` tuples ordered by time,
+    starting from the first in-profile of the sequence and ending at ``target``.
+    Profiles later than ``target`` (downstream, or not yet solved) are excluded
+    via the ``t`` filter.
+    """
+    root = _root_unit(target.unit)
+    t_target = target.t
+
+    samples = []
+
+    start = root.in_profile
+    if start is not None and start.has_value("t") and start.has_value("temperature"):
+        samples.append((float(start.t), float(start.temperature), _ring_temperatures(start)))
+
+    for profile in _leaf_out_profiles(root):
+        if profile.t <= t_target + 1e-9:
+            samples.append(
+                (float(profile.t), float(profile.temperature), _ring_temperatures(profile))
+            )
+
+    samples.sort(key=lambda s: s[0])
+    return samples
+
+
+def _scalar_history(target):
+    """Return ``(time, temperature)`` arrays of the bulk cycle, or ``None``."""
+    samples = _collect_history(target)
+    if len(samples) < 2:
+        return None
+    times = np.array([s[0] for s in samples], dtype=float)
+    temperatures = np.array([s[1] for s in samples], dtype=float)
+    return times, temperatures
+
+
+def _ring_history(target):
+    """Return ``(time, ring_temperatures_2d)`` of the per-ring cycles, or ``None``."""
+    samples = _collect_history(target)
+    if len(samples) < 2 or any(s[2] is None for s in samples):
+        return None
+    if len({len(s[2]) for s in samples}) != 1:
+        return None
+    times = np.array([s[0] for s in samples], dtype=float)
+    ring_temperatures = np.array([s[2] for s in samples], dtype=float)
+    return times, ring_temperatures
+
+
+# ---------------------------------------------------------------------------
+# Kinetics evaluation
+# ---------------------------------------------------------------------------
+
+def _solve_cycle(solver, profile, times, temperatures, n):
+    """Run the kinetics solver on a single ``T(t)`` cycle.
+
+    Resamples ``(times, temperatures)`` onto the uniform grid the solver
+    expects and short-circuits to a fully austenitic frame when the cycle never
+    cools below the ferrite-start temperature, sparing the per-step root solve
+    for the still-hot part of the line.
+    """
+    times = np.asarray(times, dtype=float)
+    temperatures = np.asarray(temperatures, dtype=float)
+    unique_times, order = np.unique(times, return_index=True)
+    grid = np.linspace(unique_times[0], unique_times[-1], n)
+    grid_temperatures = np.interp(grid, unique_times, temperatures[order])
+
+    if np.nanmin(grid_temperatures) >= profile.ae3_temperature:
+        frame = pd.DataFrame({"t": grid, "T": grid_temperatures})
+        for name in ("ferrite", "perlite", "bainite", "martensite"):
+            frame[name] = 0.0
+        frame["austenite"] = 1.0
+        return frame
+
+    return solver.get_transformed_fraction(grid, grid_temperatures)
+
+
+def _final_composition(frame: pd.DataFrame) -> dict:
+    final = frame.iloc[-1]
+    return {name: float(final[name]) for name in _PHASES}
+
+
+def _bulk_frame(profile):
+    """The solver frame for the bulk thermal history, cached on the profile."""
+    cached = profile.__dict__.get(_FRAME_CACHE)
+    if cached is not None:
+        return cached
+    history = _scalar_history(profile)
+    if history is None:
+        return None
+    solver = PhaseTransformationSolver(profile)
+    frame = _solve_cycle(solver, profile, history[0], history[1], Config.THERMAL_HISTORY_SAMPLES)
+    profile.__dict__[_FRAME_CACHE] = frame
+    return frame
+
+
+# ---------------------------------------------------------------------------
+# Hooks
+# ---------------------------------------------------------------------------
+
+@Unit.OutProfile.thermal_history
+def thermal_history(self):
+    history = _scalar_history(self)
+    if history is None:
+        return None
+    return {"t": history[0], "T": history[1]}
+
+
+@Unit.OutProfile.ring_thermal_histories
+def ring_thermal_histories(self):
+    history = _ring_history(self)
+    if history is None:
+        return None
+    return history[1]
+
+
+@Unit.OutProfile.microstructure_composition
+def microstructure_composition(self):
+    frame = _bulk_frame(self)
+    if frame is None:
+        return None
+    return _final_composition(frame)
+
+
+@Unit.OutProfile.ring_microstructure_compositions
+def ring_microstructure_compositions(self):
+    history = _ring_history(self)
+    if history is None:
+        return None
+    times, ring_temperatures = history
+
+    # The kinetics inputs (transformation temperatures, composition factors,
+    # grain size) are profile-level and identical for every ring; only the
+    # temperature path differs, so one solver instance is reused.
+    solver = PhaseTransformationSolver(self)
+    n = Config.THERMAL_HISTORY_SAMPLES
+
+    n_rings = ring_temperatures.shape[1]
+    result = np.empty(n_rings, dtype=object)
+    for i in range(n_rings):
+        frame = _solve_cycle(solver, self, times, ring_temperatures[:, i], n)
+        result[i] = _final_composition(frame)
+    return result
+
+
+@Unit.OutProfile.vickers_hardness
+def vickers_hardness(self):
+    frame = _bulk_frame(self)
+    if frame is None:
+        return None
+    hardness = PhaseTransformationSolver(self).estimate_hardness(frame)
+    if not np.isfinite(hardness):
+        return None
+    return float(hardness)
+
+
+@Unit.OutProfile.mechanical_properties
+def mechanical_properties(self):
+    frame = _bulk_frame(self)
+    if frame is None:
+        return None
+    properties = PhaseTransformationSolver(self).estimate_mechanical_properties(frame)
+    return {key: float(value) for key, value in properties.items()}

pyroll_phase_transformation_model-3.1.0/pyroll/phase_transformation_model/phase_transformations/__init__.py

@@ -0,0 +1,6 @@
+from .base import PhaseTransformation
+from .diffusional_phase_transformation import DiffusionalPhaseTransformation
+from .bainite import Bainite
+from .ferrite import Ferrite
+from .perlite import Perlite
+from .martensite import Martensite

pyroll_phase_transformation_model-3.1.0/pyroll/phase_transformation_model/phase_transformations/bainite.py

@@ -0,0 +1,29 @@
+from .diffusional_phase_transformation import DiffusionalPhaseTransformation
+
+
+class Bainite(DiffusionalPhaseTransformation):
+    """
+    Austenite to bainite phase transformation
+    """
+
+    name = "bainite"
+
+    @property
+    def grain_size_coefficient(self):
+        return 0.29
+
+    @property
+    def diffusion_coefficient(self):
+        return 2
+
+    @property
+    def transformation_start_temperature(self):
+        return self.profile.bainite_start_temperature
+
+    @property
+    def transformation_finish_temperature(self):
+        return self.profile.martensite_start_temperature
+
+    @property
+    def composition_factor(self):
+        return self.profile.bainite_kinetics

pyroll_phase_transformation_model-3.1.0/pyroll/phase_transformation_model/phase_transformations/base.py

@@ -0,0 +1,52 @@
+from abc import ABC, abstractmethod
+
+import numpy as np
+import pyroll.core as pr
+
+
+class PhaseTransformation(ABC):
+    """
+    Abstract base class for an austenite-decomposition product.
+
+    A phase only has to know how to evaluate the fraction transformed along a
+    thermal history ``T(t)``.  Diffusional products (ferrite, pearlite,
+    bainite) additionally provide isothermal kinetics and live in
+    :class:`DiffusionalPhaseTransformation`; athermal products (martensite)
+    implement :meth:`get_transformed_fraction` directly.
+
+    Attributes
+    ----------
+    name : str
+        Identifier of the phase. It is also the column key used in the result
+        frames produced by the solver and the colour key used by the diagram
+        utilities, so it must be unique across all registered phases.
+    """
+
+    name: str
+
+    def __init__(self, profile: pr.Profile):
+        self.profile: pr.Profile = profile
+
+    @abstractmethod
+    def get_transformed_fraction(
+        self, time: np.ndarray, temperature: np.ndarray, n: int = 1000
+    ):
+        """
+        Calculate the transformed fraction for a given thermal cycle ``T(t)``.
+
+        Parameters
+        ----------
+        time : np.ndarray
+            Time in seconds.
+        temperature : np.ndarray
+            Temperatures at the instants of ``time`` in Kelvin.
+        n : int, optional
+            Number of points at which the transformed fraction is evaluated.
+
+        Returns
+        -------
+        time, temperature, fraction : tuple of np.ndarray
+            The (possibly resampled) thermal cycle and the transformed phase
+            fraction evaluated along it.
+        """
+        raise NotImplementedError