cemd 0.1.0__py3-none-any.whl

cemd/__init__.py

@@ -0,0 +1,33 @@
+#
+# This file is part of the CEMD distribution
+# Copyright (c) 2022-2026 Jérôme Claverie.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+from importlib.metadata import PackageNotFoundError, version
+
+from .core.atomic_system import AtomicSystem
+
+try:
+    __version__ = version("cemd")
+except PackageNotFoundError:  # running from a source tree, never installed
+    __version__ = "unknown"
+
+__author__ = "Jérôme Claverie"
+
+__copyright__ = "Copyright (c) 2022-2026 Jérôme Claverie"
+
+__license__ = "GPL-3.0"
+
+__all__ = ["AtomicSystem", "__version__"]

cemd/_constants.py

@@ -0,0 +1,252 @@
+#
+# This file is part of the CEMD distribution
+# Copyright (c) 2022-2026 Jérôme Claverie.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+import numpy as np
+
+AVOGADRO = 6.02214076e23
+
+MASSES_DICT = {
+    "H": 1.007947,
+    "He": 4.0026022,
+    "Li": 6.9412,
+    "Be": 9.0121823,
+    "B": 10.8117,
+    "C": 12.01078,
+    "N": 14.00672,
+    "O": 15.99943,
+    "F": 18.99840325,
+    "Ne": 20.17976,
+    "Na": 22.989769282,
+    "Mg": 24.30506,
+    "Al": 26.981538613,
+    "Si": 28.08553,
+    "P": 30.9737622,
+    "S": 32.0655,
+    "Cl": 35.4532,
+    "Ar": 39.9481,
+    "K": 39.09831,
+    "Ca": 40.0784,
+    "Sc": 44.9559126,
+    "Ti": 47.8671,
+    "V": 50.94151,
+    "Cr": 51.99616,
+    "Mn": 54.9380451,
+    "Fe": 55.8452,
+    "Co": 58.9331955,
+    "Ni": 58.69344,
+    "Cu": 63.5463,
+    "Zn": 65.382,
+    "Ga": 69.7231,
+    "Ge": 72.6308,
+    "As": 74.921602,
+    "Se": 78.963,
+    "Br": 79.9041,
+    "Kr": 83.7982,
+    "Rb": 85.46783,
+    "Sr": 87.621,
+    "Y": 88.905852,
+    "Zr": 91.2242,
+    "Nb": 92.906382,
+    "Mo": 95.962,
+    "Tc": 98.0,
+    "Ru": 101.072,
+    "Rh": 102.905502,
+    "Pd": 106.421,
+    "Ag": 107.86822,
+    "Cd": 112.4118,
+    "In": 114.8181,
+    "Sn": 118.7107,
+    "Sb": 121.7601,
+    "Te": 127.603,
+    "I": 126.904473,
+    "Xe": 131.2936,
+    "Cs": 132.90545196,
+    "Ba": 137.3277,
+    "D": 2.01410178,
+    "T": 3.01604928,
+}
+
+VDW_RADII = {
+    "H": 1.10,
+    "He": 1.40,
+    "Li": 1.82,
+    "Be": 1.53,
+    "B": 1.92,
+    "C": 1.70,
+    "N": 1.55,
+    "O": 1.52,
+    "F": 1.47,
+    "Ne": 1.54,
+    "Na": 2.27,
+    "Mg": 1.73,
+    "Al": 1.84,
+    "Si": 2.10,
+    "P": 1.80,
+    "S": 1.80,
+    "Cl": 1.75,
+    "Ar": 1.88,
+    "K": 2.75,
+    "Ca": 2.31,
+    "Sc": 2.11,
+    "Ti": 1.95,
+    "V": 1.91,
+    "Cr": 1.85,
+    "Mn": 1.79,
+    "Fe": 1.63,
+    "Co": 1.63,
+    "Ni": 1.63,
+    "Cu": 1.40,
+    "Zn": 1.39,
+    "Ga": 1.87,
+    "Ge": 2.11,
+    "As": 1.85,
+    "Se": 1.90,
+    "Br": 1.85,
+    "Kr": 2.02,
+    "Rb": 3.03,
+    "Sr": 2.49,
+    "Y": 2.32,
+    "Zr": 2.23,
+    "Nb": 2.18,
+    "Mo": 2.17,
+    "Tc": 2.16,
+    "Ru": 2.13,
+    "Rh": 2.10,
+    "Pd": 1.63,
+    "Ag": 1.72,
+    "Cd": 1.58,
+    "In": 1.93,
+    "Sn": 2.17,
+    "Sb": 2.06,
+    "Te": 2.06,
+    "I": 1.98,
+    "Xe": 2.16,
+    "Cs": 3.43,
+    "Ba": 2.68,
+    "La": 2.43,
+    "Ce": 2.42,
+    "Pr": 2.40,
+    "Nd": 2.39,
+    "Pm": 2.38,
+    "Sm": 2.36,
+    "Eu": 2.35,
+    "Gd": 2.34,
+    "Tb": 2.33,
+    "Dy": 2.31,
+    "Ho": 2.30,
+    "Er": 2.29,
+    "Tm": 2.27,
+    "Yb": 2.26,
+    "Lu": 2.24,
+    "Hf": 2.23,
+    "Ta": 2.22,
+    "W": 2.18,
+    "Re": 2.16,
+    "Os": 2.16,
+    "Ir": 2.13,
+    "Pt": 1.75,
+    "Au": 1.66,
+    "Hg": 1.55,
+    "Tl": 1.96,
+    "Pb": 2.02,
+    "Bi": 2.07,
+    "Po": 1.97,
+    "At": 2.02,
+    "Rn": 2.20,
+    "Fr": 3.48,
+    "Ra": 2.83,
+    "Ac": 2.47,
+    "Th": 2.45,
+    "Pa": 2.43,
+    "U": 1.86,
+    "Np": 2.41,
+    "Pu": 2.39,
+    "Am": 2.38,
+    "Cm": 2.37,
+    "Bk": 2.35,
+    "Cf": 2.34,
+    "Es": 2.33,
+    "Fm": 2.31,
+    "Md": 2.30,
+    "No": 2.29,
+    "Lr": 2.27,
+    "Rr": 3.03,
+}
+
+CHARGES_DICT = {
+    "H": 1,
+    "Li": 1,
+    "Na": 1,
+    "K": 1,
+    "Rb": 1,
+    "Cs": 1,
+    "Be": 2,
+    "Mg": 2,
+    "Ca": 2,
+    "Sr": 2,
+    "Ba": 2,
+    "B": 3,
+    "Al": 3,
+    "Ga": 3,
+    "In": 3,
+    "C": 4,
+    "Si": 4,
+    "Ge": 4,
+    "Sn": 2,
+    "Pb": 2,
+    "N": -3,
+    "P": -3,
+    "As": -3,
+    "Sb": 3,
+    "Bi": 3,
+    "O": -2,
+    "S": -2,
+    "Se": -2,
+    "Te": -2,
+    "F": -1,
+    "Cl": -1,
+    "Br": -1,
+    "I": -1,
+    "Sc": 3,
+    "Ti": 4,
+    "V": 5,
+    "Cr": 3,
+    "Mn": 2,
+    "Fe": 3,
+    "Co": 2,
+    "Ni": 2,
+    "Cu": 2,
+    "Zn": 2,
+    "Y": 3,
+    "Zr": 4,
+    "Nb": 5,
+    "Mo": 6,
+    "Ag": 1,
+    "Cd": 2,
+    "W": 6,
+    "Pt": 4,
+    "Au": 3,
+    "Hg": 2,
+    "La": 3,
+    "Ce": 4,
+    "Nd": 3,
+    "Gd": 3,
+    "Yb": 3,
+}
+
+INV_MASSES = {float(v): k for k, v in MASSES_DICT.items()}
+MASS_KEYS = np.array(list(INV_MASSES.keys()))

