Source code for morphogen.laser.materials

"""Materials of laser-architectured sheets: flow laws from tensile properties, the
strength of each hardness, and the steels of the PIMM studies.

**Flow law** (:class:`FlowLaw`). The true stress of the equivalent plastic strain,
Ludwik's ``σ(p) = σ0 + K((p + δ)^n − δ^n)`` (``δ = 10⁻⁴`` keeps the initial slope
finite) or Voce's ``σ0 + Q(1 − exp(−bp))``. Given the 0.2 % proof stress ``R_p`` (the
stress at a plastic strain of 0.2 %), the engineering tensile strength ``R_m`` and the
uniform elongation ``A_g`` (engineering) of a tensile test, Considère's condition
``dσ/dp = σ`` at the true plastic uniform strain ``p_u = ln(1 + A_g) − σ_u/E``, with
``σ(p_u) = σ_u = R_m (1 + A_g)``, fixes the two other parameters
(:func:`flow_parameters`): Ludwik's law when an exponent fits, Voce's otherwise (the
large strength ratios of martensite at small elongations).

**Strength of a hardness** (:class:`StrengthTable`). The tensile properties of the
states of a material (base, treated at several energies, carburized...) against their
Vickers hardness, measured; between them linear interpolation, beyond the last rows the
correlations of Pavlina & Van Tyne (2008) for steels (``R_p = −90.7 + 2.876 HV``,
``R_m = −99.8 + 3.734 HV``, MPa) shifted to meet the table, and the uniform elongation
extrapolated linearly (at least 2 %). Each point of a treated sheet gets the flow law
of its hardness.

**Presets** (:data:`PRESETS`, :func:`sheet_material`):

* ``aisi430``: ferritic stainless steel AISI 430, 0.5 mm (Wang et al. 2022): C 0.026,
  Cr 18.7; base 160 HV, R_p 346 MPa, R_m 503 MPa, A_g 19.4 %; fully treated by the double
  laser in argon at 15 and 20 kJ/m: 211.5 and 241.8 HV, R_p 489 and 540 MPa, R_m 624 and
  703 MPa, A_g 15.5 and 13.7 % (the table); carburized (Wang 2022, thesis ch. 4): +130 %
  HV, R_p +90 %, R_m +85 % (A_g assumed 10 %). Hardening by peak temperature (onset Ac1
  = 1148 K, 310 HV near Tm = 1698 K for a single track), its gain at 1300 °C and its
  tempering fitted to the mean hardness of the sheets fully treated by ten tracks at
  1 mm pitch (211.5, 241.8 and 233.6 HV at 15, 20 and 25 kJ/m; computed 212, 240 and
  235).
* ``annealed_ms1500``: MS1500 annealed at 850 °C for 1 h (ferrite–pearlite), 1 mm
  (Wang 2022, thesis ch. 5): C 0.228, Si 0.242, Mn 1.73, Cr 0.19; 167 HV, R_p 300 MPa,
  R_m 534 MPa, A_g 16.7 %; laser martensite as the as-received MS1500 (about 480 HV,
  R_p 1300 MPa, R_m 1600 MPa, A_g 4 %; Lapouge et al. 2019, Wang 2020).
* ``dp1180``: dual-phase DP1180, 1 mm (Lapouge et al. 2019): 85 % martensite, 380 HV,
  R_p 850 MPa, R_m 1200 MPa, A_g 5 %; tempered at Ac1, R_m 816 MPa (about 255 HV).
  Laser tempering: soft tracks in a hard sheet.

Thermal properties: AISI 430 with the mean of the Eurocode stainless-steel laws used by
Wang et al. (conductivity 14.6 + 0.0127 θ, specific heat about 560 J/kg/K over the
cycle), the C–Mn steels with Lapouge et al.'s (28 W/m/K, 560 J/kg/K, 7860 kg/m³);
absorptivity 0.42 under argon (Wang et al. 2022), 200 W/m²/K on the faces (gas jets).
"""

from __future__ import annotations

import math
from dataclasses import dataclass, field, replace

import numpy as np

from morphogen.laser.heat import ThermalProperties
from morphogen.laser.metallurgy import (
    PeakHardening,
    PeakSoftening,
    Tempering,
    TransformationHardening,
    model_from_config,
)

