scipas 0.3.0__py3-none-any.whl

scipas/__init__.py

@@ -0,0 +1,23 @@
+# Core analysis classes
+from scipas.core import DB, CDB
+from scipas.core.const import ELECTRON_REST_MASS_KEV
+
+# Model / geometry
+from scipas.model import Material, Defect, Layer, Sample
+
+# Coincidence filter
+from scipas.filter import PasCoincidenceFilter
+
+# Transport
+from scipas.transport import (
+    ghosh_profile,
+    makhov_profile,
+    ghosh_material_parameters,
+    makhov_material_parameters,
+    multilayer_implantation_profile,
+    profile_solver,
+)
+
+# VEDB analysis
+from scipas.analysis import (DiffusionLengthOptimization, compute_s_lineshape, compute_w_lineshape,
+                            variable_energy_implantation_profiles)

scipas/analysis/__init__.py

@@ -0,0 +1,3 @@
+from .vedb import (compute_annihilation_fractions, DiffusionLengthOptimization,
+                   compute_s_lineshape, compute_w_lineshape,
+                   variable_energy_implantation_profiles)

scipas/analysis/vedb/__init__.py

@@ -0,0 +1,5 @@
+"""Package for Variable Energy Doppler Broadening (VEDB) analysis"""
+from .annihilation_fractions import compute_annihilation_fractions
+from .diffusion_length import DiffusionLengthOptimization
+from .lineshape import compute_s_lineshape, compute_w_lineshape
+from .ve_implanation import variable_energy_implantation_profiles

scipas/analysis/vedb/annihilation_fractions.py

@@ -0,0 +1,105 @@
+import numpy as np
+import xarray as xr
+from warnings import warn
+from scipas.model.sample import Sample
+
+
+def compute_annihilation_fractions(positron_profile: xr.DataArray, sample: Sample) -> xr.DataArray:
+    """
+    Compute the annihilation fraction of positrons in each layer and at the surface.
+
+    The total annihilation rate is decomposed into contributions from:
+        - Surface (layer = -1): positrons annihilating at the sample surface,
+          governed by the surface absorption length.
+        - Bulk layers (layer = 0, 1, ...): positrons annihilating in each
+          material layer, weighted by the effective annihilation rate.
+
+    The fractions are normalized so that they sum to 1.
+
+    Parameters
+    ----------
+    positron_profile : xr.DataArray
+        1D positron density profile after diffusion [positrons/nm],
+        with a single depth coordinate (any name is accepted).
+        Must be normalized such that its integral equals 1.
+    sample : Sample
+        Multilayer sample defining geometry, material annihilation rates,
+        and surface absorption length.
+
+    Returns
+    -------
+    xr.DataArray
+        Normalized annihilation fractions with coordinate 'layer':
+        - layer = -1  : surface annihilation fraction
+        - layer = 0, 1, 2, ... : bulk annihilation fraction per layer
+
+    Raises
+    ------
+    ValueError
+        If positron_profile is not 1D.
+
+    Warns
+    -----
+    UserWarning
+        If the positron profile extends beyond the sample length.
+        Annihilation beyond the sample boundary is ignored and
+        fractions will not sum to 1 correctly.
+
+     Examples
+     --------
+    >>> from scipas.model import Sample, Layer, Material
+    >>> from scipas.analysis import compute_annihilation_fractions
+    >>> import xarray as xr
+    >>> import numpy as np
+    >>> silicon = Material(name="Silicon",
+    ...                    diffusion=1,
+    ...                    mobility=1,
+    ...                    bulk_annihilation_rate=1)
+    >>> layer = Layer(start=0.0, width=10000.0, material=silicon)
+    >>> sample = Sample(layers=[layer], absorption_length=1)
+    >>> depth = np.arange(0, layer.width+1, 1)
+    >>> positron_annihilation_profile = xr.DataArray(np.ones_like(depth), coords={'x':depth})
+    >>> positron_annihilation_profile /= positron_annihilation_profile.integrate('x')
+    >>> res = compute_annihilation_fractions(positron_annihilation_profile, sample)
+    >>> round(float(res.sum())) == 1.0
+    True
+    >>> round(float(res.sel(layer=-1)), 5) == 1e-4
+    True
+    """
+    # check input
+
+    if positron_profile.ndim != 1:
+        raise ValueError(f"positron_profile must be 1D, got {positron_profile.ndim}D")
+    depth_dim = positron_profile.dims[0]  # infer axis name
+
+    profile_max_depth = positron_profile.coords[depth_dim].max().item()
+    sample_length = sample.sample_length()
+    if profile_max_depth > sample_length:
+        warn(
+            f"Positron profile extends to {profile_max_depth:.1f} nm but sample ends at "
+            f"{sample_length:.1f} nm. Annihilation beyond the sample boundary is ignored, "
+            f"fractions will not sum to 1 correctly. Consider extending the last layer."
+        )
+    # defs
+    layers = sample.layers
+    num_of_layers = len(layers)
+    layers_names = range(-1, num_of_layers)
+    annihilation_rate = np.zeros(num_of_layers+1) # layers and surface
+
+    # surface positrons annihilation rate
+    annihilation_rate[0] = (positron_profile.sel({depth_dim: 0.0}, method='nearest').item() *
+                             sample.layers[0].material.diffusion / sample.absorption_length)
+
+    # layers positrons annihilation rates
+    for i, layer in enumerate(layers):
+        layer_positron_profile = positron_profile.sel({depth_dim: slice(layer.start, layer.start + layer.width)})
+        positron_fraction_in_layer = layer_positron_profile.integrate(depth_dim)
+        annihilation_rate[i+1] = layer.material.effective_annihilation_rate() * positron_fraction_in_layer.item()
+
+    # norm
+    annihilation_fractions = xr.DataArray(annihilation_rate, coords={'layer':layers_names})/annihilation_rate.sum()
+
+    return annihilation_fractions
+
+
+

