chemistrykit 0.1.0__py3-none-any.whl

chemistrykit/__init__.py

@@ -0,0 +1,69 @@
+"""chemistrykit: unified numerical toolkit for computational chemistry.
+
+Import as ``ck`` by convention::
+
+    import chemistrykit as ck
+    ck.kinetics.FirstOrder(k=0.1, C0=1.0)
+    ck.kinetics.StoichiometricNetwork.consecutive(k1=1.0, k2=0.3)
+    ck.thermo.VanDerWaals(a=0.1448, b=3.913e-5)
+    ck.solutions.WeakAcid(Ca=0.1, Ka=1.8e-5).pH()
+    ck.md.LJFluid.from_lattice(n_per_side=4, density=0.6, temperature=1.0)
+    ck.statmech.MaxwellBoltzmannSpeedDistribution(mass=6.63e-26, temperature=298.15)
+    ck.structure.determine_point_group(water_molecule)
+    ck.spectro.rotational_spectrum(rotor, J_max=10, temperature=300.0)
+    ck.electrochem.nernst_potential(E_standard=0.34, n=2, Q=0.01)
+    ck.photochem.jablonski_network(kf=2.0, kic=1.0, kisc=0.5, kp=0.3, kic_T=0.2)
+    ck.surface.LangmuirIsotherm(K=2.0, qmax=5.0).loading(P=1.0)
+    ck.polymer.IdealChain().end_to_end_distance(n=1000, b=0.5)
+    ck.crystal.FaceCenteredCubicPacking().packing_fraction()
+    ck.analytical.fit_calibration([0, 1, 2, 3], [0.1, 1.0, 2.1, 2.9]).lod()
+    ck.constants.R
+    ck.integrators.rk4_integrate(...)
+
+chemistrykit mirrors the architecture of the sibling project physicskit
+(pk): one subpackage per chemistry domain, sharing common ODE integrators
+(:mod:`chemistrykit.integrators`) and physical/chemical constants
+(:mod:`chemistrykit.constants`). All 14 domains from
+``chemistrykit-spec.md``'s build plan are implemented; see ``__all__``
+below for the full list.
+"""
+
+from chemistrykit import (
+    analytical,
+    constants,
+    crystal,
+    electrochem,
+    integrators,
+    kinetics,
+    md,
+    photochem,
+    polymer,
+    quantum,
+    solutions,
+    spectro,
+    statmech,
+    structure,
+    surface,
+    thermo,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "constants",
+    "integrators",
+    "kinetics",
+    "thermo",
+    "solutions",
+    "md",
+    "statmech",
+    "quantum",
+    "spectro",
+    "structure",
+    "electrochem",
+    "photochem",
+    "surface",
+    "polymer",
+    "crystal",
+    "analytical",
+]

chemistrykit/analytical/__init__.py

@@ -0,0 +1,61 @@
+"""chemistrykit.analytical: analytical chemistry.
+
+Acid-base titration curves are provided by
+:mod:`chemistrykit.solutions.systems.titration`; this subpackage adds
+redox and complexometric (EDTA) titration-curve simulation with
+equivalence-point detection; chromatographic plate theory and the van
+Deemter equation (resolution, selectivity); linear-regression calibration
+curves with IUPAC-convention limits of detection/quantitation; and
+propagation-of-uncertainty formulas plus Dixon's Q-test for outlier
+rejection.
+"""
+
+__version__ = "0.1.0"
+
+from chemistrykit.analytical.core.base_system import TitrationCurve, TitrationCurveResult
+from chemistrykit.analytical.systems.calibration import LinearCalibration, fit_calibration
+from chemistrykit.analytical.systems.chromatography import (
+    minimum_plate_height,
+    optimum_flow_velocity,
+    plate_height,
+    resolution,
+    retention_factor,
+    selectivity_factor,
+    simulate_chromatogram,
+    theoretical_plates,
+    van_deemter_H,
+)
+from chemistrykit.analytical.systems.qtest import Q_CRITICAL_TABLE, QTestResult, dixon_q_test
+from chemistrykit.analytical.systems.titration import EDTATitration, RedoxTitration
+from chemistrykit.analytical.systems.uncertainty import (
+    propagate_power,
+    propagate_product,
+    propagate_sum,
+    propagate_uncertainty,
+)
+
+__all__ = [
+    "__version__",
+    "TitrationCurve",
+    "TitrationCurveResult",
+    "RedoxTitration",
+    "EDTATitration",
+    "theoretical_plates",
+    "plate_height",
+    "van_deemter_H",
+    "optimum_flow_velocity",
+    "minimum_plate_height",
+    "retention_factor",
+    "selectivity_factor",
+    "resolution",
+    "simulate_chromatogram",
+    "LinearCalibration",
+    "fit_calibration",
+    "propagate_sum",
+    "propagate_product",
+    "propagate_power",
+    "propagate_uncertainty",
+    "Q_CRITICAL_TABLE",
+    "QTestResult",
+    "dixon_q_test",
+]

