compositecalc/interface/kapitza.py

"""Kapitza resistance (interfacial thermal resistance) correction.

Corrects the effective filler property P_f for the thermal resistance at
the filler-matrix interface, yielding an apparent filler property P_f_eff
that can be substituted into any EMT model (Maxwell-Garnett, Bruggeman,
Mori-Tanaka, etc.) without modification.

Physical picture
----------------
When a filler particle is coated by an atomically thin resistance layer
(Kapitza resistance, R_K), the heat flux across the interface is limited by
the conductance h = 1/R_K.  The effect is captured by replacing k_f with a
smaller "apparent" conductivity k_f_eff before entering the EMT formula.
For nanoscale particles (small a) the correction is large because the
surface-to-volume ratio 3/a is high.

References
----------
Nan, C.-W., Birringer, R., Clarke, D.R., & Gleiter, H. (1997).
    Effective thermal conductivity of particulate composites with interfacial
    thermal resistance.  *J. Appl. Phys.*, 81(10), 6692–6699.
Hasselman, D.P.H. & Johnson, L.F. (1987).
    Effective thermal conductivity of composites with interfacial thermal
    barrier resistance.  *J. Composite Mater.*, 21(6), 508–515.
"""

from __future__ import annotations

import numpy as np

__all__ = ["kapitza_correction"]


def kapitza_correction(
    P_f: float | np.ndarray,
    P_m: float | np.ndarray,
    R_K: float | np.ndarray,
    radius: float | np.ndarray,
    L: float | np.ndarray,
) -> float | np.ndarray:
    """Effective filler property corrected for Kapitza interfacial resistance.

    Computes the apparent filler property P_f_eff that, when substituted
    into any effective medium theory formula, accounts for the interfacial
    resistance R_K between filler and matrix.

    Parameters
    ----------
    P_f : float or np.ndarray
        Intrinsic filler property (e.g. thermal conductivity in W/(m·K),
        or electrical conductivity in S/m, etc.).
    P_m : float or np.ndarray
        Matrix property (same units as P_f).  Included to match the Nan
        (1997) notation; it cancels analytically in the final expression.
    R_K : float or np.ndarray
        Kapitza (interfacial) resistance (m²·K/W for thermal conductivity;
        more generally m² per [P unit]).  R_K = 0 recovers P_f unchanged.
        Must be non-negative.
    radius : float or np.ndarray
        Characteristic particle semi-axis length relevant to the axis with
        depolarization factor L (SI units: m).  Must be positive.
    L : float or np.ndarray
        Depolarization factor along the axis of interest.  For a sphere
        use L = 1/3; for the long axis of a prolate fibre use L_a < 1/3.

    Returns
    -------
    P_f_eff : float or np.ndarray
        Effective filler property after interfacial resistance correction.
        Always P_f_eff ≤ P_f (resistance only reduces effective conductivity).

    Raises
    ------
    ValueError
        If *radius* ≤ 0 or *R_K* < 0.

    Notes
    -----
    From Nan et al. (1997) eqs. (4)–(6):

    .. math::

        \\gamma = \\frac{2 R_K P_m}{a}, \\qquad
        P_f^{c} = \\frac{P_f}{1 + \\gamma L P_f / P_m}

    Since :math:`P_m` appears in both :math:`\\gamma` and :math:`P_f/P_m`
    it cancels analytically:

    .. math::

        P_f^{c} = \\frac{P_f}{1 + 2 R_K L P_f / a}

    References
    ----------
    Nan, C.-W., Birringer, R., Clarke, D.R., & Gleiter, H. (1997).
        *J. Appl. Phys.*, 81(10), 6692.

    Examples
    --------
    >>> kapitza_correction(10.0, 1.0, 0.0, 1e-9, 1 / 3)  # R_K=0 → unchanged
    10.0
    >>> # Sphere: L = 1/3, r = 100 nm, R_K = 10 nm·K/W (=1e-8 m²·K/W)
    >>> kapitza_correction(10.0, 1.0, 1e-8, 100e-9, 1 / 3)
    6.0
    """
    P_f = np.asarray(P_f, dtype=float)
    P_m = np.asarray(P_m, dtype=float)
    R_K = np.asarray(R_K, dtype=float)
    radius = np.asarray(radius, dtype=float)
    L = np.asarray(L, dtype=float)

    if np.any(radius <= 0):
        raise ValueError("radius must be positive.")
    if np.any(R_K < 0):
        raise ValueError("R_K must be non-negative.")

    # gamma * L * P_f / P_m = (2*R_K*P_m/radius) * L * P_f / P_m
    #                        = 2*R_K*L*P_f / radius   (P_m cancels)
    result = P_f / (1.0 + 2.0 * R_K * L * P_f / radius)

    return float(result) if result.ndim == 0 else result