adsorption 0.0.1__py3-none-any.whl

adsorption/__init__.py

@@ -0,0 +1,3 @@
+from ._interface import Adsorption  # noqa: D104
+
+__all__ = ["Adsorption"]

adsorption/_interface.py

@@ -0,0 +1,320 @@
+import numpy as np
+import numpy.typing as npt
+from ase.atom import Atom
+from ase.atoms import Atoms
+from ase.build import molecule
+from ase.calculators.calculator import Calculator
+from ase.constraints import FixAtoms, FixBondLengths
+from ase.data import chemical_symbols as SYMBOLS
+from ase.data import covalent_radii as COV_R
+from ase.optimize import LBFGS
+from scipy.optimize import OptimizeResult, minimize
+from scipy.spatial.distance import cdist
+from scipy.spatial.transform import Rotation
+from skopt import gp_minimize
+
+from adsorption.calculator import get_calculator
+from adsorption.rotation import kabsch, rotate
+
+
+class Adsorption:
+    """The class for adsorption calculations."""
+
+    def __init__(
+        self,
+        atoms: Atoms,
+        adsorbate: Atoms | Atom | str,
+        calculator: Calculator | str = "gfnff",
+        core: npt.ArrayLike | list[int] | int = 0,
+        adsorbate_index: int | None = None,
+    ) -> None:
+        """Initialize the adsorption calculation.
+
+        Args:
+        atoms (Atoms): The surface or cluster
+            onto which the adsorbate should be added.
+        adsorbate (Atoms | Atom | str): The adsorbate.
+            Must be one of the following three types:
+                1. An atoms object (for a molecular adsorbate).
+                2. An atom object.
+                3. A string:
+                    the chemical symbol for a single atom.
+                    the molecule string by `ase.build`.
+                    the SMILES of the molecule.
+        calculator (Calculator | str, optional): The SPE Calculator.
+            Must be one of the following three types:
+                1. A string that contains the calculator name
+                2. Calculator object
+            Defaults to "gfnff".
+        core (npt.ArrayLike | list[int] | int, optional):
+            The central atoms (core) which will place at.
+            Defaults to the first atom, i.e. the 0-th atom.
+        adsorbate_index (int | None, optional): The index of the adsorbate.
+            Defaults to None. It means that the adsorbate's core is its COM.
+            If it is interger, it means that the adsorbate's core is the atom.
+        """
+        assert isinstance(atoms, Atoms), "Input must be of type Atoms."
+        self.__atoms = atoms
+
+        # Convert the adsorbate to an Atoms object
+        if isinstance(adsorbate, Atoms):
+            ads = adsorbate
+        elif isinstance(adsorbate, Atom):
+            ads = Atoms([adsorbate])
+        elif isinstance(adsorbate, str):
+            if adsorbate in SYMBOLS:
+                ads = Atoms([Atom(adsorbate)])
+            else:
+                try:
+                    ads = molecule(adsorbate)
+                except Exception:
+                    # TODO: convert SMILES into atoms.
+                    ads = None
+        assert isinstance(ads, Atoms), f"{adsorbate} is not a valid adsorbate."
+        self.__adsorbate = ads
+
+        if len(ads) == 0:
+            raise ValueError("The adsorbate must have at least one atom.")
+        elif len(ads) == 1:
+            adsorbate_index = 0
+        else:
+            if adsorbate_index is None:
+                com_ads = ads.get_center_of_mass()
+                v2com_ads = ads.positions - com_ads
+                d2com_ads = np.linalg.norm(v2com_ads, axis=1)
+                adsorbate_index = int(np.argmin(d2com_ads))
+        assert isinstance(adsorbate_index, int), (
+            "The adsorbate_index must be None or integer."
+        )
+        self.__adsorbate_index = adsorbate_index
+
+        # Convert the calculator to a calculator object
+        if isinstance(calculator, str):
+            calculator = get_calculator(calculator)
+        assert isinstance(calculator, Calculator), (
+            f"{calculator} is not a valid calculator."
+        )
+        self.__calculator = calculator
+
+        # Convert the core atoms to a list of integers (np.ndarray)
+        core = [core] if isinstance(core, int) else core
+        self.__core = np.asarray(core, dtype=int)
+
+    def __call__(self, *args, mode: str = "scipy", **kwds) -> Atoms:  # noqa: D417
+        """Run the adsorption calculation.
+
+        Args:
+            mode (str, optional): The mode of the calculation.
+                If it is "guess", only guess initial structure.
+                If it is "scipy", use `scipy.optimize.minimize` as backend.
+                If it is "bayesian", use `skopt.gp_minimize` as backend.
+                If it is "ase", use `ase.optimize.optimize` as backend.
+
+        """
+        self.__backend_name: str = f"_add_adsorbate_{mode}"
+        assert hasattr(self, self.__backend_name), f"Invalid mode: {mode}."
+        return getattr(self, self.__backend_name)(*args, **kwds)
+
+    def __funcxbounds(self) -> list[tuple[float, float]]:
+        com_ads = self.__adsorbate.get_center_of_mass()
+        covradii_ads = np.mean(COV_R[self.__adsorbate.numbers])
+        covradii_core = np.mean(COV_R[self.__atoms.numbers[self.__core]])
+        com_core = Atoms(self.__atoms[self.__core]).get_center_of_mass()
+        xyz_ads = np.max(self.__adsorbate.positions - com_ads, axis=0)
+        xyz_ads = np.abs(xyz_ads) + covradii_ads + covradii_core
+        result = [
+            (
+                v - xyz_ads[i],
+                v + xyz_ads[i],
+            )
+            for i, v in enumerate(com_core)
+        ]
+        for _ in range(4):
+            result.append((-1, 1))
+        return result
+
+    def __func2atoms(self, x) -> Atoms:
+        x = np.asarray(x, dtype=float).flatten()
+        assert x.ndim == 1 and x.shape == (7,)
+        return _add_adsorbate(
+            atoms=self.__atoms,
+            adsorbate=self.__adsorbate,
+            translation=np.asarray(x[4:7]),
+            rotation=Rotation.from_quat(x[:4], scalar_first=False),
+        )
+
+    def __func2energy(self, x) -> float:
+        natoms = len(self.__atoms)
+        nads = len(self.__adsorbate)
+        ads_idx = list(range(natoms, natoms + nads))
+        core_and_ads = np.append(self.__core, ads_idx).astype(int)
+        new_atoms = self.__func2atoms(x)
+        pos = new_atoms.positions
+        d = cdist(pos[core_and_ads], pos)
+        mask = np.sum(d < 8, axis=0).astype(bool)
+        assert mask.ndim == 1 and mask.shape == (len(new_atoms),)
+        calc_atoms = Atoms(new_atoms[mask], calculator=self.__calculator)
+        return calc_atoms.get_potential_energy()
+
+    def __funcx0(self) -> npt.ArrayLike:
+        r, t = _add_adsorbate_guess(
+            atoms=self.__atoms,
+            adsorbate=self.__adsorbate,
+            core=self.__core,
+            adsorbate_index=None,
+        )
+        r_quat = r.as_quat(
+            canonical=True,
+            scalar_first=False,
+        )
+        return np.append(r_quat, t)
+
+    def _add_adsorbate_scipy(self) -> Atoms:
+        result = minimize(
+            fun=self.__func2energy,
+            x0=self.__funcx0(),
+            bounds=self.__funcxbounds(),
+        )
+        if result.success:
+            return self.__func2atoms(result.x)
+        else:
+            raise RuntimeError("The optimization failed.")
+
+    def _add_adsorbate_bayesian(self) -> Atoms:
+        result = gp_minimize(
+            func=self.__func2energy,
+            dimensions=self.__funcxbounds(),
+            x0=self.__funcx0(),
+        )
+        if isinstance(result, OptimizeResult):
+            return self.__func2atoms(result.x)
+        else:
+            raise RuntimeError("The bayesian optimization failed.")
+
+    def _add_adsorbate_ase(self) -> Atoms:
+        pair = np.triu_indices(len(self.__adsorbate), k=1)
+        iatoms = self._add_adsorbate_guess()
+        iatoms.calc = self.__calculator
+        iatoms.set_constraint(
+            [
+                FixBondLengths(np.column_stack(pair)),
+                FixAtoms(indices=list(range(len(self.__atoms)))),
+            ]
+        )
+        opt = LBFGS(iatoms, logfile=None, trajectory=None)  # type: ignore
+        opt.run(fmax=0.03, steps=100)
+        return Atoms(
+            numbers=iatoms.numbers,
+            positions=iatoms.positions,
+            cell=iatoms.cell,
+            pbc=iatoms.pbc,
+        )
+
+    def _add_adsorbate_guess(self) -> Atoms:
+        rotation, translation = _add_adsorbate_guess(
+            atoms=self.__atoms,
+            adsorbate=self.__adsorbate,
+            core=self.__core,
+            adsorbate_index=self.__adsorbate_index,
+        )
+
+        return _add_adsorbate(
+            atoms=self.__atoms,
+            adsorbate=self.__adsorbate,
+            translation=translation,
+            rotation=rotation,
+        )
+
+
+def _add_adsorbate(
+    atoms: Atoms,
+    adsorbate: Atoms,
+    translation: npt.ArrayLike,
+    rotation: Rotation,
+) -> Atoms:
+    """Add an adsorbate to a surface or cluster.
+
+    Args:
+        atoms (Atoms): The surface or cluster.
+        adsorbate (Atoms): The adsorbate molecule.
+        translation (npt.ArrayLike): The translation vector (3D).
+        rotation (Rotation): The rotation matrix.
+
+    Returns:
+        Atoms: The surface or cluster with adsorbate after optimization.
+    """
+    assert isinstance(atoms, Atoms), "Input must be of type Atoms."
+    assert isinstance(adsorbate, Atoms), "Adsorbate must be of type Atoms."
+    assert isinstance(rotation, Rotation), "Rotation must be of type Rotation."
+
+    translation = np.asarray(translation, dtype=float).flatten()
+    assert translation.shape == (3,), "The translation must be a 3D vector."
+
+    adsorbate_positions = rotate(
+        rotation=rotation,
+        points=adsorbate.positions,
+        center=None,  # around geometry center
+    )
+    adsorbate_positions += translation
+    return Atoms(
+        numbers=np.append(atoms.numbers, adsorbate.numbers),
+        positions=np.vstack((atoms.positions, adsorbate_positions)),
+        cell=atoms.cell,
+        pbc=atoms.pbc,
+    )
+
+
+def _add_adsorbate_guess(
+    atoms: Atoms,
+    adsorbate: Atoms,
+    core: npt.ArrayLike,
+    adsorbate_index: int | None = None,
+) -> tuple[Rotation, np.ndarray]:
+    """Guess the distance and rotation of the adsorbate.
+
+    Returns:
+        rotation (Rotation): The rotation matrix.
+        translation (npt.ArrayLike): The translation vector (3D).
+    """
+    assert isinstance(atoms, Atoms), "Input must be of type Atoms."
+    assert isinstance(adsorbate, Atoms), "Adsorbate must be of type Atoms."
+
+    core = [core] if isinstance(core, int) else core
+    core = np.asarray(core, dtype=int).flatten()
+    assert isinstance(core, np.ndarray) and core.ndim == 1 and core.size > 0, (
+        "The core must be a 1D array-like object with at least one element."
+    )
+    assert np.all(core < len(atoms)), "The core must be within the atoms."
+    assert np.all(core >= 0), "The core must be non-negative."
+    cov_radii_core = np.mean(COV_R[atoms.numbers[core]])
+
+    com_atoms = atoms.get_center_of_mass()
+    com_core = Atoms(atoms[core]).get_center_of_mass()
+    direction: np.ndarray = com_core - com_atoms
+    direction /= np.linalg.norm(direction)
+
+    com_ads = adsorbate.get_center_of_mass()
+    if len(adsorbate) == 0:
+        raise ValueError("The adsorbate must have at least one atom.")
+    elif len(adsorbate) == 1:
+        adsorbate_index = 0
+    else:
+        if adsorbate_index is None:
+            v2com_ads = adsorbate.positions - com_ads
+            d2com_ads = np.linalg.norm(v2com_ads, axis=1)
+            adsorbate_index = int(np.argmin(d2com_ads))
+    assert isinstance(adsorbate_index, int), (
+        "The adsorbate_index must be None or integer."
+    )
+    ref_pos = adsorbate.positions[adsorbate_index]
+    B = np.asarray([ref_pos, com_ads])
+
+    _d2ref = COV_R[adsorbate.numbers[adsorbate_index]] + cov_radii_core
+    _d2com = float(np.linalg.norm(ref_pos - com_ads)) + _d2ref
+    target_ref_pos = com_core + _d2ref * direction
+    target_com_ads = com_core + _d2com * direction
+    A = np.asarray([target_ref_pos, target_com_ads])
+
+    rotation, translation, rmsd = kabsch(A, B)
+    assert rmsd < 1e-5, "The guess rotation are not good enough."
+    return rotation, translation