#: Offset of the Ludwik law (keeps its initial slope finite).
LUDWIK_OFFSET = 1e-4
#: Kinds of flow laws: Ludwik's power law, Voce's saturating law, Swift's (Hollomon's law
#: from the yield stress).
LAWS = ("ludwik", "voce", "swift")


[docs] @dataclass(frozen=True) class FlowLaw: """True stress (MPa) of the equivalent plastic strain: ``ludwik``, ``σ0 + a((p + δ)^b − δ^b)`` (``a = K``, ``b = n``), ``voce``, ``σ0 + a(1 − exp(−b p))`` (``a = Q``, ``b`` the rate), or ``swift``, ``K (ε0 + p)^n`` (``a = K``, ``b = n``, ``ε0 = (σ0/K)^(1/n)``: Hollomon's ``σ = K ε^n`` from the yield stress ``σ0``, as Wang et al. 2023 for their phases).""" kind: str sigma0: float a: float b: float offset: float = LUDWIK_OFFSET def __post_init__(self): if self.kind not in LAWS: raise ValueError(f"flow law: one of {LAWS}") @property def code(self) -> int: """The index of the kind in the kernels.""" return LAWS.index(self.kind)
[docs] @classmethod def hollomon(cls, yield_strength: float, k: float, n: float) -> FlowLaw: """Hollomon's ``σ = K ε^n`` beyond the yield stress (a Swift law).""" return cls("swift", float(yield_strength), float(k), float(n))
[docs] def stress(self, p): p = np.asarray(p, dtype=float) if self.kind == "ludwik": d = self.offset return self.sigma0 + self.a * ((p + d) ** self.b - d**self.b) if self.kind == "swift": return self.a * ((self.sigma0 / self.a) ** (1.0 / self.b) + p) ** self.b return self.sigma0 + self.a * (1.0 - np.exp(-self.b * p))
[docs] def slope(self, p): p = np.asarray(p, dtype=float) if self.kind == "ludwik": return self.b * self.a * (p + self.offset) ** (self.b - 1.0) if self.kind == "swift": q = (self.sigma0 / self.a) ** (1.0 / self.b) + p return self.b * self.a * q ** (self.b - 1.0) return self.a * self.b * np.exp(-self.b * p)
[docs] @classmethod def from_tensile( cls, yield_strength: float, tensile_strength: float, uniform_elongation: float, young: float = 210000.0, ) -> FlowLaw: """The law of a tensile test (see the module): Considère at the uniform elongation.""" kind, s0, a, b = flow_parameters( yield_strength, tensile_strength, uniform_elongation, young=young ) return cls(LAWS[int(kind[0])], float(s0[0]), float(a[0]), float(b[0]))
[docs] def necking(self) -> tuple[float, float]: """True plastic strain at Considère's condition (rigid-plastic) and the engineering tensile strength of the law.""" lo, hi = 1e-7, 5.0 for _ in range(200): mid = 0.5 * (lo + hi) if self.slope(mid) > self.stress(mid): lo = mid else: hi = mid p = 0.5 * (lo + hi) return p, float(self.stress(p) * math.exp(-p))
def _bisect(fun, lo, hi, iterations: int = 60): """Vectorized bisection of a decreasing function on ``[lo, hi]``.""" lo, hi = lo.copy(), hi.copy() for _ in range(iterations): mid = 0.5 * (lo + hi) up = fun(mid) > 0 lo = np.where(up, mid, lo) hi = np.where(up, hi, mid) return 0.5 * (lo + hi)
[docs] def flow_parameters( yield_strength, tensile_strength, uniform_elongation, *, young: float = 210000.0, offset: float = LUDWIK_OFFSET, strict: bool = True, ): """Flow laws of tensile properties, vectorized: ``(kind, σ0, a, b)`` (kind 0: Ludwik, 1: Voce). The law gives the proof stress at a plastic strain of 0.2 %, ``σ(0.002) = R_p``, and at the true plastic strain ``p_u = ln(1 + A_g) − σ_u/E`` of the uniform elongation ``σ(p_u) = σ_u = R_m (1 + A_g)`` and ``dσ/dp = σ_u`` (Considère). Ludwik: ``K = σ_u (p_u + δ)^(1−n)/n``, ``n`` and ``σ0`` by nested bisections; where no exponent fits (a large ratio ``R_m/R_p`` at a small elongation, martensite), Voce: ``x/(e^x − 1) = σ_u p_u/(σ_u − σ0)`` with ``x = b p_u`` and ``Q = (σ_u − σ0)/(1 − e^(−x))``. ``strict``: raise on properties that no law fits (else their parameters are NaN).""" rp = np.atleast_1d(np.asarray(yield_strength, dtype=float)) rm = np.atleast_1d(np.asarray(tensile_strength, dtype=float)) ag = np.atleast_1d(np.asarray(uniform_elongation, dtype=float)) rp, rm, ag = (np.array(v, dtype=float) for v in np.broadcast_arrays(rp, rm, ag)) bad = (ag <= 0) | (rm * (1.0 + ag) <= rp) if strict and bad.any(): raise ValueError("tensile properties: A_g > 0 and R_m (1 + A_g) > R_p") ag = np.where(bad, 0.1, ag) rm = np.where(bad, 2.0 * rp, rm) su = rm * (1.0 + ag) pu = np.maximum(np.log1p(ag) - su / young, 1e-3) steep = su * (1.0 - pu) <= rp if strict and steep.any(): raise ValueError( "tensile properties: a hardening exponent above 1 (R_p too high " "for the strength and elongation)" ) bad |= steep d = float(offset) q = pu + d n_lo, n_hi = np.full_like(su, 1e-3), np.full_like(su, 1.0) def ludwik(s0): """Exponent, modulus and whether a root exists, for the initial stresses s0.""" f = lambda n: s0 + su / n * (q - d**n * q ** (1.0 - n)) - su # noqa: E731 ok = (f(n_lo) > 0) & (f(n_hi) < 0) n = _bisect(f, n_lo, n_hi) return n, su * q ** (1.0 - n) / n, ok def g_ludwik(s0): # the proof stress minus R_p: increasing in s0 n, k, ok = ludwik(s0) return np.where(ok, rp - (s0 + k * ((0.002 + d) ** n - d**n)), -1.0) s_lo, s_hi = 0.2 * rp, rp.copy() s0_l = _bisect(g_ludwik, s_lo, s_hi) n, k, ok = ludwik(s0_l) ok &= np.abs(g_ludwik(s0_l)) < 1e-6 * rp def voce(s0): r = su * pu / (su - s0) x = _bisect( lambda x: x / np.expm1(x) - r, np.full_like(su, 1e-6), np.full_like(su, 60.0), 80 ) return x / pu, (su - s0) / (-np.expm1(-x)) def g_voce(s0): b, qv = voce(s0) return rp - (s0 + qv * (-np.expm1(-b * 0.002))) s0_v = _bisect(g_voce, s_lo, s_hi) b_v, q_v = voce(s0_v) bad |= ~ok & (np.abs(g_voce(s0_v)) > 1e-3 * rp) if strict and bad.any(): raise ValueError("tensile properties: no Ludwik or Voce law fits them") kind = np.where(ok, 0, 1).astype(np.int8) out = [np.where(ok, s0_l, s0_v), np.where(ok, k, q_v), np.where(ok, n, b_v)] out = [np.where(bad, np.nan, v) for v in out] return (kind, *out)
[docs] @dataclass class StrengthTable: """Tensile properties against hardness: rows ``(HV, R_p, R_m, A_g)`` (MPa, MPa, engineering fraction), interpolated linearly, extrapolated by Pavlina & Van Tyne's slopes (see the module).""" rows: tuple def __post_init__(self): tab = np.asarray(self.rows, dtype=float).reshape(-1, 4) tab = tab[np.argsort(tab[:, 0])] if len(tab) < 1 or np.any(np.diff(tab[:, 0]) <= 0): raise ValueError("strength table: rows of distinct hardnesses") self.rows = tuple(map(tuple, tab)) self._t = tab
[docs] def properties(self, hv) -> tuple[np.ndarray, np.ndarray, np.ndarray]: """``R_p``, ``R_m`` and ``A_g`` of hardnesses (arrays).""" hv = np.asarray(hv, dtype=float) t = self._t if len(t) == 1: rp = t[0, 1] + 2.876 * (hv - t[0, 0]) rm = t[0, 2] + 3.734 * (hv - t[0, 0]) ag = np.full_like(hv, t[0, 3]) else: rp = np.interp(hv, t[:, 0], t[:, 1]) rm = np.interp(hv, t[:, 0], t[:, 2]) ag = np.interp(hv, t[:, 0], t[:, 3]) lo, hi = hv < t[0, 0], hv > t[-1, 0] rp = np.where(lo, t[0, 1] + 2.876 * (hv - t[0, 0]), rp) rm = np.where(lo, t[0, 2] + 3.734 * (hv - t[0, 0]), rm) rp = np.where(hi, t[-1, 1] + 2.876 * (hv - t[-1, 0]), rp) rm = np.where(hi, t[-1, 2] + 3.734 * (hv - t[-1, 0]), rm) slope = (t[-1, 3] - t[-2, 3]) / (t[-1, 0] - t[-2, 0]) ag = np.where(hi, t[-1, 3] + slope * (hv - t[-1, 0]), ag) ag = np.clip(ag, 0.02, 0.6) rp = np.maximum(rp, 50.0) rm = np.maximum(rm, 1.02 * rp / (1.0 + ag) + 1.0) return rp, rm, ag
[docs] def flow(self, hv, young: float = 210000.0) -> tuple: """Flow laws ``(kind, σ0, a, b)`` of hardnesses (see :func:`flow_parameters`), those of the nearest hardness of a grid of 0.5 HV (cached).""" hv = np.asarray(hv, dtype=float) key = float(young) cache = self.__dict__.setdefault("_flow_cache", {}) if key not in cache: lo = max(50.0, 0.6 * self._t[0, 0]) hi = max(1.6 * self._t[-1, 0], self._t[-1, 0] + 200.0) grid = np.arange(lo, hi + 1e-9, 0.5) params = flow_parameters(*self.properties(grid), young=young, strict=False) valid = np.isfinite(params[1]) if not valid.any(): raise ValueError("strength table: no flow law fits its properties") near = np.flatnonzero(valid)[ np.clip( np.searchsorted(np.flatnonzero(valid), np.arange(len(grid))), 0, valid.sum() - 1 ) ] cache[key] = (lo, tuple(v[near] for v in params)) lo, params = cache[key] i = np.clip(np.rint((hv - lo) / 0.5).astype(np.int64), 0, len(params[0]) - 1) return tuple(v[i] for v in params)
@classmethod def from_config(cls, data) -> StrengthTable: if isinstance(data, StrengthTable): return data return cls(tuple(tuple(row) for row in data))
_YLD_FITS: dict = {} def _yld2000_coefficients(material) -> tuple: """α1 ... α8 of the Yld2000-2d texture of a material (fitted once per data).""" from morphogen.laser.mechanics import yld2000_from_data a = material.anisotropy key = tuple( float(a[k]) if k in a else None for k in ("s0", "s45", "s90", "sb", "r0", "r45", "r90", "rb", "a") ) if key not in _YLD_FITS: missing = [k for k in ("s0", "s45", "s90", "sb", "r0", "r45", "r90") if k not in a] if missing: raise ValueError(f"anisotropy yld2000: give {missing}") _YLD_FITS[key] = yld2000_from_data( a["s0"], a["s45"], a["s90"], a["sb"], a["r0"], a["r45"], a["r90"], a.get("rb", a["r0"] / a["r90"]), a.get("a", 6.0), )[:8] return _YLD_FITS[key]
[docs] @dataclass class SheetMaterial: """A sheet: its thermal properties, its metallurgical response to the cycles of the tracks, its strength against hardness, its elasticity (MPa), its density (kg/m³), its usual thickness (mm) and absorptivity, its rolling texture (``anisotropy``: the Lankford coefficients ``{"r0", "r45", "r90"}`` of Hill's 1948 criterion, or with ``"criterion": "yld2000"`` the yield stresses ``"s0", "s45", "s90", "sb"`` and the coefficients ``"r0", "r45", "r90", "rb"`` of Barlat's Yld2000-2d and its exponent ``"a"``; the share ``"memory"`` of the texture the treated points keep; :meth:`yield_criterion`), the ``fracture`` of its hard points (``{"hardness": HV, "critical": plastic strain, "radius": mm}``: the points at least that hard break at that plastic strain, averaged over the radius; :class:`~morphogen.laser.mechanics.Fracture`) and the sources of the data.""" name: str thermal: ThermalProperties metallurgy: TransformationHardening | PeakHardening strength: StrengthTable young: float = 210000.0 poisson: float = 0.3 thickness: float = 1.0 absorptivity: float = 0.42 description: str = "" references: tuple = () extra: dict = field(default_factory=dict) fracture: dict | None = None anisotropy: dict | None = None
[docs] def yield_criterion(self, treated, angle: float = 0.0) -> np.ndarray: """The yield criterion of points of treated share ``treated``: Hill's 1948 (``(..., 5)``, :meth:`hill`) or, with ``anisotropy["criterion"] = "yld2000"``, Barlat's Yld2000-2d (``(..., 10)``: α1 ... α8 fitted to the data of the sheet, :func:`~morphogen.laser.mechanics.yld2000_from_data`, the exponent ``a``, 6 by default, and the angle of the rolling direction): the texture where untreated, the isotropic coefficients (α = 1, the same exponent) where the laser transformed the steel, or the share ``memory`` of the texture's departure from them, mixed in proportion between.""" a = self.anisotropy or {} if a.get("criterion", "hill48") == "hill48": return self.hill(treated, angle) if a["criterion"] != "yld2000": raise ValueError("anisotropy criterion: hill48 or yld2000") coef = np.asarray(_yld2000_coefficients(self), dtype=float) expo = float(a.get("a", 6.0)) t = np.clip(np.asarray(treated, dtype=float), 0.0, 1.0)[..., None] treated_coef = 1.0 + float(a.get("memory", 0.0)) * (coef - 1.0) al = (1.0 - t) * coef + t * treated_coef tail = np.empty((*al.shape[:-1], 2)) tail[..., 0] = expo tail[..., 1] = np.radians(angle) return np.concatenate([al, tail], axis=-1)
[docs] def hill(self, treated, angle: float = 0.0) -> np.ndarray: """Hill's 1948 coefficients and the angle of the rolling direction of points of treated share ``treated`` (``(..., 5)``, see :func:`~morphogen.laser.mechanics.hill_from_r`): the sheet's texture (``anisotropy``: ``{"r0", "r45", "r90"}``, the Lankford coefficients of the rolled sheet) where it is untreated; where the laser transformed it, isotropic (the new phases form with a weak texture) or, with ``"memory"`` ``m`` in ``anisotropy``, the isotropic coefficients plus ``m`` times the texture's departure from them (1: the texture inherited whole, as when the treatment only dissolves precipitates); mixed in proportion between; the rolling direction at ``angle`` degrees from the axis of the specimen.""" from morphogen.laser.mechanics import ISOTROPIC, hill_from_r t = np.clip(np.asarray(treated, dtype=float), 0.0, 1.0)[..., None] iso = np.asarray(ISOTROPIC[:4]) if not self.anisotropy: base = treated_coef = iso else: a = self.anisotropy base = np.asarray(hill_from_r(a["r0"], a["r45"], a["r90"])[:4]) treated_coef = iso + float(a.get("memory", 0.0)) * (base - iso) coef = (1.0 - t) * base + t * treated_coef ang = np.full((*coef.shape[:-1], 1), np.radians(angle)) return np.concatenate([coef, ang], axis=-1)
[docs] def critical_strain(self, hardness): """The critical plastic strain of points of the given hardness (None: ductile sheet): ``fracture["hardness"]`` and ``["critical"]`` are a threshold and its strain, or tables between which the brittleness (the inverse of the critical strain) varies linearly (a partly transformed zone is less brittle).""" if not self.fracture: return None hv = np.asarray(hardness, dtype=float) h = np.atleast_1d(np.asarray(self.fracture["hardness"], dtype=float)) c = np.atleast_1d(np.asarray(self.fracture["critical"], dtype=float)) if h.size == 1: return np.where(hv >= h[0], c[0], np.inf) with np.errstate(divide="ignore"): brittle = np.interp(hv, h, 1.0 / c, left=0.0) return np.where(brittle > 0, 1.0 / np.where(brittle > 0, brittle, 1.0), np.inf)
@property def density(self) -> float: return self.thermal.density @property def base_hardness(self) -> float: """Hardness of the untreated sheet.""" m = self.metallurgy return float(m.hardness(m.initial_state(1))[0])
[docs] def with_(self, **changes) -> SheetMaterial: return replace(self, **changes)
[docs] @classmethod def from_config(cls, data) -> SheetMaterial: """A preset name, or a mapping: ``preset`` (optional, the defaults) and any of the fields (``thermal``, ``metallurgy`` with its ``kind``, ``strength`` rows...).""" if isinstance(data, SheetMaterial): return data if isinstance(data, str): return sheet_material(data) data = dict(data) base = sheet_material(data.pop("preset")) if "preset" in data else None if "thermal" in data: th = data["thermal"] if base is not None and isinstance(th, dict): th = replace(base.thermal, **th) data["thermal"] = ThermalProperties.from_config(th) if "metallurgy" in data: met = data["metallurgy"] if base is not None and isinstance(met, dict) and "kind" not in met: kind = ( "softening" if isinstance(base.metallurgy, PeakSoftening) else "peak" if isinstance(base.metallurgy, PeakHardening) else "transformation" ) params = { k: getattr(base.metallurgy, k) for k in type(base.metallurgy).__dataclass_fields__ } params.update(met) met = {"kind": kind, **params} data["metallurgy"] = model_from_config(met) if "strength" in data: data["strength"] = StrengthTable.from_config(data["strength"]) if base is not None: return replace(base, **data) missing = {"name", "thermal", "metallurgy", "strength"} - set(data) if missing: raise ValueError(f"material: missing {sorted(missing)} (or give a preset)") return cls(**data)
def _aisi430() -> SheetMaterial: return SheetMaterial( name="aisi430", thermal=ThermalProperties( conductivity=23.5, density=7700.0, heat_capacity=560.0, convection=200.0 ), metallurgy=PeakHardening( table=((875.0, 0.0), (1082.0, 40.0), (1300.0, 110.0), (1425.0, 150.0), (1700.0, 150.0)), base_hardness=160.0, solidus=1425.0, composition={"C": 0.026, "Si": 0.30, "Mn": 0.50, "Cr": 18.7, "Ni": 0.14}, carbon_hardening=560.0, tempering=Tempering(start=8300.0, end=26800.0, floor=0.0), ), strength=StrengthTable( ( (160.0, 346.0, 502.9, 0.1939), (211.5, 488.7, 623.5, 0.1552), (241.8, 539.7, 702.5, 0.1365), (370.0, 657.0, 930.0, 0.10), ) ), thickness=0.5, absorptivity=0.42, description="ferritic stainless steel AISI 430 (18.7 Cr), hardened by martensite " "and Cr carbides near its melting point; carburized from a graphite coating", references=( "Wang, Dirrenberger, Lapouge, Dubent (2022) Mater. Sci. Eng. A 831, 142205", "Wang et al. (2022) J. Eng. Mater. Technol. 144, 041005", "Wang (2022) PhD thesis, HESAM Université (ENSAM, PIMM)", ), ) def _annealed_ms1500() -> SheetMaterial: comp = {"C": 0.228, "Si": 0.242, "Mn": 1.730, "Cr": 0.190} return SheetMaterial( name="annealed_ms1500", thermal=ThermalProperties( conductivity=28.0, density=7860.0, heat_capacity=560.0, convection=200.0 ), metallurgy=TransformationHardening( composition=comp, superheat=50.0, solidus=1480.0, martensite=0.0, matrix_hardness=167.0, critical_time=3.0, slow_time=30.0, tempering=Tempering(constant=20.0, start=9000.0, end=20000.0, floor=0.0, minimum=190.0), ), # the martensite of the tracks: Hollomon's law identified by Wang et al. (2023, # K 1966 MPa, n 0.06), uniform elongation from Considère (the 0.036 of the bulk # martensite tested alone is its fracture, which the matrix delays) strength=StrengthTable( ( (167.0, 300.0, 534.0, 0.167), (480.0, 1300.0, 1560.0, 0.062), ) ), thickness=1.0, absorptivity=0.42, description="MS1500EZ annealed at 850 °C for 1 h (ferrite-pearlite, 0.23 C, 1.7 Mn), " "hardened by laser tracks of martensite", references=( "Wang, Bouaziz, Dirrenberger, Lapouge (2023) steel res. int. 94, 2200695", "Lapouge et al. (2019) Mater. Sci. Eng. A 752, 128-135", "Maynier, Jungmann, Dollet (1978) Hardenability concepts with applications to " "steel, AIME, 518-545", ), ) def _dp1180() -> SheetMaterial: comp = {"C": 0.15, "Si": 0.2, "Mn": 1.8} return SheetMaterial( name="dp1180", thermal=ThermalProperties( conductivity=28.0, density=7860.0, heat_capacity=560.0, convection=200.0 ), metallurgy=TransformationHardening( composition=comp, ac1=727.0, ac3=827.0, superheat=50.0, solidus=1480.0, martensite=0.85, martensite_hardness=420.0, matrix_hardness=165.0, critical_time=3.0, slow_time=30.0, tempering=Tempering(constant=20.0, start=9000.0, end=20000.0, floor=0.0, minimum=200.0), ), strength=StrengthTable( ( (165.0, 300.0, 480.0, 0.20), (255.0, 600.0, 816.0, 0.08), (380.0, 850.0, 1200.0, 0.05), (480.0, 1300.0, 1600.0, 0.04), ) ), thickness=1.0, absorptivity=0.42, description="dual-phase DP1180 (85 % martensite), softened by laser tempering", references=("Lapouge et al. (2019) Mater. Sci. Eng. A 752, 128-135",), ) def _22mnb5() -> SheetMaterial: comp = {"C": 0.22, "Si": 0.25, "Mn": 1.25, "Cr": 0.2} return SheetMaterial( name="22mnb5", thermal=ThermalProperties( conductivity=34.0, density=7850.0, heat_capacity=650.0, convection=200.0 ), metallurgy=TransformationHardening( composition=comp, superheat=50.0, solidus=1480.0, martensite=0.0, matrix_hardness=185.0, critical_time=3.0, slow_time=30.0, tempering=Tempering(constant=20.0, start=9000.0, end=20000.0, floor=0.0, minimum=200.0), ), # as delivered (75 % ferrite, 25 % pearlite: R_p about 400, R_m 450-550 MPa, # uniform elongation 18 %) and quenched (martensite up to 605 HV10, R_m # 1590-1600 MPa; its uniform elongation 3.25 % measured alone, 0.06 from # Considère as for the annealed MS1500): Karbasian & Tekkaya (2010), Merklein et # al. (2006) strength=StrengthTable( ( (185.0, 400.0, 520.0, 0.18), (550.0, 1150.0, 1590.0, 0.06), ) ), thickness=1.5, absorptivity=0.4, description="boron steel 22MnB5 as delivered (ferrite and pearlite), hardened by " "laser tracks of martensite (the steel of hot stamping; laser-patterned tubes of " "Kim & Yoon 2021)", references=( "Karbasian H., Tekkaya A.E. (2010) J. Mater. Process. Technol. 210, 2103-2118", "Kim H.-g., Yoon J. (2021) Compos. Struct. 262, 113633", ), ) def _aa6082_t6() -> SheetMaterial: return SheetMaterial( name="aa6082_t6", thermal=ThermalProperties( conductivity=170.0, density=2700.0, heat_capacity=950.0, convection=200.0 ), # T6 (105 HV); overaged near 350-400 °C (about 60 HV, no ageing again); # dissolved above about 480 °C then naturally aged (55 HV just after, about # 80 HV after days): Piccininni & Palumbo (2020), Myhr & Grong (1991) metallurgy=PeakSoftening( base_hardness=105.0, solidus=585.0, table=( (200.0, 0.0), (250.0, -8.0), (300.0, -25.0), (350.0, -40.0), (400.0, -45.0), (450.0, -38.0), (500.0, -25.0), (600.0, -25.0), ), ), # the solution-treated state just after the laser (yield about 70 MPa), the # naturally aged one (T4-like) and T6 strength=StrengthTable( ( (55.0, 70.0, 170.0, 0.20), (80.0, 150.0, 240.0, 0.15), (105.0, 290.0, 330.0, 0.07), ) ), young=70000.0, poisson=0.33, thickness=1.0, absorptivity=0.3, description="age-hardened aluminium alloy AA6082-T6 softened by laser tracks " "(the precipitates dissolved above about 250 °C; tailor heat-treated blanks)", references=( "Piccininni A., Palumbo G. (2020) Materials 13, 1576", "Myhr O.R., Grong O. (1991) Acta Metall. Mater. 39, 2693-2702", ), ) #: The materials of the PIMM studies (see the module) and alternative ones. PRESETS = { "aisi430": _aisi430, "annealed_ms1500": _annealed_ms1500, "dp1180": _dp1180, "22mnb5": _22mnb5, "aa6082_t6": _aa6082_t6, }
[docs] def sheet_material(name: str) -> SheetMaterial: """A preset material (:data:`PRESETS`).""" if name not in PRESETS: raise ValueError(f"material: one of {sorted(PRESETS)}, got {name!r}") return PRESETS[name]()