chemistrykit/analytical/core/base_system.py

@@ -0,0 +1,118 @@
+r"""Abstract base class for potentiometric-style titration-curve models, and a note on scope.
+
+:class:`TitrationCurve` captures the one genuinely polymorphic shape in
+this domain: several titration *types* (redox, complexometric --
+:mod:`chemistrykit.analytical.systems.titration`) that all reduce to
+"compute some scalar response as a function of titrant volume, then find
+the equivalence point as the point of steepest response change" -- the
+same shape that :class:`chemistrykit.solutions.core.base_system.Titration`
+already captures for acid-base titrations (pH vs. volume).
+
+**Why a new ABC here, rather than reusing** :class:`chemistrykit.solutions.core.base_system.Titration`:
+that class's abstract method is named and documented specifically as
+``pH_at`` (a *hydrogen-ion* activity readout), which is the wrong
+abstraction for a redox titration's electrode potential `E` or a
+complexometric titration's `pM`. Rather than force those into a
+pH-flavored interface (or reach across a domain boundary the way
+``chemistrykit.photochem`` reaches into ``chemistrykit.kinetics`` for
+substantial shared machinery -- not warranted here, since the shared
+logic is a handful of lines), :class:`TitrationCurve` reimplements the
+same small pattern (curve, steepest-ascent-or-descent equivalence-point
+detection) with a response-type-neutral abstract method name, exactly
+the way :mod:`chemistrykit.surface.utils.regression`,
+:mod:`chemistrykit.electrochem.utils.regression`, and
+:mod:`chemistrykit.photochem.utils.regression` each keep their own small
+``linear_fit`` rather than importing one another's. Acid-base titration
+curves are *not* reimplemented here at all -- :mod:`chemistrykit.analytical`'s
+examples and tests use
+:mod:`chemistrykit.solutions.systems.titration`'s classes directly for
+that case, side by side with the new redox/complexometric models below.
+
+Chromatography (:mod:`chemistrykit.analytical.systems.chromatography`),
+calibration curves (:mod:`chemistrykit.analytical.systems.calibration`),
+uncertainty propagation (:mod:`chemistrykit.analytical.systems.uncertainty`),
+and the Q-test (:mod:`chemistrykit.analytical.systems.qtest`) are each a
+self-contained set of formulas with no swappable sibling, so -- following
+``chemistrykit.electrochem``/``chemistrykit.photochem``/``chemistrykit.surface``'s
+precedent -- they stay as plain functions (plus small result dataclasses)
+in their own ``systems/`` modules.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+import numpy as np
+
+__all__ = ["TitrationCurveResult", "TitrationCurve"]
+
+
+@dataclass
+class TitrationCurveResult:
+    """Container for the output of a :meth:`TitrationCurve.curve` call."""
+
+    V: np.ndarray
+    """ndarray: Volume(s) of titrant added, in L (or any consistent volume unit)."""
+
+    response: np.ndarray
+    """ndarray: The titration's response variable at each volume in `V`
+    (e.g. electrode potential `E` in volts, or `pM`)."""
+
+
+class TitrationCurve(ABC):
+    """Common base for a potentiometric titration-curve model whose response is not pH.
+
+    Concrete subclasses implement :meth:`response_at`; :meth:`curve` and
+    :meth:`find_equivalence_point` are then available for free, mirroring
+    :meth:`chemistrykit.solutions.core.base_system.Titration.curve`/
+    :meth:`~chemistrykit.solutions.core.base_system.Titration.find_equivalence_point`.
+    """
+
+    @abstractmethod
+    def response_at(self, V: np.ndarray) -> np.ndarray:
+        """Return the titration's response variable at each titrant volume in `V`.
+
+        Parameters
+        ----------
+        V : ndarray
+            Volume(s) of titrant added, in L.
+
+        Returns
+        -------
+        ndarray
+        """
+
+    def curve(self, V) -> TitrationCurveResult:
+        """Compute the full titration curve over a range of titrant volumes.
+
+        Parameters
+        ----------
+        V : array-like of float
+            Volumes of titrant added, in L.
+
+        Returns
+        -------
+        TitrationCurveResult
+        """
+        V = np.atleast_1d(np.asarray(V, dtype=np.float64))
+        response = np.asarray(self.response_at(V), dtype=np.float64)
+        return TitrationCurveResult(V=V, response=response)
+
+    def find_equivalence_point(self, V) -> float:
+        r"""Numerically locate the equivalence point as the point of steepest response change.
+
+        Parameters
+        ----------
+        V : array-like of float
+            A sufficiently fine grid of titrant volumes spanning the
+            equivalence point, in L.
+
+        Returns
+        -------
+        float
+        """
+        result = self.curve(V)
+        d_response_dV = np.gradient(result.response, result.V)
+        idx = int(np.argmax(np.abs(d_response_dV)))
+        return float(result.V[idx])

chemistrykit/analytical/systems/calibration.py

@@ -0,0 +1,131 @@
+r"""Linear-regression calibration curves, and IUPAC-convention limits of detection/quantitation.
+
+See Harris, *Quantitative Chemical Analysis*, 9th ed., Ch. 4.5 ("Method
+Validation") and Ch. 5, or the IUPAC recommendation (G. L. Long & J. D.
+Winefordner, *Anal. Chem.* 55, 712A (1983)), for the standard :math:`3.3
+\sigma/m` (LOD) and :math:`10\sigma/m` (LOQ) convention, with `sigma` the
+calibration curve's residual standard error and `m` its slope.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from chemistrykit.analytical.utils.regression import linear_fit
+
+__all__ = ["LinearCalibration", "fit_calibration"]
+
+#: float: IUPAC LOD multiplier (Long & Winefordner, 1983).
+_LOD_MULTIPLIER = 3.3
+
+#: float: IUPAC LOQ multiplier (Long & Winefordner, 1983).
+_LOQ_MULTIPLIER = 10.0
+
+
+@dataclass
+class LinearCalibration:
+    """A fitted instrument-response-vs-concentration calibration curve, ``signal = slope*conc + intercept``."""
+
+    slope: float
+    """float: Sensitivity, signal units per concentration unit."""
+
+    intercept: float
+    """float: Signal at zero concentration (ideally the blank signal)."""
+
+    r_squared: float
+    """float: Coefficient of determination of the fit."""
+
+    residual_std_error: float
+    """float: :math:`s_{y/x}`, the residual standard error about the fit
+    (Harris, *Quantitative Chemical Analysis*, 9th ed., Ch. 4.5)."""
+
+    def predict_signal(self, concentration):
+        """Predict the instrument signal at given concentration(s).
+
+        Parameters
+        ----------
+        concentration : float or array-like of float
+
+        Returns
+        -------
+        float or ndarray
+        """
+        c = np.asarray(concentration, dtype=np.float64)
+        result = self.slope * c + self.intercept
+        return float(result) if result.ndim == 0 else result
+
+    def predict_concentration(self, signal):
+        r"""Invert the calibration to estimate concentration from a measured signal.
+
+        .. math::
+
+            \hat c = (y_{measured} - b)/m
+
+        Parameters
+        ----------
+        signal : float or array-like of float
+
+        Returns
+        -------
+        float or ndarray
+        """
+        y = np.asarray(signal, dtype=np.float64)
+        result = (y - self.intercept) / self.slope
+        return float(result) if result.ndim == 0 else result
+
+    def lod(self) -> float:
+        r"""Limit of detection, :math:`\text{LOD}=3.3\,s_{y/x}/|m|` (IUPAC convention).
+
+        Returns
+        -------
+        float
+        """
+        return _LOD_MULTIPLIER * self.residual_std_error / abs(self.slope)
+
+    def loq(self) -> float:
+        r"""Limit of quantitation, :math:`\text{LOQ}=10\,s_{y/x}/|m|` (IUPAC convention).
+
+        Returns
+        -------
+        float
+        """
+        return _LOQ_MULTIPLIER * self.residual_std_error / abs(self.slope)
+
+
+def fit_calibration(concentration, signal) -> LinearCalibration:
+    r"""Fit a linear calibration curve (signal vs. concentration) by ordinary least squares.
+
+    Parameters
+    ----------
+    concentration : array-like of float
+        Known standard concentrations (at least 3 distinct values, so the
+        residual standard error is defined).
+    signal : array-like of float
+        Corresponding measured instrument signals.
+
+    Returns
+    -------
+    LinearCalibration
+
+    Examples
+    --------
+    LOQ is always exactly :math:`10/3.3` times LOD, by definition,
+    regardless of the data:
+
+    >>> conc = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0]
+    >>> signal = [0.02, 1.05, 1.98, 3.10, 3.95, 5.08]
+    >>> cal = fit_calibration(conc, signal)
+    >>> round(cal.loq() / cal.lod(), 6) == round(10.0 / 3.3, 6)
+    True
+
+    A perfect (noiseless) calibration has zero residual error and hence
+    zero LOD/LOQ:
+
+    >>> cal_perfect = fit_calibration([0.0, 1.0, 2.0, 3.0], [1.0, 3.0, 5.0, 7.0])
+    >>> cal_perfect.lod() < 1e-9
+    True
+    """
+    fit = linear_fit(concentration, signal)
+    return LinearCalibration(slope=fit.slope, intercept=fit.intercept, r_squared=fit.r_squared, residual_std_error=fit.residual_std_error)