adsorption/calculator.py

@@ -0,0 +1,237 @@
+from typing import Optional
+
+import numpy as np
+from ase.atoms import Atoms
+from ase.calculators import calculator as ase_calc
+from pygfn0 import GFN0
+from pygfnff import GFNFF
+from typing_extensions import override
+
+__LJ_PARAM_OPENKIM = np.fromstring(
+    sep=" ",
+    dtype=float,
+    # https://openkim.org/files/MO_959249795837_003/LennardJones612_UniversalShifted.params
+    #   cutoff(Å)       epsilon(eV)     sigma(Å)
+    string="""
+        4.0000000       1.000000000     1.0000000
+        2.2094300       4.4778900       0.5523570
+        1.9956100       0.0009421       0.4989030
+        9.1228000       1.0496900       2.2807000
+        6.8421000       0.5729420       1.7105300
+        6.0581100       2.9670300       1.5145300
+        5.4166600       6.3695300       1.3541700
+        5.0603000       9.7537900       1.2650800
+        4.7039500       5.1264700       1.1759900
+        4.0625000       1.6059200       1.0156200
+        4.1337700       0.0036471       1.0334400
+        11.8311000      0.7367450       2.9577800
+        10.0493000      0.0785788       2.5123300
+        8.6239000       2.7006700       2.1559700
+        7.9111800       3.1743100       1.9778000
+        7.6260900       5.0305000       1.9065200
+        7.4835500       4.3692700       1.8708900
+        7.2697300       4.4832800       1.8174300
+        7.5548200       0.0123529       1.8887100
+        14.4682000      0.5517990       3.6170500
+        12.5439000      0.1326790       3.1359600
+        12.1162000      1.6508000       3.0290600
+        11.4035000      1.1802700       2.8508800
+        10.9046000      2.7524900       2.7261500
+        9.9067900       1.5367900       2.4767000
+        9.9067900       0.5998880       2.4767000
+        9.4078900       1.1844200       2.3519700
+        8.9802600       1.2776900       2.2450600
+        8.8377200       2.0757200       2.2094300
+        9.4078900       2.0446300       2.3519700
+        8.6951700       0.1915460       2.1737900
+        8.6951700       1.0642000       2.1737900
+        8.5526300       2.7017100       2.1381600
+        8.4813600       3.9599000       2.1203400
+        8.5526300       3.3867700       2.1381600
+        8.5526300       1.9706300       2.1381600
+        8.2675400       0.0173276       2.0668900
+        15.6798000      0.4682650       3.9199500
+        13.8980000      0.1339230       3.4745100
+        13.5417000      2.7597500       3.3854200
+        12.4726000      3.0520100       3.1181500
+        11.6886000      5.2782000       2.9221500
+        10.9759000      4.4749900       2.7439700
+        10.4770000      3.3815900       2.6192400
+        10.4057000      1.9617200       2.6014200
+        10.1206000      2.4058200       2.5301500
+        9.9067900       1.3709700       2.4767000
+        10.3344000      1.6497600       2.5836100
+        10.2632000      0.0377447       2.5657900
+        10.1206000      0.8113140       2.5301500
+        9.9067900       1.9005700       2.4767000
+        9.9067900       3.0882800       2.4767000
+        9.8355200       2.6312300       2.4588800
+        9.9067900       1.5393800       2.4767000
+        9.9780700       0.0238880       2.4945200
+        17.3903000      0.4166420       4.3475900
+        15.3235000      1.9000000       3.8308600
+        14.7533000      2.4996100       3.6883200
+        14.5395000      2.5700800       3.6348700
+        14.4682000      1.2994600       3.6170500
+        14.3257000      0.8196050       3.5814100
+        14.1831000      3.2413400       3.5457800
+        14.1118000      0.5211220       3.5279600
+        14.1118000      0.4299180       3.5279600
+        13.9693000      2.0995600       3.4923200
+        13.8267000      1.3999900       3.4566900
+        13.6842000      0.6900550       3.4210500
+        13.6842000      0.6900550       3.4210500
+        13.4704000      0.7387660       3.3676000
+        13.5417000      0.5211220       3.3854200
+        13.3278000      0.1303990       3.3319600
+        13.3278000      1.4331500       3.3319600
+        12.4726000      3.3608600       3.1181500
+        12.1162000      4.0034300       3.0290600
+        11.5460000      6.8638900       2.8865100
+        10.7621000      4.4387100       2.6905100
+        10.2632000      4.2625300       2.5657900
+        10.0493000      3.7028700       2.5123300
+        9.6929800       3.1401000       2.4232400
+        9.6929800       2.3058000       2.4232400
+        9.4078900       0.0454140       2.3519700
+        10.3344000      0.5770870       2.5836100
+        10.4057000      0.8589880       2.6014200
+        10.5482000      2.0798700       2.6370600
+        9.9780700       1.8995300       2.4945200
+        10.6908000      1.3854420       2.6727000
+        10.6908000      0.0214992       2.6727000
+        18.5307000      0.3749778       4.6326700
+        15.7511000      1.7100000       3.9377700
+        15.3235000      2.2496490       3.8308600
+        14.6820000      2.3130720       3.6705000
+        14.2544000      1.1695140       3.5635900
+        13.9693000      0.7376445       3.4923200
+        13.5417000      2.9172060       3.3854200
+        13.3278000      0.4690098       3.3319600
+        12.8289000      0.3869262       3.2072400
+        12.0450000      1.8896040       3.0112400
+        11.9737000      1.2599910       2.9934200
+        11.9737000      0.6210495       2.9934200
+        11.7599000      0.6210495       2.9399700
+        11.9024000      0.6648894       2.9756000
+        12.3300000      0.4690098       3.0825100
+        12.5439000      0.1173591       3.1359600
+        11.4748000      1.2898350       2.8686900
+        11.1897000      3.0247740       2.7974200
+        10.6195000      3.6030870       2.6548800
+        10.1919000      6.1775010       2.5479700
+        10.0493000      3.9948390       2.5123300
+        9.5504300       3.8362770       2.3876100
+        9.1940700       3.3325830       2.2985200
+        9.1228000       2.8260900       2.2807000
+        8.6239000       2.0752200       2.1559700
+        8.6951700       0.0408726       2.1737900
+        9.6929800       0.5193783       2.4232400
+        10.1919000      0.7730892       2.5479700
+        11.5460000      1.8718830       2.8865100
+        12.4726000      1.7095770       3.1181500
+        11.7599000      1.2468978       2.9399700
+        11.1897000      0.0193493       2.7974200""",
+).reshape(-1, 3)
+LJ_EPSILON = __LJ_PARAM_OPENKIM[:, 1]
+LJ_CUTOFF = __LJ_PARAM_OPENKIM[:, 0]
+LJ_SIGMA = __LJ_PARAM_OPENKIM[:, 2]
+__ASE_CALCULATORS_DICT: dict[str, ase_calc.Calculator] = {
+    "gfn0": GFN0(),
+    "gfnff": GFNFF(),
+}
+
+
+class LennardJones(ase_calc.Calculator):
+    """Lennard-Jones interaction calculator based on openkim database."""
+
+    implemented_properties = [
+        "energy",
+        "forces",
+    ]
+
+    @override
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.epsilon = LJ_EPSILON
+        self.cutoff = LJ_CUTOFF
+        self.sigma = LJ_SIGMA
+
+    def __get_parameters_matrix(
+        self,
+        numbers: np.ndarray,
+        parameters: np.ndarray,
+    ) -> np.ndarray:
+        """Construct an interaction parameters matrix."""
+        parameters = np.asarray(parameters, dtype=float)
+        numbers = np.asarray(numbers, dtype=int)
+        array = parameters[numbers]
+        return np.sqrt(array[:, None] * array[None, :])
+
+    @override
+    def calculate(
+        self,
+        atoms: Optional[Atoms] = None,
+        properties: Optional[list[str]] = None,
+        system_changes: list[str] = ase_calc.all_changes,
+    ) -> None:
+        """Perform actual calculation by GFNFF."""
+        super().calculate(atoms, properties, system_changes)
+        assert isinstance(self.atoms, Atoms)
+        if any(self.atoms.pbc) or self.atoms.cell.array.any():
+            raise ase_calc.CalculatorSetupError(
+                "PBC system is not supported yet by pygfnff backend."
+            )
+        Z, X = self.atoms.numbers, self.atoms.positions
+        rc = self.__get_parameters_matrix(Z, self.cutoff)
+        epsilon = self.__get_parameters_matrix(Z, self.epsilon)
+        sigma = self.__get_parameters_matrix(Z, self.sigma)
+
+        diff = X[:, None, :] - X[None, :, :]
+        r2 = np.sum(diff**2, axis=-1)  # Squared distances (N, N)
+        r = np.sqrt(r2)  # Actual distances (N, N)
+
+        # Handle self-interaction: set diagonal distances to rc + small epsilon
+        np.fill_diagonal(r, rc + 1e-8)
+
+        # Compute σ/r (N, N)
+        s = sigma / r
+
+        # Create mask: retain only pairs with r < rc
+        mask = r < rc
+
+        # Compute potential energy matrix (only valid pairs contribute)
+        V_matrix = np.where(mask, 4 * epsilon * (s**12 - s**6), 0.0)
+
+        # Total energy: sum over upper triangle
+        #   (i < j pairs, skip diagonal with k=1)
+        energy = np.triu(V_matrix, k=1).sum()
+
+        # Compute force matrix (N, N, 3)
+        # Derivative of V w.r.t. r: dV/dr = 24ε(σ⁶/r⁷ - 2σ¹²/r¹³)
+        inv_r7 = 1.0 / (r**7)
+        inv_r13 = 1.0 / (r**13)
+        dV_dr = 24 * epsilon * (sigma**6 * inv_r7 - 2 * sigma**12 * inv_r13)
+
+        # Force direction: unit vector from i to j
+        force_dir = diff / r[..., None]  # (N, N, 3)
+
+        # Force matrix: force_matrix[i,j] is the force on i due to j
+        force_matrix = dV_dr[..., None] * force_dir  # Broadcast multiplication
+
+        # Apply cutoff mask (set forces to 0 where r >= rc)
+        force_matrix = np.where(mask[..., None], force_matrix, 0.0)
+
+        # Total forces: sum forces acting on each atom (axis=1)
+        forces = np.sum(force_matrix, axis=1)
+
+        self.results.update(dict(energy=energy, forces=-forces))
+
+
+__ASE_CALCULATORS_DICT["lennard_jones"] = LennardJones()
+__ASE_CALCULATORS_DICT["lj"] = __ASE_CALCULATORS_DICT["lennard_jones"]
+__ASE_CALCULATORS_DICT["lj_openkim"] = __ASE_CALCULATORS_DICT["lennard_jones"]
+
+
+def get_calculator(calculator: str) -> ase_calc.Calculator:  # noqa: D103
+    return __ASE_CALCULATORS_DICT[calculator]