scipas/analysis/vedb/diffusion_length.py

@@ -0,0 +1,268 @@
+import numpy as np
+import pandas as pd
+from uncertainties import ufloat
+from uncertainties.unumpy import nominal_values, std_devs
+from scipy.optimize import least_squares
+from scipas.model import Sample, Material, Layer
+from scipas.transport.diffusion import profile_solver
+from scipas.analysis.vedb.annihilation_fractions import compute_annihilation_fractions
+
+
+class DiffusionLengthOptimization:
+    """
+    Optimize positron diffusion lengths in a multilayer sample to best fit
+    experimentally measured lineshpae-parameter from variable-energy Doppler broadening (VEDB).
+    The parametrer can be S or W.
+
+    The optimization solves the simplified positron transport equation in layered samples:
+
+        d²c(z)/dz² − (1 / L_eff²) * c(z) = -I(z)
+
+    where:
+        - c(z)   : positron concentration as a function of depth
+        - L_eff  : effective diffusion length, L_eff = sqrt(D / λ)
+        - I(z)   : positron implantation source term
+
+    For each trial set of diffusion lengths, the class:
+        1. Constructs a normalized trial sample (D=1, λ = 1/L²).
+        2. Solves the positron transport equation for each implantation energy.
+        3. Computes annihilation fractions per layer and surface.
+        4. Estimates S-parameters via linear least squares.
+        5. Minimizes weighted residuals via nonlinear least squares.
+
+    The number of layers is inferred automatically from the initial guess sample,
+    making this class applicable to single-layer, two-layer, and three-layer models
+    without modification.
+
+    Parameters
+    ----------
+    positron_implantation_profiles : list of xr.DataArray
+        Depth profiles of implanted positrons for each beam energy [positrons/nm].
+        Each profile must be normalized and have a single depth coordinate.
+    s_measurement : pd.Series of uncertainties.ufloat or uarray
+        Measured S-parameters with uncertainties for each beam energy.
+        Index must correspond to the implantation profiles.
+    initial_guess : Sample
+        Initial sample defining layer geometry and material properties.
+        Used to extract layer widths and initial diffusion length estimates.
+    num_of_mesh_cells : int, optional
+        Number of mesh points for the transport equation solver. Default is 10000.
+        Higher values improve accuracy at the cost of computation time.
+
+    Attributes
+    ----------
+    n_layers : int
+        Number of layers, inferred from initial_guess.
+    s_measurement : np.ndarray
+        Nominal S-parameter values extracted from the ufloat series.
+    s_measurement_dev : np.ndarray
+        Standard deviations of the S-parameter measurements.
+
+    Notes
+    -----
+    The trial sample uses normalized units (D=1, absorption_length=1) since
+    only the diffusion length L = sqrt(D/λ) affects the annihilation profile shape.
+    The absolute values of D and absorption_length do not affect the optimization result.
+    """
+
+    def __init__(self,
+                 positron_implantation_profiles: list,
+                 s_measurement: pd.Series,
+                 initial_guess: Sample,
+                 num_of_mesh_cells: int = 10000):
+
+        self.positron_implantation_profiles = positron_implantation_profiles
+        self.initial_sample = initial_guess
+        self.s_measurement = nominal_values(s_measurement)
+        self.s_measurement_dev = std_devs(s_measurement)
+        self.num_of_mesh_cells = num_of_mesh_cells
+        self.n_layers = len(initial_guess.layers)
+
+    def make_sample(self, diffusion_lengths: list) -> Sample:
+        """
+        Construct a normalized trial sample for a given set of diffusion lengths.
+
+        Each layer is assigned D=1 and λ = 1/L² so that the effective diffusion
+        length matches the trial value. Layer geometry (start, width) is preserved
+        from the initial guess. The absorption length is set to 1 (normalized)
+        since it does not affect the diffusion length optimization.
+
+        Parameters
+        ----------
+        diffusion_lengths : list of float
+            Trial diffusion lengths [nm], one per layer.
+            Must have the same length as the number of layers in the initial sample.
+
+        Returns
+        -------
+        Sample
+            Normalized single- or multilayer sample with the given diffusion lengths.
+        """
+        layers = [
+            Layer(
+                start=self.initial_sample.layers[i].start,
+                width=self.initial_sample.layers[i].width,
+                material=Material(diffusion=1, mobility=0, bulk_annihilation_rate=1 / dl ** 2)
+            )
+            for i, dl in enumerate(diffusion_lengths)
+        ]
+        return Sample(layers=layers, absorption_length=1)
+
+    def layers_transport_solver(self, sample: Sample, implantation_profiles: list) -> np.ndarray:
+        """
+        Solve the positron transport equation for each implantation profile
+        and return the annihilation fraction matrix.
+
+        Parameters
+        ----------
+        sample : Sample
+            Trial sample for which the transport equation is solved.
+        implantation_profiles : list of xr.DataArray
+            Positron implantation profiles, one per beam energy.
+
+        Returns
+        -------
+        np.ndarray
+            Annihilation fraction matrix of shape (n_profiles, n_layers + 1).
+            Each row corresponds to one beam energy; columns are
+            [surface, layer_0, layer_1, ...].
+        """
+        frac_matrix = np.zeros((len(implantation_profiles), self.n_layers + 1))
+        for i, p in enumerate(implantation_profiles):
+            frac_matrix[i] = compute_annihilation_fractions(
+                positron_profile=profile_solver(p, sample, mesh_size=self.num_of_mesh_cells),
+                sample=sample).values
+        return frac_matrix
+
+    def layer_s_value(self, frac_matrix: np.ndarray) -> np.ndarray:
+        """
+        Estimate the S-parameter characteristic of each annihilation channel
+        via linear least squares.
+
+        Solves:  frac_matrix @ s_layers ≈ s_measurement
+
+        Parameters
+        ----------
+        frac_matrix : np.ndarray
+            Annihilation fraction matrix of shape (n_profiles, n_channels).
+
+        Returns
+        -------
+        np.ndarray
+            Estimated S-parameter per annihilation channel [surface, layer_0, ...].
+            Length is n_layers + 1.
+        """
+        return np.linalg.lstsq(frac_matrix, self.s_measurement, rcond=None)[0]
+
+    def residuals(self, diffusion_lengths: np.ndarray) -> np.ndarray:
+        """
+        Compute weighted residuals between measured and modeled S-parameters.
+
+        For a given trial set of diffusion lengths, solves the transport equation,
+        estimates S-parameters per layer, and returns the normalized difference:
+
+            residuals = (S_calc - S_measured) / sigma_measured
+
+        If any estimated S-parameter per layer is unphysical (negative or >= 1),
+        returns a large residual vector to penalize the optimizer.
+
+        Parameters
+        ----------
+        diffusion_lengths : np.ndarray
+            Trial diffusion lengths [nm], one per layer.
+
+        Returns
+        -------
+        np.ndarray
+            Weighted residual vector of length n_profiles.
+        """
+        sample = self.make_sample(diffusion_lengths)
+        frac_matrix = self.layers_transport_solver(sample, self.positron_implantation_profiles)
+        s_vec = self.layer_s_value(frac_matrix)
+        s_calc = frac_matrix @ s_vec
+        if np.any(s_vec[1:] >= 1) or np.any(s_vec <= 0):
+            return np.full_like(s_calc, 1e6)
+        return (s_calc - self.s_measurement) / self.s_measurement_dev
+
+    def extract_fit_results(self, ls_results) -> list:
+        """
+        Extract best-fit parameters and full covariance matrix from least-squares result.
+
+        The covariance matrix is estimated from the Jacobian via the Gauss-Newton
+        approximation using SVD:
+
+        J ≈ U S Vᵀ  →  cov ≈ Vᵀ diag(1/s²) V
+
+        Singular values below numerical precision are discarded to regularize
+        the inversion.
+        Parameters
+        ----------
+        ls_results : OptimizeResult
+            Result from `scipy.optimize.least_squares`. Must contain
+            `jac` (Jacobian at solution) and `x` (best-fit parameters).
+
+        Returns
+        -------
+        best_fit : np.ndarray
+            Best-fit diffusion lengths [nm], shape (n_layers,).
+        cov : np.ndarray
+            Full covariance matrix, shape (n_layers, n_layers).
+            Diagonal entries are variances; off-diagonal entries capture
+            parameter correlations and should not be neglected for
+            correlated layers.
+        """
+
+        J = ls_results.jac
+        _, s, VT = np.linalg.svd(J, full_matrices=False)
+        threshold = np.finfo(float).eps * max(J.shape) * s[0]
+        s = s[s > threshold]
+        VT = VT[:s.size]
+        cov = np.dot(VT.T / s ** 2, VT)
+        return ls_results.x, cov
+
+    def optimize_diffusion_length(self, bounds=None) -> tuple:
+        """
+        Optimize diffusion lengths for all layers simultaneously.
+
+        Performs nonlinear least-squares minimization of the weighted residuals
+        between measured and modeled S-parameters. Initial guesses are derived
+        from the material properties of the initial sample.
+
+        Parameters
+        ----------
+        bounds : tuple of (float, float), optional
+            (lower, upper) bounds applied equally to all diffusion lengths [nm].
+            Must satisfy 0 <= lower <= upper. Default is (0, 1000).
+
+        Returns
+        -------
+        best_fit : np.ndarray
+            Best-fit diffusion lengths [nm], shape (n_layers,).
+            Ordered as [layer_0, layer_1, ...].
+        cov : np.ndarray
+            Full covariance matrix of shape (n_layers, n_layers).
+            Diagonal entries are variances; off-diagonal entries capture
+            parameter correlations. Marginal uncertainties can be obtained
+            via np.sqrt(np.diag(cov)).
+
+        Raises
+        ------
+        ValueError
+            If lower bound exceeds upper bound.
+        """
+        initial_guess = [
+            (m.diffusion / m.effective_annihilation_rate()) ** 0.5
+            for m in (layer.material for layer in self.initial_sample.layers)
+        ]
+
+        if bounds is None:
+            bounds = (0, 1000)
+        elif not 0 <= bounds[0] <= bounds[1]:
+            raise ValueError("lower bound must be less than upper bound")
+
+        lb = [bounds[0]] * self.n_layers
+        ub = [bounds[1]] * self.n_layers
+
+        ls_result = least_squares(fun=self.residuals, x0=initial_guess, bounds=(lb, ub))
+
+        return self.extract_fit_results(ls_result)