chemistrykit/analytical/systems/chromatography.py

@@ -0,0 +1,317 @@
+r"""Chromatographic plate theory: theoretical plates, the van Deemter equation, resolution, and selectivity.
+
+See Harris, *Quantitative Chemical Analysis*, 9th ed., Ch. 23 ("An
+Introduction to Chromatographic Separations"), or Skoog, West, Holler &
+Crouch, *Fundamentals of Analytical Chemistry*, 9th ed., Ch. 26,
+throughout.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from chemistrykit.spectro.utils.lineshapes import gaussian
+
+__all__ = [
+    "theoretical_plates",
+    "plate_height",
+    "van_deemter_H",
+    "optimum_flow_velocity",
+    "minimum_plate_height",
+    "retention_factor",
+    "selectivity_factor",
+    "resolution",
+    "simulate_chromatogram",
+]
+
+
+def theoretical_plates(retention_time: float, peak_width: float, width_type: str = "base"):
+    r"""Number of theoretical plates `N` from a peak's retention time and width.
+
+    For a Gaussian elution peak (Harris, *Quantitative Chemical
+    Analysis*, 9th ed., eq. 23.19-23.20):
+
+    .. math::
+
+        N = 16\left(\frac{t_R}{w_{base}}\right)^2 = 5.545\left(\frac{t_R}{w_{1/2}}\right)^2
+
+    where :math:`w_{base}` is the width at the peak base (tangents to the
+    inflection points) and :math:`w_{1/2}` is the full width at half
+    maximum -- the numeric prefactor differs only because a Gaussian's
+    base width (4 standard deviations) and FWHM
+    (:math:`2\sqrt{2\ln2}\,\sigma`) are different multiples of `sigma`.
+
+    Parameters
+    ----------
+    retention_time : float or array-like of float
+        Peak retention time :math:`t_R`.
+    peak_width : float or array-like of float
+        Peak width, in the same units as `retention_time`, of the type
+        selected by `width_type`.
+    width_type : {"base", "half_height"}, default "base"
+
+    Returns
+    -------
+    float or ndarray
+
+    Examples
+    --------
+    A peak eluting at 10.0 min with a 0.5 min base width:
+
+    >>> round(float(theoretical_plates(10.0, 0.5, width_type="base")), 1)
+    6400.0
+
+    The two width conventions must agree for a Gaussian peak of
+    consistent shape (base width = 4 sigma, FWHM =
+    :math:`2\sqrt{2\ln2}\,\sigma\approx2.3548\sigma`):
+
+    >>> sigma = 0.125
+    >>> N_base = theoretical_plates(10.0, 4.0 * sigma, width_type="base")
+    >>> N_half = theoretical_plates(10.0, 2.3548 * sigma, width_type="half_height")
+    >>> bool(abs(N_base - N_half) / N_base < 1e-3)
+    True
+    """
+    tR = np.asarray(retention_time, dtype=np.float64)
+    w = np.asarray(peak_width, dtype=np.float64)
+    if width_type == "base":
+        result = 16.0 * (tR / w) ** 2
+    elif width_type == "half_height":
+        result = 5.545 * (tR / w) ** 2
+    else:
+        raise ValueError('width_type must be "base" or "half_height"')
+    return float(result) if result.ndim == 0 else result
+
+
+def plate_height(column_length: float, N):
+    r"""Plate height (HETP) :math:`H=L/N`, the column length per theoretical plate.
+
+    Parameters
+    ----------
+    column_length : float
+        Column length `L`, e.g. in cm.
+    N : float or array-like of float
+        Number of theoretical plates.
+
+    Returns
+    -------
+    float or ndarray
+
+    Examples
+    --------
+    >>> round(float(plate_height(column_length=25.0, N=6400.0)), 6)
+    0.003906
+    """
+    N = np.asarray(N, dtype=np.float64)
+    result = column_length / N
+    return float(result) if result.ndim == 0 else result
+
+
+def van_deemter_H(u, A: float, B: float, C: float):
+    r"""The van Deemter equation: plate height `H` as a function of mobile-phase linear velocity `u`.
+
+    .. math::
+
+        H = A + \frac{B}{u} + Cu
+
+    with `A` the eddy-diffusion term (velocity-independent band
+    broadening from unequal flow paths), `B` the longitudinal-molecular-
+    diffusion term (dominant at low `u`), and `C` the mass-transfer-
+    resistance term (dominant at high `u`) (J. J. van Deemter, F. J.
+    Zuiderweg, A. Klinkenberg, *Chem. Eng. Sci.* 5, 271 (1956); Harris,
+    *Quantitative Chemical Analysis*, 9th ed., Ch. 23.4).
+
+    Parameters
+    ----------
+    u : float or array-like of float
+        Mobile-phase linear velocity.
+    A, B, C : float
+        Van Deemter coefficients (all non-negative for a physical column).
+
+    Returns
+    -------
+    float or ndarray
+
+    Examples
+    --------
+    >>> round(float(van_deemter_H(u=2.0, A=1.0, B=2.0, C=0.05)), 4)
+    2.1
+    """
+    u = np.asarray(u, dtype=np.float64)
+    result = A + B / u + C * u
+    return float(result) if result.ndim == 0 else result
+
+
+def optimum_flow_velocity(B: float, C: float) -> float:
+    r"""The flow velocity :math:`u_{opt}=\sqrt{B/C}` minimizing the van Deemter equation.
+
+    Found by :math:`dH/du=-B/u^2+C=0` (Harris, *Quantitative Chemical
+    Analysis*, 9th ed., Ch. 23.4).
+
+    Parameters
+    ----------
+    B, C : float
+        Van Deemter longitudinal-diffusion and mass-transfer coefficients.
+
+    Returns
+    -------
+    float
+
+    Examples
+    --------
+    >>> round(optimum_flow_velocity(B=2.0, C=0.05), 6)
+    6.324555
+    """
+    return float(np.sqrt(B / C))
+
+
+def minimum_plate_height(A: float, B: float, C: float) -> float:
+    r"""The minimum plate height :math:`H_{min}=A+2\sqrt{BC}`, at the optimum flow velocity.
+
+    Substituting :func:`optimum_flow_velocity` into
+    :func:`van_deemter_H` (Harris, *Quantitative Chemical Analysis*, 9th
+    ed., Ch. 23.4).
+
+    Parameters
+    ----------
+    A, B, C : float
+
+    Returns
+    -------
+    float
+
+    Examples
+    --------
+    Matches direct evaluation of :func:`van_deemter_H` at the optimum
+    velocity from :func:`optimum_flow_velocity`:
+
+    >>> A, B, C = 1.0, 2.0, 0.05
+    >>> u_opt = optimum_flow_velocity(B, C)
+    >>> bool(round(minimum_plate_height(A, B, C), 6) == round(float(van_deemter_H(u_opt, A, B, C)), 6))
+    True
+    """
+    return A + 2.0 * np.sqrt(B * C)
+
+
+def retention_factor(retention_time: float, dead_time: float):
+    r"""The retention (capacity) factor :math:`k=(t_R-t_0)/t_0`.
+
+    Parameters
+    ----------
+    retention_time : float or array-like of float
+        Analyte retention time :math:`t_R`.
+    dead_time : float
+        Column dead time (retention time of an unretained species) :math:`t_0`.
+
+    Returns
+    -------
+    float or ndarray
+
+    Examples
+    --------
+    >>> round(float(retention_factor(retention_time=12.0, dead_time=2.0)), 6)
+    5.0
+    """
+    tR = np.asarray(retention_time, dtype=np.float64)
+    result = (tR - dead_time) / dead_time
+    return float(result) if result.ndim == 0 else result
+
+
+def selectivity_factor(k1: float, k2: float) -> float:
+    r"""The selectivity (relative retention) factor :math:`\alpha=k_2/k_1` (:math:`k_2\ge k_1` by convention).
+
+    Parameters
+    ----------
+    k1, k2 : float
+        Retention factors of the earlier- and later-eluting peaks.
+
+    Returns
+    -------
+    float
+
+    Examples
+    --------
+    >>> round(selectivity_factor(k1=2.0, k2=5.0), 6)
+    2.5
+    """
+    return k2 / k1
+
+
+def resolution(tR1: float, tR2: float, w1: float, w2: float) -> float:
+    r"""Chromatographic resolution :math:`R_s=2(t_{R,2}-t_{R,1})/(w_1+w_2)` between two adjacent peaks.
+
+    :math:`R_s\ge1.5` is the conventional criterion for baseline
+    separation (Harris, *Quantitative Chemical Analysis*, 9th ed., eq.
+    23.21).
+
+    Parameters
+    ----------
+    tR1, tR2 : float
+        Retention times of the earlier- and later-eluting peaks.
+    w1, w2 : float
+        Base widths of the two peaks, same time units.
+
+    Returns
+    -------
+    float
+
+    Examples
+    --------
+    >>> round(resolution(tR1=9.0, tR2=10.0, w1=0.5, w2=0.5), 6)
+    2.0
+    """
+    return 2.0 * (tR2 - tR1) / (w1 + w2)
+
+
+def simulate_chromatogram(t, centers, retention_times=None, N: float = 10000.0, amplitudes=None):
+    r"""Simulate a chromatogram as a sum of Gaussian elution peaks of plate-count-consistent width.
+
+    Reuses :func:`chemistrykit.spectro.utils.lineshapes.gaussian` (each
+    elution peak is, to a good approximation, Gaussian -- the same
+    plate-theory result that underlies :func:`theoretical_plates`), with
+    each peak's FWHM set by :math:`w_{1/2}=t_R\sqrt{8\ln2/N}` (inverting
+    :func:`theoretical_plates`'s half-height form,
+    :math:`N=5.545(t_R/w_{1/2})^2` with :math:`5.545\approx8\ln2`).
+
+    Parameters
+    ----------
+    t : array-like of float
+        Time grid to evaluate the chromatogram on.
+    centers : array-like of float
+        Retention time of each peak (alias for `retention_times`, kept
+        for a natural call signature with :func:`chemistrykit.spectro.utils.lineshapes.broaden_stick_spectrum`).
+    retention_times : array-like of float, optional
+        If given, overrides `centers`.
+    N : float, default 10000.0
+        Number of theoretical plates (assumed equal for every peak, the
+        common simplifying assumption for a single column/method).
+    amplitudes : array-like of float, optional
+        Relative peak heights; defaults to 1.0 for every peak.
+
+    Returns
+    -------
+    ndarray, shape matching `t`
+
+    Examples
+    --------
+    A single simulated peak's apparent plate count (recovered from its
+    numerically-measured FWHM) matches the `N` it was built from:
+
+    >>> import numpy as np
+    >>> t = np.linspace(8.0, 12.0, 200001)
+    >>> N_true = 10000.0
+    >>> chrom = simulate_chromatogram(t, centers=[10.0], N=N_true)
+    >>> half_max = chrom.max() / 2.0
+    >>> above = t[chrom >= half_max]
+    >>> fwhm = above.max() - above.min()
+    >>> N_recovered = theoretical_plates(10.0, fwhm, width_type="half_height")
+    >>> bool(abs(N_recovered - N_true) / N_true < 0.01)
+    True
+    """
+    t = np.asarray(t, dtype=np.float64)
+    centers = np.asarray(retention_times if retention_times is not None else centers, dtype=np.float64)
+    amps = np.ones_like(centers) if amplitudes is None else np.asarray(amplitudes, dtype=np.float64)
+    chrom = np.zeros_like(t)
+    for tR, amp in zip(centers, amps, strict=True):
+        fwhm = tR * np.sqrt(8.0 * np.log(2.0) / N)
+        chrom += amp * gaussian(t, tR, fwhm)
+    return chrom