adsorption/rotation.py

@@ -0,0 +1,101 @@
+from warnings import catch_warnings, filterwarnings
+
+import numpy as np
+from numpy import typing as npt
+from scipy.spatial.transform import Rotation as Rot
+
+
+def rotate(
+    points: npt.ArrayLike,
+    rotation: Rot = Rot.random(),
+    center: npt.ArrayLike | None = None,
+) -> np.ndarray:
+    """Rotate 3D points by the provided rotation around a given center.
+
+    Default rotation center is the geometry center of the given points.
+
+    Args:
+        points (npt.ArrayLike): The 3D points to rotate.
+        rotation (Rot, optional): The rotation. Defaults to Rot.random().
+        center (npt.ArrayLike, optional): The center of the rotation.
+            Defaults to None which means that rotation will take
+                place around the geometry center of input points.
+
+    Returns:
+        np.ndarray: The points after rotation.
+    """
+    assert isinstance(rotation, Rot), (
+        "Rotation must be an instance of scipy.spatial.transform.Rotation."
+    )
+
+    points = np.asarray(points, dtype=float)
+    if points.ndim != 2 or points.shape[-1] != 3:
+        raise ValueError("Points must be an array of 3D points.")
+
+    if center is None:
+        center = points.mean(axis=0)
+    else:
+        center = np.asarray(center, dtype=float)
+    assert (
+        isinstance(center, np.ndarray)
+        and center.ndim == 1
+        and center.shape[0] == 3
+    ), "Center must be a 3D vector."
+
+    return rotation.apply(points - center) + center
+
+
+def kabsch(
+    A: npt.ArrayLike,
+    B: npt.ArrayLike,
+) -> tuple[Rot, np.ndarray, float]:
+    """Find rotation matrix and translation vector for convert A into B.
+
+    This method solves and returns the R & t in
+        A = rotate(B) + t
+        where A & B are Nx3 matrices for point coordinates,
+            R is the scipy Rotation object, and
+            t is the 3D translation vector.
+
+    See details:
+        https://nghiaho.com/?page_id=671
+        https://github.com/nghiaho12/rigid_transform_3D
+        https://blog.csdn.net/u012836279/article/details/80203170
+        https://blog.csdn.net/u012836279/article/details/80351462
+    Advanced Methods:
+        https://github.com/mammasmias/IterativeRotationsAssignments
+        https://pubs.acs.org/doi/10.1021/acs.jcim.2c01187
+
+    Returns:
+        Tuple[np.ndarray, np.ndarray]:
+            The first item is rotation matrix which is the instance
+                instance of scipy.spatial.transform.Rotation.
+            The second item is translation vector.
+            The third item is the RMSD value.
+    """
+    A, B = np.asarray(A, dtype=float), np.asarray(B, dtype=float)
+    if A.ndim != 2 or B.ndim != 2:
+        raise ValueError("Arrays must be of 2D arrays.")
+    if A.shape[-1] != 3 or B.shape[-1] != 3:
+        raise ValueError("Array elements must be 3D vectors.")
+    assert isinstance(A, np.ndarray) and isinstance(B, np.ndarray)
+
+    # find mean/centroid
+    centroid_A: np.ndarray = np.mean(A, axis=0)
+    centroid_B: np.ndarray = np.mean(B, axis=0)
+
+    # subtract mean
+    # NOTE: doing A -= centroid_A will modifiy input!
+    A, B = A - centroid_A, B - centroid_B
+    assert np.all(np.abs(np.mean(A, axis=0)) < 1e-5)
+    assert np.all(np.abs(np.mean(B, axis=0)) < 1e-5)
+
+    with catch_warnings():
+        filterwarnings("ignore", category=UserWarning)
+        rotation, rmsd = Rot.align_vectors(
+            A,
+            B,
+            weights=None,
+            return_sensitivity=False,
+        )
+    return rotation, centroid_A - centroid_B, rmsd

adsorption-0.0.1.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: adsorption
+Version: 0.0.1
+Summary: Adsorption Based on ASE
+Author-email: LiuGaoyong <liugaoyong_88@163.com>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ase
+Requires-Dist: numpy
+Requires-Dist: pygfn0>=0.0.2
+Requires-Dist: pygfnff>=0.0.2
+Requires-Dist: scikit-learn
+Requires-Dist: scikit-optimize>=0.10.2
+Requires-Dist: scipy
+Requires-Dist: typing-extensions
+Dynamic: license-file
+
+# Adsorption
+
+[![Pypi version](https://img.shields.io/pypi/v/adsorption)](https://pypi.org/project/adsorption/)
+[![Pypi downloads](https://img.shields.io/pypi/dm/adsorption)](https://pypi.org/project/adsorption/)
+[![Pypi downloads](https://img.shields.io/pypi/dw/adsorption)](https://pypi.org/project/adsorption/)
+[![Pypi downloads](https://img.shields.io/pypi/dd/adsorption)](https://pypi.org/project/adsorption/)
+
+The Adsorption package is a Python package for the adsorption of molecules on clusters or surfaces.