cemd/analysis/__init__.py

@@ -0,0 +1,32 @@
+#
+# This file is part of the CEMD distribution
+# Copyright (c) 2022-2026 Jérôme Claverie.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+from .density import density_map, density_profile, electrostatic_potential
+from .diffusion import diffusion_coefficient, msd, msd_profile
+from .rdf import compute_rdf
+from .silicates import analyze_silicates
+
+__all__ = [
+    "compute_rdf",
+    "msd",
+    "msd_profile",
+    "diffusion_coefficient",
+    "density_profile",
+    "density_map",
+    "electrostatic_potential",
+    "analyze_silicates",
+]

cemd/analysis/density.py

@@ -0,0 +1,394 @@
+#
+# This file is part of the CEMD distribution
+# Copyright (c) 2022-2026 Jérôme Claverie.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+from __future__ import annotations
+
+import dask
+import MDAnalysis as mda
+import numpy as np
+import pandas as pd
+from scipy import integrate
+from tqdm import tqdm
+
+_AXIS_MAP = {
+    "x": {"axid": 0, "axida": 1, "axidb": 2},
+    "y": {"axid": 1, "axida": 0, "axidb": 2},
+    "z": {"axid": 2, "axida": 0, "axidb": 1},
+}
+
+
+def _get_axis_ids(axis: str) -> dict:
+    if axis not in _AXIS_MAP:
+        raise ValueError(f"axis must be 'x', 'y' or 'z', got '{axis}'")
+    return _AXIS_MAP[axis]
+
+
+def density_profile(
+    universe: mda.Universe,
+    atom_types: list[str | int],
+    axis: str = "z",
+    start: int = 0,
+    end: int = -1,
+    bin_size: float = 0.1,
+) -> pd.DataFrame:
+    """Create a DataFrame with the average density of atoms of given types along a given axis.
+
+    Parameters
+    ----------
+    universe : mda.Universe
+        The input MDAnalysis Universe to analyze.
+    atom_types : list
+        Atom types to compute the density for.
+    axis : str
+        Axis along which to calculate the density ('x', 'y', or 'z').
+    start : int
+        Starting frame index.
+    end : int
+        Ending frame index.
+    bin_size : float
+        Size of bins for the histogram (in Angstroms).
+
+    Returns
+    -------
+    pd.DataFrame
+        Average density profile for the specified atom types.
+    """
+
+    box = universe.dimensions
+
+    ids = _get_axis_ids(axis)
+    axid = ids["axid"]
+    axida, axidb = ids["axida"], ids["axidb"]
+    slice_vol = bin_size * box[axida] * box[axidb]
+
+    bins = np.arange(0, box[axid], bin_size)
+    pos = (bins[1:] + bins[:-1]) / 2
+    density_total = []
+    columns = []
+
+    def count_pframe(frame_index, sel):
+
+        sel.universe.trajectory[frame_index]
+
+        posi = sel.positions[:, axid]
+
+        posi = posi % box[axid]
+
+        count = np.histogram(posi, bins=bins, range=[0, box[axid]])[0]
+
+        return count
+
+    if atom_types == "all":
+        atom_types = np.unique(universe.atoms.types)
+
+    for t in atom_types:
+        print(f"Compute 1D atomic density of {t} atoms...")
+
+        sel = universe.select_atoms(f"type {t}")
+
+        # nframes = len(universe.trajectory[start:end])
+
+        # job_list = []
+        # for frame_index in tqdm( range(nframes) ):
+        #     job_list.append(dask.delayed(count_pframe)(frame_index, sel))
+
+        frames = (
+            range(len(universe.trajectory))[start:end]
+            if end != -1
+            else range(len(universe.trajectory))[start:]
+        )
+        nframes = len(frames)
+
+        if nframes == 0:
+            raise ValueError(
+                "Le slice de la trajectoire [start:end] ne contient aucune frame."
+            )
+
+        job_list = []
+        for frame_index in tqdm(frames):
+            job_list.append(dask.delayed(count_pframe)(frame_index, sel))
+
+        result = dask.compute(job_list)
+        atom_count = np.sum(result[0], axis=0)
+
+        density = atom_count / slice_vol / nframes * 1000
+
+        density_total.append(density)
+
+        columns.append(f"{t}")
+
+    return pd.DataFrame(np.array(density_total).T, columns=columns, index=pos)
+
+
+def density_map(
+    univ: mda.Universe,
+    atom_types: str | list[str | int],
+    interface_coordinate: float,
+    axis: str = "z",
+    eps: float = 3.0,
+    start: int = 0,
+    end: int = -1,
+    bin_size: float = 0.1,
+) -> pd.DataFrame:
+    """Create a 2D density map of atoms within a specified distance of an interface.
+
+    Parameters
+    ----------
+    univ : mda.Universe
+        The input MDAnalysis Universe to analyze.
+    atom_types : str or list
+        Atom types to consider.
+    interface_coordinate : float
+        Interface coordinate along the given axis.
+    axis : str
+        Axis parallel to which to calculate the density.
+    eps : float
+        Half-thickness of the slab: atoms between ``interface_coordinate -
+        eps`` and ``interface_coordinate + eps`` are counted.
+    start : int
+        Starting trajectory frame.
+    end : int
+        Ending trajectory frame.
+    bin_size : float
+        Size of bins for the histogram in Angstroms.
+
+    Returns
+    -------
+    pd.DataFrame
+        2D average density map.
+    """
+
+    box = univ.dimensions
+
+    type_str = " ".join(atom_types) if isinstance(atom_types, list) else atom_types
+
+    # A slab of half-thickness `eps` centred on the interface, which is what
+    # "within a distance of an interface" means and what this function is
+    # for -- the adsorbed layer, not everything on one side of the plane.
+    # The selection used to be `prop axis < interface + eps`, i.e. the whole
+    # half-cell below: on a solid-liquid system with the solid underneath,
+    # that swept the entire solid into a map meant to show the liquid.
+    lower = interface_coordinate - eps
+    upper = interface_coordinate + eps
+    sel = univ.select_atoms(
+        f"type {type_str} and prop {axis} > {lower} and prop {axis} < {upper}",
+        updating=True,
+    )
+
+    ids = _get_axis_ids(axis)
+    axid = ids["axid"]
+    axida, axidb = ids["axida"], ids["axidb"]
+    bins_a = np.arange(0, box[axida], bin_size)
+    bins_b = np.arange(0, box[axidb], bin_size)
+
+    # A bin of the map is a column through the selected slab: bin_size by
+    # bin_size in the plane, and as deep as the selection reaches along the
+    # perpendicular axis. The 1D slab volume used before
+    # (bin_size * box[a] * box[b]) is the volume of a whole slice, so the
+    # reported densities were low by box[a] * box[b] / (bin_size * depth) --
+    # a factor of 40 on a 20 A box at bin_size 0.5, and one that changes
+    # with the box and the binning rather than being a constant offset.
+    # It went unnoticed because a density map is read for its contrast.
+    slab_depth = min(upper, float(box[axid])) - max(lower, 0.0)
+    column_vol = bin_size * bin_size * slab_depth
+
+    nframes = len(univ.trajectory[start:end])
+
+    print(f"Compute 2D atomic density of {type_str} atoms...")
+
+    pos_a_list, pos_b_list = [], []
+    for ts in tqdm(univ.trajectory[start:end]):
+        posi, posj = sel.positions[:, axida], sel.positions[:, axidb]
+
+        posi = sel.positions[:, axida] % box[axida]
+        posj = sel.positions[:, axidb] % box[axidb]
+
+        pos_a_list.append(posi)
+        pos_b_list.append(posj)
+
+    pos_a = np.concatenate(pos_a_list)
+    pos_b = np.concatenate(pos_b_list)
+
+    hist, edges_a, edges_b = np.histogram2d(pos_a, pos_b, bins=(bins_a, bins_b))
+
+    ra = (edges_a[1:] + edges_a[:-1]) / 2
+    rb = (edges_b[1:] + edges_b[:-1]) / 2
+
+    density = hist / column_vol / nframes * 1000
+
+    return pd.DataFrame(density, index=ra, columns=rb)
+
+
+def find_interfaces_coordinates(
+    input_df: pd.DataFrame, solid_types: list[str | int], liquid_types: list[str | int]
+) -> tuple[float, float, float, float]:
+    """Calculate the solid/liquid interface coordinates for an interfacial system.
+
+    Parameters
+    ----------
+    input_df : pd.DataFrame
+        Input DataFrame of 1D atomic density profiles.
+    solid_types : list
+        List of atom types composing the solid phase.
+    liquid_types : list
+        List of atom types composing the liquid phase.
+
+    Returns
+    -------
+    tuple
+        Left liquid interface, left solid interface, right solid interface,
+        and right liquid interface coordinates.
+    """
+
+    solid_series = pd.Series(input_df[solid_types].max(axis=1), index=input_df.index)
+    liquid_series = pd.Series(input_df[liquid_types].max(axis=1), index=input_df.index)
+
+    # On the left
+    solid_left = (solid_series == 0).idxmax()
+    solution_left = (liquid_series != 0).idxmax()
+
+    # On the right
+    df_solide_r = solid_series[::-1]
+    df_solution = liquid_series.loc[solution_left:]
+    solid_right = (df_solide_r == 0).idxmax()
+    solution_right = (df_solution == 0).idxmax()
+
+    return solution_left, solid_left, solid_right, solution_right
+
+
+def shift_profile(
+    input_df: pd.DataFrame, shift: float, csv_output: str = "new_density_profile.csv"
+):
+    """Shift the coordinates of a 1D density profile.
+
+    Parameters
+    ----------
+    input_df : pd.DataFrame
+        Input DataFrame of 1D atomic density profiles.
+    shift : float
+        Positive or negative shift in Angstroms.
+    csv_output : str
+        Output CSV file path.
+
+    Returns
+    -------
+    pd.DataFrame
+        Shifted density profile data.
+    """
+
+    # to avoid pylint warning
+    # pylint: disable=E1101
+    columns = input_df.columns
+
+    r = input_df.index.values
+    dr = r[1] - r[0]
+    densities = input_df.values
+
+    idx = int(shift / dr)
+    new_densities = np.roll(densities, idx, axis=0)
+
+    new_data = np.hstack((r.reshape(r.size, 1), new_densities))
+
+    output_df = pd.DataFrame(new_data, columns=columns)
+
+    if csv_output is not None:
+        output_df.to_csv(csv_output)
+
+    return output_df
+
+
+def electrostatic_potential(
+    input_df: pd.DataFrame, list_charges: list[float]
+) -> tuple[pd.Series, pd.Series, pd.Series]:
+    """Calculate charge distribution, electric field, and electrostatic potential.
+
+    Parameters
+    ----------
+    input_df : pd.DataFrame
+        DataFrame of atomic densities.
+    list_charges : list
+        List of charges for each atom type in the CSV file.
+
+    Returns
+    -------
+    charge_density : pd.Series
+        Calculated charge density profile.
+    efield : pd.Series
+        Calculated electric field profile.
+    potential : pd.Series
+        Calculated electrostatic potential profile.
+    """
+
+    def shift_constant(array: np.ndarray, threshold: float = 0.1) -> np.ndarray:
+        """Shifts the array by subtracting the mean of its constant (flat) regions.
+
+        This function automatically detects stationary or flat regions within a 1D signal by analyzing relative consecutive differences. It computes the average intensity of the signal across these stable baselines and subtracts it from the entire array, effectively centering the baseline/background around zero.
+
+        Parameters
+        ----------
+            array
+            The 1D input array containing the signal to be corrected.
+            threshold
+            The maximum relative difference between consecutive elements to consider a region as 'constant' or flat. Evaluated after scaling the array by its maximum value.
+
+        Returns:
+            np.ndarray: The baseline-corrected array where the flat regions
+                are centered around zero.
+
+        Example:
+            >>> signal = np.array([10.0, 10.1, 10.0, 25.0, 50.0, 10.2, 10.0])
+            >>> shift_constant(signal, threshold=0.02)
+            array([-0.025,  0.075, -0.025, 14.975, 39.975,  0.175, -0.025])
+        """
+
+        narr = array / array.max()
+        # Calculate the absolute differences between consecutive elements
+        differences = np.abs(np.diff(narr))
+
+        # Identify indices where the difference is within the threshold
+        constant_indices = np.where(differences <= threshold)[0]
+
+        # Adjust indices to include the next element in the array
+        constant_indices = np.append(constant_indices, constant_indices + 1)
+
+        # Get unique indices and sort them
+        constant_indices = np.unique(constant_indices)
+
+        result_array = array - np.mean(array[constant_indices])
+
+        return result_array
+
+    charge = np.array(list_charges)
+
+    r = input_df.index
+    dr = (r[1] - r[0]) * 1e-10
+
+    charge_density = np.sum(input_df.values * charge.T, axis=1)
+    charge_density_series = pd.Series(charge_density, index=r)
+
+    efield = (
+        integrate.cumulative_trapezoid(charge_density * 1.602e-19 * 1e27, dx=dr)
+        / 8.854e-12
+    )
+    r = (r[1:] + r[:-1]) / 2
+    efield_series = pd.Series(shift_constant(efield), index=r)
+
+    potential = -integrate.cumulative_trapezoid(efield, dx=dr)
+    r = (r[1:] + r[:-1]) / 2
+    potential_series = pd.Series(shift_constant(potential), index=r)
+
+    return charge_density_series, efield_series, potential_series