phonopy 4.2.0__tar.gz → 4.2.1__tar.gz

{phonopy-4.2.0 → phonopy-4.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phonopy
-Version: 4.2.0
+Version: 4.2.1
 Summary: This is the phonopy module.
 Author-Email: Atsushi Togo <atz.togo@gmail.com>
 License-Expression: BSD-3-Clause

{phonopy-4.2.0 → phonopy-4.2.1}/phonopy/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '4.2.0'
-__version_tuple__ = version_tuple = (4, 2, 0)
+__version__ = version = '4.2.1'
+__version_tuple__ = version_tuple = (4, 2, 1)
 
-__commit_id__ = commit_id = 'g5d908eee6'
+__commit_id__ = commit_id = 'g0cf619fe7'

{phonopy-4.2.0 → phonopy-4.2.1}/phonopy/api_phonopy.py

@@ -181,6 +181,7 @@ class Phonopy:
         group_velocity_delta_q: float | None = None,
         symprec: float = 1e-5,
         is_symmetry: bool = True,
+        distinguish_symbol_index: bool = False,
         use_SNF_supercell: bool = False,
         hermitianize_dynamical_matrix: bool = True,
         calculator: str | None = None,
@@ -210,6 +211,13 @@ class Phonopy:
         is_symmetry : bool, optional
             Whether to search symmetry of the supercell. Default is
             True.
+        distinguish_symbol_index : bool, optional
+            When True, atoms whose symbols differ only in the numeric
+            suffix ("Cl" vs "Cl1") are treated as distinct species in
+            the symmetry search and in the automatic primitive matrix
+            determination. By default (False) the suffix is a
+            calculator-facing label that does not affect symmetry.
+            Default is False.
         use_SNF_supercell : bool, optional
             Build the supercell with the SNF algorithm when True.
             Default is False. The SNF algorithm is faster than the
@@ -234,6 +242,7 @@ class Phonopy:
         log_dispatch(lang, "Phonopy.__init__")
         self._symprec = symprec
         self._is_symmetry = is_symmetry
+        self._distinguish_symbol_index = distinguish_symbol_index
         self._hermitianize_dynamical_matrix = hermitianize_dynamical_matrix
         self._calculator = calculator
         self._lang: Literal["C", "Rust"] = lang
@@ -249,7 +258,10 @@ class Phonopy:
         self._unitcell = unitcell.copy()
         self._supercell_matrix = shape_supercell_matrix(supercell_matrix)
         self._primitive_matrix = get_primitive_matrix_with_auto(
-            self._unitcell, primitive_matrix, symprec=self._symprec
+            self._unitcell,
+            primitive_matrix,
+            symprec=self._symprec,
+            distinguish_symbol_index=self._distinguish_symbol_index,
         )
         warn_if_primitive_matrix_auto_changed_cell(
             primitive_matrix, self._primitive_matrix
@@ -3606,7 +3618,7 @@ class Phonopy:
         # calculator path remains unchanged. The raw forces in
         # ``self._dataset`` are kept intact. Reduction convention is
         # picked from the calculator: VASP uses a plain sum because its
-        # vasprun.xml forces already carry the VCA weight factor.
+        # vasprun.xml forces already carry the mixture weight factor.
         dataset_for_fc = self._dataset
         if self._supercell.has_mixtures:
             dataset_for_fc = _reduce_mixture_dataset_forces(
@@ -3614,6 +3626,11 @@ class Phonopy:
                 self._supercell,
                 mode=_mixture_reduce_mode_for_calculator(self._calculator),
             )
+        # Non-merge site-mixture (weighted real species) cells use the
+        # ordinary finite-difference path: the raw VASP forces and real
+        # displacements give the symmetric force constants G that satisfy
+        # the ordinary sum rule, so the standard symmetrizer applies. The
+        # concentration weights x do not enter the force constants.
 
         self._force_constants = get_fc2(
             self._supercell,
@@ -3724,11 +3741,16 @@ class Phonopy:
             self._is_symmetry,
             s2p_map=self._primitive.s2p_map,
             lang=self._lang,
+            distinguish_symbol_index=self._distinguish_symbol_index,
         )
 
     def _search_primitive_symmetry(self) -> None:
         self._primitive_symmetry = Symmetry(
-            self._primitive, self._symprec, self._is_symmetry, lang=self._lang
+            self._primitive,
+            self._symprec,
+            self._is_symmetry,
+            lang=self._lang,
+            distinguish_symbol_index=self._distinguish_symbol_index,
         )
 
         if len(self._symmetry.pointgroup_operations) != len(
@@ -3900,11 +3922,11 @@ def _mixture_reduce_mode_for_calculator(
 ) -> Literal["weighted_sum", "sum"]:
     """Return the mixture-reduce convention appropriate for ``calculator``.
 
-    VASP applies the VCA weights inside the SCF, so the per-row forces in
+    VASP folds the mixture weights into the SCF, so the per-row forces in
     vasprun.xml already carry the weight factor: a plain sum across
     constituents is correct. Other calculators have not yet been wired
     for site-mixture; for them we default to the explicit weighted sum
-    so the per-site force matches the standard VCA expression.
+    so the per-site force matches the standard weighted-mixture expression.
 
     """
     if calculator is None or calculator == "vasp":

{phonopy-4.2.0 → phonopy-4.2.1}/phonopy/cui/collect_cell_info.py

@@ -55,7 +55,11 @@ from phonopy.interface.calculator import (
 from phonopy.interface.phonopy_yaml import PhonopyYaml
 from phonopy.interface.vasp import read_vasp
 from phonopy.structure.atoms import PhonopyAtoms
-from phonopy.structure.cells import build_mixture_cell, get_primitive_matrix_with_auto
+from phonopy.structure.cells import (
+    apply_site_mixture,
+    build_mixture_cell,
+    get_primitive_matrix_with_auto,
+)
 
 _FallbackReason = Literal[
     "load_phonopy_yaml mode",
@@ -143,9 +147,24 @@ def get_cell_info(
             print("")
 
     if settings.site_mixture is not None:
-        cell_info.unitcell = build_mixture_cell(
-            cell_info.unitcell, settings.site_mixture
-        )
+        # A cell loaded from phonopy(_disp).yaml already carries its
+        # site-mixture (merged mixtures or weighted species), so re-applying
+        # the --site-mixture weights would fail. Skip in that case; the
+        # persisted cell already has the information.
+        if cell_info.unitcell.has_mixtures or cell_info.unitcell.has_weighted_species:
+            if log_level:
+                print(
+                    "Site mixture is already defined in the input cell; "
+                    "--site-mixture is ignored."
+                )
+        elif settings.merge_site_mixture:
+            cell_info.unitcell = build_mixture_cell(
+                cell_info.unitcell, settings.site_mixture
+            )
+        else:
+            cell_info.unitcell = apply_site_mixture(
+                cell_info.unitcell, settings.site_mixture
+            )
 
     set_magnetic_moments(cell_info.unitcell, settings.magnetic_moments, log_level)
 

{phonopy-4.2.0 → phonopy-4.2.1}/phonopy/cui/phonopy_argparse.py

@@ -47,6 +47,32 @@ from phonopy.interface.calculator import (
     calculator_info,
 )
 
+_CALCULATOR_DESTS = frozenset(f"{name}_mode" for name in calculator_info)
+
+
+class _SortedHelpFormatter(argparse.HelpFormatter):
+    """Help formatter that orders options independently of definition order.
+
+    The options are split across shared / init / run helper functions, so
+    their definition order does not give a tidy ``--help`` listing. This
+    formatter sorts the display instead: ``-h`` first, then the calculator
+    interface flags (alphabetically), then the remaining options
+    alphabetically.
+
+    """
+
+    def add_arguments(self, actions):
+        """Sort actions before the base formatter lays them out."""
+
+        def sort_key(action):
+            is_help = action.dest == "help"
+            is_calculator = action.dest in _CALCULATOR_DESTS
+            opt = (action.option_strings or [""])[0].lstrip("-").lower()
+            # (help first, calculators next, then the rest), each then by name.
+            return (not is_help, not is_calculator, opt)
+
+        super().add_arguments(sorted(actions, key=sort_key))
+
 
 def fix_deprecated_option_names(argv: list[str]) -> list[str]:
     """Replace underscore in command option name by hyphen."""
@@ -115,13 +141,25 @@ def _add_shared_options(parser: argparse.ArgumentParser) -> None:
         dest="site_mixture",
         default=None,
         help=(
-            "Per-atom mixture weights in the order atoms appear in the "
-            "input cell. Overlapping atoms are merged into mixed-species "
-            "sites; weights within each overlapping group must sum to "
-            "1.0. The typical use case is the Virtual Crystal "
-            "Approximation. Note that this is per-atom and distinct from "
-            "the VASP INCAR VCA tag, which lists one weight per element "
-            "row in POSCAR."
+            "[Experimental] Per-atom mixture weights in the order atoms "
+            "appear in the input cell. Weights within each overlapping "
+            "group of atoms must sum to 1.0. By default the overlapping "
+            "atoms are merged into mixed-species sites (Virtual Crystal "
+            "Approximation); pass --split-site-mixture to instead keep them "
+            "as separate species-resolved atoms. Note that this is per-atom "
+            "and distinct from the VASP INCAR VCA tag, which lists one "
+            "weight per element row in POSCAR."
+        ),
+    )
+    parser.add_argument(
+        "--split-site-mixture",
+        dest="split_site_mixture",
+        action="store_true",
+        default=None,
+        help=(
+            "[Experimental] With --site-mixture, keep overlapping atoms as "
+            "separate species-resolved atoms instead of merging them into "
+            "mixed-species sites."
         ),
     )
     parser.add_argument(
@@ -1023,6 +1061,7 @@ def get_init_parser() -> tuple[argparse.ArgumentParser, list[str]]:
             "FORCE_CONSTANTS files, and inspect crystal symmetry."
         ),
         allow_abbrev=False,
+        formatter_class=_SortedHelpFormatter,
     )
     _add_shared_options(parser)
     _add_init_options(parser)
@@ -1044,6 +1083,7 @@ def get_run_parser() -> tuple[argparse.ArgumentParser, list[str]]:
     parser = argparse.ArgumentParser(
         description="phonopy: phonon calculation from a phonopy.yaml-like file.",
         allow_abbrev=False,
+        formatter_class=_SortedHelpFormatter,
     )
     _add_shared_options(parser)
     _add_run_options(parser)

{phonopy-4.2.0 → phonopy-4.2.1}/phonopy/cui/phonopy_script.py

@@ -1770,9 +1770,9 @@ def _init_phonopy(
     if settings.masses is not None:
         phonon.masses = settings.masses
 
-    # Atomic species without mass case. VCA / mixed-species sites carry derived
-    # masses already, so the per-symbol lookup (which would fail on composite
-    # labels like "GeSn") is skipped for those cells.
+    # Atomic species without mass case. Mixture and weighted-species sites
+    # carry derived masses already, so the per-symbol lookup (which would
+    # fail on composite labels like "GeSn") is skipped for those cells.
     atom_data = get_atomic_data().atom_data
     symbol_map = get_atomic_data().symbol_map
     symbols_with_no_mass = []

{phonopy-4.2.0 → phonopy-4.2.1}/phonopy/cui/settings.py

@@ -98,6 +98,7 @@ class Settings:
         self.magnetic_moments: list[float] | None = None
         self.masses: list[float] | None = None
         self.site_mixture: list[float] | None = None
+        self.merge_site_mixture: bool = True
         self.mesh_numbers: float | list[int] | list[list[int]] | None = None
         self.mlp_params: str | None = None
         self.nac_method: str | None = None
@@ -347,6 +348,13 @@ class ConfParser(Generic[TSettings]):
                 else:
                     self._confs["site_mixture"] = args.site_mixture
 
+        # The CLI flag --split-site-mixture opts into the non-merge scheme;
+        # internally this is the merge_site_mixture switch (default merge),
+        # so the flag sets it to false.
+        if "split_site_mixture" in arg_list:
+            if args.split_site_mixture:
+                self._confs["merge_site_mixture"] = ".false."
+
         if "mesh_numbers" in arg_list:
             mesh = args.mesh_numbers
             if mesh is not None:
@@ -674,6 +682,12 @@ class ConfParser(Generic[TSettings]):
                 except ValueError:
                     self.setting_error("SITE_MIXTURE tag is incorrectly set.")
 
+            if conf_key == "merge_site_mixture":
+                if confs["merge_site_mixture"].lower() == ".true.":
+                    self._set_parameter("merge_site_mixture", True)
+                elif confs["merge_site_mixture"].lower() == ".false.":
+                    self._set_parameter("merge_site_mixture", False)
+
             if conf_key == "mass":
                 self._set_parameter("mass", [float(x) for x in confs["mass"].split()])
 
@@ -1004,6 +1018,9 @@ class ConfParser(Generic[TSettings]):
         if "site_mixture" in params:
             settings.site_mixture = params["site_mixture"]
 
+        if "merge_site_mixture" in params:
+            settings.merge_site_mixture = params["merge_site_mixture"]
+
         # Atomic mass
         if "mass" in params:
             settings.masses = params["mass"]

{phonopy-4.2.0 → phonopy-4.2.1}/phonopy/harmonic/dynamical_matrix.py

@@ -250,7 +250,6 @@ class DynamicalMatrix:
     def run(
         self,
         q: Sequence[float] | NDArray[np.double],
-        lang: Literal["C", "Python"] = "C",
     ) -> None:
         """Run dynamical matrix calculation at a q-point.
 
@@ -259,22 +258,17 @@ class DynamicalMatrix:
             shape=(3,), dtype='double'
 
         """
-        self._run_without_NAC(np.array(q, dtype="double"), lang=lang)
+        self._run_without_NAC(np.array(q, dtype="double"))
 
-    def _run_without_NAC(
-        self, q: NDArray[np.double], lang: Literal["C", "Python"] = "C"
-    ) -> None:
+    def _run_without_NAC(self, q: NDArray[np.double]) -> None:
         """Run dynamical matrix calculation at a q-point without NAC."""
-        if lang == "C":
-            self._dynamical_matrix = get_dynamical_matrices_at_qpoints(
-                self,
-                q,
-                is_nac=False,
-                hermitianize=self._hermitianize,
-                lang=self._lang,
-            )
-        else:
-            self._dynamical_matrix = self._run_py_dynamical_matrix(q)
+        self._dynamical_matrix = get_dynamical_matrices_at_qpoints(
+            self,
+            q,
+            is_nac=False,
+            hermitianize=self._hermitianize,
+            lang=self._lang,
+        )
 
     def _run_py_dynamical_matrix(self, q: NDArray[np.double]) -> NDArray[np.cdouble]:
         """Python implementation of building dynamical matrix.
@@ -596,7 +590,7 @@ class DynamicalMatrixGL(DynamicalMatrixNAC):
         supercell force constants.
 
         """
-        self._run_c_recip_dipole_dipole_q0()
+        self._run_recip_dipole_dipole_q0()
 
         if self._with_full_terms:
             self._dd_limiting = self._run_limiting_dipole_dipole()
@@ -702,13 +696,12 @@ class DynamicalMatrixGL(DynamicalMatrixNAC):
         q_direction: NDArray[np.double] | None,
     ) -> NDArray[np.cdouble]:
         num_atom = len(self._pcell)
-        q_cart = np.array(np.dot(q_red, self._rec_lat.T), dtype="double")
         if q_direction is None:
             q_dir_cart = None
         else:
             q_dir_cart = np.array(np.dot(q_direction, self._rec_lat.T), dtype="double")
 
-        C_recip = self._get_c_recip_dipole_dipole(q_cart, q_dir_cart)
+        C_recip = self._get_recip_dipole_dipole(q_red, q_dir_cart)
 
         if self._with_full_terms:
             for i in range(num_atom):
@@ -728,9 +721,9 @@ class DynamicalMatrixGL(DynamicalMatrixNAC):
 
         return C_dd
 
-    def _get_c_recip_dipole_dipole(
+    def _get_recip_dipole_dipole(
         self,
-        q_cart: NDArray[np.double],
+        q_red: NDArray[np.double],
         q_dir_cart: NDArray[np.double] | None,
     ) -> NDArray[np.cdouble]:
         """Reciprocal part of Eq.(71) on the right hand side.
@@ -746,6 +739,7 @@ class DynamicalMatrixGL(DynamicalMatrixNAC):
         shape=(num_atom, 3, num_atom, 3), dtype="cdouble"
 
         """
+        q_cart = np.array(np.dot(q_red, self._rec_lat.T), dtype="double")
         pos = self._pcell.positions
         num_atom = len(pos)
         volume = self._pcell.volume
@@ -759,7 +753,7 @@ class DynamicalMatrixGL(DynamicalMatrixNAC):
         factor = self._unit_conversion * 4.0 * np.pi / volume
 
         if self._lang == "Rust":
-            log_dispatch("Rust", "DynamicalMatrixGL._get_c_recip_dipole_dipole")
+            log_dispatch("Rust", "DynamicalMatrixGL._get_recip_dipole_dipole")
             import phonors  # type: ignore[import-untyped]
 
             phonors.recip_dipole_dipole(
@@ -775,7 +769,7 @@ class DynamicalMatrixGL(DynamicalMatrixNAC):
                 q_dir_cart,
             )
         else:
-            log_dispatch("C", "DynamicalMatrixGL._get_c_recip_dipole_dipole")
+            log_dispatch("C", "DynamicalMatrixGL._get_recip_dipole_dipole")
             import phonopy._phonopy as phonoc  # type: ignore
 
             if q_dir_cart is None:
@@ -802,7 +796,7 @@ class DynamicalMatrixGL(DynamicalMatrixNAC):
             )
         return dd
 
-    def _run_c_recip_dipole_dipole_q0(self) -> None:
+    def _run_recip_dipole_dipole_q0(self) -> None:
         """Reciprocal part of Eq.(71) second term on the right hand side.
 
         Computed only once.
@@ -812,7 +806,7 @@ class DynamicalMatrixGL(DynamicalMatrixNAC):
         self._dd_q0 = np.zeros((len(pos), 3, 3), dtype="cdouble", order="C")
 
         if self._lang == "Rust":
-            log_dispatch("Rust", "DynamicalMatrixGL._run_c_recip_dipole_dipole_q0")
+            log_dispatch("Rust", "DynamicalMatrixGL._run_recip_dipole_dipole_q0")
             import phonors  # type: ignore[import-untyped]
 
             phonors.recip_dipole_dipole_q0(
@@ -824,7 +818,7 @@ class DynamicalMatrixGL(DynamicalMatrixNAC):
                 self._Lambda,
             )
         else:
-            log_dispatch("C", "DynamicalMatrixGL._run_c_recip_dipole_dipole_q0")
+            log_dispatch("C", "DynamicalMatrixGL._run_recip_dipole_dipole_q0")
             import phonopy._phonopy as phonoc  # type: ignore
 
             phonoc.recip_dipole_dipole_q0(

{phonopy-4.2.0 → phonopy-4.2.1}/phonopy/harmonic/dynmat_to_fc.py

@@ -342,10 +342,10 @@ class DynmatToForceConstants:
         elif dynamical_matrices is not None:
             self.dynamical_matrices = dynamical_matrices
 
-    def run(self, lang: Literal["C", "Python"] = "C") -> None:
+    def run(self) -> None:
         """Run."""
         self._fc = np.zeros(self._fc_shape, dtype="double", order="C")
-        self._inverse_transformation(lang=lang)
+        self._inverse_transformation()
 
     @property
     def force_constants(self) -> NDArray[np.double] | None:
@@ -451,11 +451,8 @@ class DynmatToForceConstants:
             dm.append(np.dot(np.dot(eigvecs, np.diag(eigvals)), eigvecs.T.conj()))
         self.dynamical_matrices = np.array(dm, dtype="cdouble", order="C")
 
-    def _inverse_transformation(self, lang: Literal["C", "Python"] = "C") -> None:
-        if lang == "C":
-            self._inverse_transformation_compiled()
-        else:
-            self._inverse_transformation_py()
+    def _inverse_transformation(self) -> None:
+        self._inverse_transformation_compiled()
 
         assert self._fc is not None
         if self._fc.shape[0] == self._fc.shape[1]:

{phonopy-4.2.0 → phonopy-4.2.1}/phonopy/harmonic/force_constants.py

@@ -543,6 +543,7 @@ def get_positions_sent_by_rot_inv(
     site_symmetry: NDArray[np.int64],
     symprec: float,
     lang: Literal["C", "Rust"] = "Rust",
+    types: NDArray[np.int64] | Sequence[int] | None = None,
 ) -> NDArray[np.int64]:
     """Return atom indices of positions sent by inverse site symmetries.
 
@@ -558,6 +559,11 @@ def get_positions_sent_by_rot_inv(
         Site symmetry operations of the displaced atom.
     symprec : float
         Tolerance of symmetry.
+    types : array_like or None
+        Per-atom integer types. When given, atoms are matched only within
+        the same type so co-located atoms of different species (e.g. in a
+        site-mixture cell) are not paired. When None (default), matching
+        is by position alone. See ``compute_permutation_for_rotation``.
 
     Note
     ----
@@ -567,7 +573,12 @@ def get_positions_sent_by_rot_inv(
     rot_map_syms = []
     for sym in site_symmetry:
         rot_map = compute_permutation_for_rotation(
-            np.dot(positions, sym.T), positions, lattice, symprec, lang=lang
+            np.dot(positions, sym.T),
+            positions,
+            lattice,
+            symprec,
+            lang=lang,
+            types=types,
         )
         rot_map_syms.append(rot_map)
 
@@ -906,8 +917,15 @@ def _solve_force_constants_svd(
     positions = supercell.scaled_positions
     pos_center = positions[disp_atom_number]
     positions -= pos_center
+    # For cells with co-located atoms (site-mixture / weighted species),
+    # match the site-symmetry permutations within each species so that
+    # degenerate positions do not pair atoms of different species.
+    if supercell.has_weighted_species or supercell.has_mixtures:
+        types: NDArray[np.int64] | None = supercell.species_ids
+    else:
+        types = None
     rot_map_syms = get_positions_sent_by_rot_inv(
-        lattice, positions, site_symmetry, symprec, lang=lang
+        lattice, positions, site_symmetry, symprec, lang=lang, types=types
     )
     site_sym_cart = [similarity_transformation(lattice, sym) for sym in site_symmetry]
     rot_disps = get_rotated_displacement(displacements, site_sym_cart)

{phonopy-4.2.0 → phonopy-4.2.1}/phonopy/qha/eos.py

@@ -88,7 +88,7 @@ def get_eos(eos: str) -> EosFunc:
         p[3] = V_0
 
         """
-        x = (v / p[3]) ** (1.0 / 3)
+        x = np.cbrt(v / p[3])
         xi = 3.0 / 2 * (p[2] - 1)
         return p[0] + (
             9 * p[1] * p[3] / (xi**2) * (1 + (xi * (1 - x) - 1) * np.exp(xi * (1 - x)))