scipas/analysis/vedb/lineshape.py

@@ -0,0 +1,167 @@
+import pandas as pd
+from scipas.core.const import ELECTRON_REST_MASS_KEV
+
+
+def compute_s_lineshape(
+        db_spectra: list,
+        energies,
+        energy_domain_total,
+        energy_domain_s,
+        centralize: bool = True,
+        center_value: float = ELECTRON_REST_MASS_KEV,
+) -> pd.Series:
+    """
+    Compute S-parameter vs. positron beam energy from a series of DB spectra.
+
+    Parameters
+    ----------
+    db_spectra : list of DB
+        DB spectra, one per beam energy, in the same order as ``energies``.
+    energies : array-like
+        Positron beam energies [keV], one per spectrum.
+    energy_domain_total : iterable of float
+        (e_low, e_high) — full integration window for normalization [keV].
+    energy_domain_s : iterable of float
+        (e_low, e_high) — central window for the S parameter [keV].
+    centralize : bool, optional
+        If True (default), recenters each spectrum's axis calibration so the
+        annihilation peak aligns with ``center_value`` before computing.
+        Modifies each DB's axis calibration in place.
+    center_value : float, optional
+        Target energy for peak centralization [keV].
+        Defaults to the electron rest mass energy (``ELECTRON_REST_MASS_KEV``).
+        Use 0.0 for CDB or momentum spectra expressed as energy shifts.
+
+    Returns
+    -------
+    pd.Series of uncertainties.ufloat
+        S parameter vs. beam energy, indexed by ``energies``, named ``'S'``.
+
+    Raises
+    ------
+    ValueError
+        If ``db_spectra`` and ``energies`` have different lengths.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scispectrum import Spectrum, AxisCalibration, ResolutionCalibration
+    >>> from scipas.core.db import DB
+    >>> from scipas.analysis.vedb.lineshape import compute_s_lineshape
+    >>> def make_db(center):
+    ...     bins = np.linspace(center - 10, center + 10, 200)
+    ...     ax = (bins[:-1] + bins[1:]) / 2
+    ...     counts = np.round(1e4 * np.exp(-0.5 * ((ax - center) / 1.5) ** 2) + 50).astype(int)
+    ...     spec = Spectrum(counts=counts, counts_err=np.sqrt(counts),
+    ...                     axis_calib=AxisCalibration.from_array(ax),
+    ...                     resolution_calib=ResolutionCalibration(lambda e: 3.0))
+    ...     return DB.from_spectrum(spec)
+    >>> db_list = [make_db(511.0), make_db(510.8)]
+    >>> s = compute_s_lineshape(db_list, [5.0, 10.0],
+    ...                         energy_domain_total=[507.0, 515.0],
+    ...                         energy_domain_s=[510.2, 511.8])
+    >>> list(s.index) == [5.0, 10.0]
+    True
+    >>> all(0 < float(v.nominal_value) < 1 for v in s)
+    True
+    """
+    if len(db_spectra) != len(energies):
+        raise ValueError(
+            f"db_spectra and energies must have the same length "
+            f"(got {len(db_spectra)} spectra and {len(energies)} energies)."
+        )
+
+    s_values = []
+    for db in db_spectra:
+        if centralize:
+            db.recenter(center_value)
+        s_values.append(db.s_parameter_calculation(energy_domain_total, energy_domain_s))
+
+    s = pd.Series(s_values, index=list(energies), name='S')
+    s.index.name = 'energy'
+    return s
+
+
+def compute_w_lineshape(
+        db_spectra: list,
+        energies,
+        energy_domain_total,
+        energy_domain_w_left,
+        energy_domain_w_right,
+        centralize: bool = True,
+        center_value: float = ELECTRON_REST_MASS_KEV,
+) -> pd.Series:
+    """
+    Compute W-parameter vs. positron beam energy from a series of DB spectra.
+
+    Parameters
+    ----------
+    db_spectra : list of DB
+        DB spectra, one per beam energy, in the same order as ``energies``.
+    energies : array-like
+        Positron beam energies [keV], one per spectrum.
+    energy_domain_total : iterable of float
+        (e_low, e_high) — full integration window for normalization [keV].
+    energy_domain_w_left : iterable of float
+        (e_low, e_high) — left wing window for the W parameter [keV].
+    energy_domain_w_right : iterable of float
+        (e_low, e_high) — right wing window for the W parameter [keV].
+    centralize : bool, optional
+        If True (default), recenters each spectrum's axis calibration so the
+        annihilation peak aligns with ``center_value`` before computing.
+        Modifies each DB's axis calibration in place.
+    center_value : float, optional
+        Target energy for peak centralization [keV].
+        Defaults to the electron rest mass energy (``ELECTRON_REST_MASS_KEV``).
+        Use 0.0 for CDB or momentum spectra expressed as energy shifts.
+
+    Returns
+    -------
+    pd.Series of uncertainties.ufloat
+        W parameter vs. beam energy, indexed by ``energies``, named ``'W'``.
+
+    Raises
+    ------
+    ValueError
+        If ``db_spectra`` and ``energies`` have different lengths.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scispectrum import Spectrum, AxisCalibration, ResolutionCalibration
+    >>> from scipas.core.db import DB
+    >>> from scipas.analysis.vedb.lineshape import compute_w_lineshape
+    >>> def make_db(center):
+    ...     bins = np.linspace(center - 10, center + 10, 200)
+    ...     ax = (bins[:-1] + bins[1:]) / 2
+    ...     counts = np.round(1e4 * np.exp(-0.5 * ((ax - center) / 1.5) ** 2) + 50).astype(int)
+    ...     spec = Spectrum(counts=counts, counts_err=np.sqrt(counts),
+    ...                     axis_calib=AxisCalibration.from_array(ax),
+    ...                     resolution_calib=ResolutionCalibration(lambda e: 3.0))
+    ...     return DB.from_spectrum(spec)
+    >>> db_list = [make_db(511.0), make_db(510.8)]
+    >>> w = compute_w_lineshape(db_list, [5.0, 10.0],
+    ...                         energy_domain_total=[507.0, 515.0],
+    ...                         energy_domain_w_left=[507.5, 509.3],
+    ...                         energy_domain_w_right=[512.7, 514.5])
+    >>> list(w.index) == [5.0, 10.0]
+    True
+    >>> all(0 < float(v.nominal_value) < 1 for v in w)
+    True
+    """
+    if len(db_spectra) != len(energies):
+        raise ValueError(
+            f"db_spectra and energies must have the same length "
+            f"(got {len(db_spectra)} spectra and {len(energies)} energies)."
+        )
+
+    w_values = []
+    for db in db_spectra:
+        if centralize:
+            db.recenter(center_value)
+        w_values.append(db.w_parameter_calculation(
+            energy_domain_total, energy_domain_w_left, energy_domain_w_right))
+
+    w = pd.Series(w_values, index=list(energies), name='W')
+    w.index.name = 'energy'
+    return w

scipas/analysis/vedb/ve_implanation.py

@@ -0,0 +1,86 @@
+import numpy as np
+import xarray as xr
+from scipas.transport.implantation import multilayer_implantation_profile, makhov_profile
+
+
+def variable_energy_implantation_profiles(
+        energies,
+        depth_vector: np.ndarray,
+        materials_parameters: list,
+        densities: list,
+        widths: list,
+        implantation_profile_function=makhov_profile,
+) -> list:
+    """
+    Compute positron implantation profiles for a series of beam energies.
+
+    Wraps ``multilayer_implantation_profile`` in a loop over ``energies``,
+    returning one profile per energy. Handles both single-layer (homogeneous
+    substrate) and multilayer (thin film on substrate) geometries.
+
+    Parameters
+    ----------
+    energies : array-like
+        Positron beam energies [keV] for which to compute implantation profiles.
+    depth_vector : np.ndarray
+        1D depth grid [nm] spanning the full sample, e.g.
+        ``np.linspace(0, sample.sample_length(), 10000)``.
+    materials_parameters : list of pd.Series
+        Material parameters for each layer, one entry per layer.
+        Obtain via ``makhov_material_parameters()`` or ``ghosh_material_parameters()``.
+        For a homogeneous substrate pass a single-element list.
+    densities : list of float
+        Actual material density [g/cm³] for each layer.
+        Must be the same length as ``materials_parameters``.
+    widths : list of float
+        Width of each layer [nm], from surface to substrate.
+        If ``depth_vector[-1]`` exceeds ``sum(widths)``, the last layer is
+        extended to fill the remaining depth (semi-infinite substrate approximation).
+        For a homogeneous substrate pass ``[sample_length]``.
+    implantation_profile_function : callable, optional
+        Profile function to use for each layer.
+        Must have the signature
+        ``f(positron_energy, depth_vector, density, material_params) -> xr.DataArray``.
+        Defaults to ``makhov_profile``.
+
+    Returns
+    -------
+    list of xr.DataArray
+        Implantation profiles, one per entry in ``energies``, each with
+        coordinate ``'x'`` in nm and units of positrons/nm (normalised so
+        the integral over depth equals 1).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from scipas.transport import makhov_material_parameters, makhov_profile
+    >>> from scipas.analysis.vedb.ve_implanation import variable_energy_implantation_profiles
+    >>> params = makhov_material_parameters()
+    >>> cu = params[params['Material'] == 'Cu'].iloc[0]
+    >>> depth = np.linspace(0, 10000, 5000)
+    >>> profiles = variable_energy_implantation_profiles(
+    ...     energies=[5.0, 10.0, 20.0],
+    ...     depth_vector=depth,
+    ...     materials_parameters=[cu],
+    ...     densities=[cu.density],
+    ...     widths=[10000],
+    ... )
+    >>> len(profiles)
+    3
+    >>> all(isinstance(p, xr.DataArray) for p in profiles)
+    True
+    >>> all('x' in p.coords for p in profiles)
+    True
+    """
+    profiles = []
+    for energy in energies:
+        profile = multilayer_implantation_profile(
+            positron_energy=float(energy),
+            depth_vector=depth_vector,
+            widths=list(widths),
+            materials_parameters=list(materials_parameters),
+            densities=list(densities),
+            implantation_profile_function=implantation_profile_function,
+        )
+        profiles.append(profile)
+    return profiles

scipas/core/__init__.py

@@ -0,0 +1,4 @@
+"""Doppler Broadening peak analysis"""
+from .db import DB
+from .cdb import CDB
+from .const import ELECTRON_REST_MASS_KEV