phonopy 4.2.1__tar.gz → 4.2.2__tar.gz

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

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

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

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

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

@@ -2004,6 +2004,7 @@ class Phonopy:
         freq_max: float | None = None,
         freq_pitch: float | None = None,
         use_tetrahedron_method: bool = True,
+        smearing_function: Literal["Normal", "Cauchy"] = "Normal",
     ) -> TotalDos:
         """Run total DOS calculation.
 
@@ -2019,6 +2020,10 @@ class Phonopy:
         use_tetrahedron_method : bool, optional
             Use the tetrahedron method when True. When ``sigma`` is
             set, the smearing method is used instead. Default is True.
+        smearing_function : {"Normal", "Cauchy"}, optional
+            Distribution used by the smearing method. "Normal" is a normal
+            distribution and "Cauchy" is a Cauchy (Lorentzian) distribution.
+            Default is "Normal".
 
         Returns
         -------
@@ -2038,6 +2043,7 @@ class Phonopy:
             self._mesh,
             sigma=sigma,
             use_tetrahedron_method=use_tetrahedron_method,
+            smearing_function=smearing_function,
             lang=self._lang,
         )
         total_dos.set_draw_area(freq_min, freq_max, freq_pitch)
@@ -2109,20 +2115,42 @@ class Phonopy:
         )
 
     def set_Debye_frequency(self, freq_max_fit: float | None = None) -> None:
-        """Calculate Debye frequency on top of total DOS."""
+        """Calculate Debye frequency on top of total DOS.
+
+        .. deprecated::
+            After ``run_total_dos()``, call
+            ``total_dos.run_debye_frequency(num_atoms)`` instead.
+
+        """
+        warnings.warn(
+            "set_Debye_frequency() is deprecated. After run_total_dos(), call "
+            "total_dos.run_debye_frequency(num_atoms) and read "
+            "total_dos.debye_frequency.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         if self._total_dos is None:
             msg = "run_total_dos has to be done before getting total DOS."
             raise RuntimeError(msg)
-        self._total_dos.set_Debye_frequency(
-            len(self._primitive), freq_max_fit=freq_max_fit
-        )
+        self._total_dos.run_debye_frequency(freq_max_fit=freq_max_fit)
 
     def get_Debye_frequency(self) -> float | None:
-        """Return Debye frequency."""
+        """Return Debye frequency.
+
+        .. deprecated::
+            Use ``total_dos.debye_frequency`` instead.
+
+        """
+        warnings.warn(
+            "get_Debye_frequency() is deprecated. Use the total_dos property "
+            "and read its debye_frequency attribute instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         if self._total_dos is None:
             msg = "run_total_dos has to be done before getting total DOS."
             raise RuntimeError(msg)
-        return self._total_dos.get_Debye_frequency()
+        return self._total_dos.debye_frequency
 
     def plot_total_dos(
         self,
@@ -2172,6 +2200,7 @@ class Phonopy:
         use_tetrahedron_method: bool = True,
         direction: Sequence[float] | NDArray[np.double] | None = None,
         xyz_projection: bool = False,
+        smearing_function: Literal["Normal", "Cauchy"] = "Normal",
     ) -> ProjectedDos:
         """Run projected DOS calculation.
 
@@ -2194,6 +2223,10 @@ class Phonopy:
         xyz_projection : bool, optional
             Whether to project along Cartesian directions. Default is
             False.
+        smearing_function : {"Normal", "Cauchy"}, optional
+            Distribution used by the smearing method. "Normal" is a normal
+            distribution and "Cauchy" is a Cauchy (Lorentzian) distribution.
+            Default is "Normal".
 
         Returns
         -------
@@ -2230,6 +2263,7 @@ class Phonopy:
             use_tetrahedron_method=use_tetrahedron_method,
             direction=direction_cart,
             xyz_projection=xyz_projection,
+            smearing_function=smearing_function,
             lang=self._lang,
         )
         self._pdos.set_draw_area(freq_min, freq_max, freq_pitch)

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

@@ -1271,6 +1271,8 @@ def _run_projected_dos(
         print(
             "                      [%6.3f %6.3f %6.3f] (Cartesian)" % tuple(c_direction)
         )
+    if log_level and phonon.primitive.mixture_weights is not None:
+        print("Projected DOS is scaled by per-atom site-mixture concentration weights.")
     if log_level:
         print("Calculating projected DOS...")
     phonon.run_projected_dos(
@@ -1299,6 +1301,8 @@ def _run_total_dos(
 ) -> None:
     """Run total DOS calculation."""
     run_mode = settings.run_mode
+    if log_level and phonon.primitive.mixture_weights is not None:
+        print("Total DOS is NOT scaled by site-mixture concentration weights.")
     phonon.run_total_dos(
         sigma=settings.sigma,
         freq_min=settings.min_frequency,
@@ -1309,9 +1313,9 @@ def _run_total_dos(
     if log_level:
         print("Calculating DOS...")
     if settings.fits_Debye_model:
-        phonon.set_Debye_frequency()
+        phonon.total_dos.run_debye_frequency()
         if log_level:
-            print("Debye frequency: %10.5f" % phonon.get_Debye_frequency())
+            print("Debye frequency: %10.5f" % phonon.total_dos.debye_frequency)
     phonon.write_total_dos()
     if plot_conf["plot_graph"] and run_mode != "band_mesh":
         plot = phonon.plot_total_dos()

{phonopy-4.2.1 → phonopy-4.2.2}/phonopy/cui/show_symmetry.py

@@ -49,9 +49,12 @@ from phonopy.interface.calculator import (
     write_crystal_structure,
 )
 from phonopy.interface.phonopy_yaml import PhonopyYaml
-from phonopy.interface.vasp import sort_positions_by_symbols
 from phonopy.structure.atoms import PhonopyAtoms
-from phonopy.structure.cells import determinant, guess_primitive_matrix
+from phonopy.structure.cells import (
+    determinant,
+    guess_primitive_matrix,
+    sort_positions_by_symbols,
+)
 from phonopy.structure.symmetry import Symmetry
 
 

{phonopy-4.2.1 → phonopy-4.2.2}/phonopy/harmonic/derivative_dynmat.py

@@ -242,7 +242,7 @@ class DerivativeOfDynamicalMatrix:
                 reclat,
                 self._svecs,
                 self._multi,
-                self._pcell.masses,
+                self._dynmat.scaled_masses,
                 self._s2p_map,
                 self._p2s_map,
                 nac_factor,
@@ -262,7 +262,7 @@ class DerivativeOfDynamicalMatrix:
                 np.array(np.linalg.inv(self._pcell.cell), dtype="double", order="C"),
                 self._svecs,
                 self._multi,
-                self._pcell.masses,
+                self._dynmat.scaled_masses,
                 self._s2pp_map,
                 np.arange(len(self._p2s_map), dtype="int64"),
                 nac_factor,
@@ -354,7 +354,7 @@ class DerivativeOfDynamicalMatrix:
             reclat,
             self._svecs,
             self._multi,
-            self._pcell.masses,
+            self._dynmat.scaled_masses,
             s2_for_inner,
             fc_row,
             born=born if kernel_is_nac else None,
@@ -411,7 +411,7 @@ class DerivativeOfDynamicalMatrix:
 
         # Mass weighting: the kernel returns without 1/sqrt(m_k m_k'),
         # matching the value-side `get_recip_dipole_dipole` convention.
-        inv_sqrt_m = 1.0 / np.sqrt(self._pcell.masses)
+        inv_sqrt_m = 1.0 / np.sqrt(self._dynmat.scaled_masses)
         mass_pair = np.outer(inv_sqrt_m, inv_sqrt_m)
         dd *= mass_pair[None, :, None, :, None]
 
@@ -446,7 +446,9 @@ class DerivativeOfDynamicalMatrix:
             s_i = self._p2s_map[i]
             s_j = self._p2s_map[j]
             fc_row = s_i if is_full_fc else i
-            mass = np.sqrt(self._pcell.masses[i] * self._pcell.masses[j])
+            mass = np.sqrt(
+                self._dynmat.scaled_masses[i] * self._dynmat.scaled_masses[j]
+            )
             ddm_local = np.zeros((num_elem, 3, 3), dtype=np.cdouble)
 
             for k in range(num_satom):
@@ -654,7 +656,7 @@ class DerivativeOfDynamicalMatrix:
             d_dd += ZTZ * C * phase_pair[None, :, None, :, None]
 
         # Mass weighting 1 / sqrt(m_k m_kp)
-        inv_sqrt_m = 1.0 / np.sqrt(self._pcell.masses)
+        inv_sqrt_m = 1.0 / np.sqrt(self._dynmat.scaled_masses)
         mass_pair = np.outer(inv_sqrt_m, inv_sqrt_m)
         d_dd *= mass_pair[None, :, None, :, None]
         d_dd *= factor

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

@@ -214,6 +214,25 @@ class DynamicalMatrix:
         """Return primitive cell."""
         return self._pcell
 
+    @property
+    def scaled_masses(self) -> NDArray[np.double]:
+        """Atomic masses used to mass-normalize the dynamical matrix.
+
+        For ordinary and merge-style mixture cells this equals
+        ``primitive.masses``. For non-merge site-mixture cells (built by
+        ``apply_site_mixture``) each mass is scaled by its per-atom
+        concentration weight x_i in (0, 1], giving the VCA effective mass
+        x_i * M_i in the 1/sqrt(M_i M_j) normalization. The reported masses
+        (``primitive.masses``) and the force constants stay unchanged; only
+        the dynamical matrix and its derivative see the scaled mass.
+        shape=(natom,), dtype='double'.
+
+        """
+        weights = self._pcell.mixture_weights
+        if weights is None:
+            return self._pcell.masses
+        return self._pcell.masses * weights
+
     @property
     def force_constants(self) -> NDArray[np.double]:
         """Return supercell force constants."""
@@ -282,7 +301,7 @@ class DynamicalMatrix:
         multi = self._multi
         num_atom = len(self._pcell)
         dm = np.zeros((3 * num_atom, 3 * num_atom), dtype="cdouble", order="C")
-        mass = self._pcell.masses
+        mass = self.scaled_masses
         if fc.shape[0] == fc.shape[1]:
             is_compact_fc = False
         else:
@@ -712,7 +731,7 @@ class DynamicalMatrixGL(DynamicalMatrixNAC):
                 C_recip[i, :, i, :] -= drift[i]
 
         # Mass weighted
-        mass = self._pcell.masses
+        mass = self.scaled_masses
         for i in range(num_atom):
             for j in range(num_atom):
                 C_recip[i, :, j, :] *= 1.0 / np.sqrt(mass[i] * mass[j])
@@ -1491,7 +1510,7 @@ def _extract_params(
     else:
         _svecs, _multi = sparse_to_dense_svecs(svecs, multi)
 
-    masses = dm.primitive.masses
+    masses = dm.scaled_masses
     rec_lattice = np.array(np.linalg.inv(dm.primitive.cell), dtype="double", order="C")
     positions = dm.primitive.positions
     if isinstance(dm, DynamicalMatrixNAC):

{phonopy-4.2.1 → phonopy-4.2.2}/phonopy/interface/calculator.py

@@ -50,14 +50,13 @@ from numpy.typing import NDArray
 from phonopy.file_IO import get_supported_file_extensions_for_compression
 from phonopy.harmonic.displacement import DisplacementDataset
 from phonopy.interface.phonopy_yaml import PhonopyYaml
-from phonopy.interface.vasp import sort_positions_by_symbols
 from phonopy.physical_units import (
     CalculatorPhysicalUnits,
     get_calculator_physical_units,
     get_physical_units,
 )
 from phonopy.structure.atoms import PhonopyAtoms
-from phonopy.structure.cells import determinant
+from phonopy.structure.cells import determinant, sort_positions_by_symbols
 from phonopy.structure.dataset import get_displacements_and_forces
 
 

{phonopy-4.2.1 → phonopy-4.2.2}/phonopy/interface/elk.py

@@ -49,10 +49,10 @@ from phonopy.interface.vasp import (
     check_forces,
     get_drift_forces,
     get_scaled_positions_lines,
-    sort_positions_by_symbols,
 )
 from phonopy.structure.atomic_data import get_atomic_data
 from phonopy.structure.atoms import PhonopyAtoms
+from phonopy.structure.cells import sort_positions_by_symbols
 
 
 def parse_set_of_forces(

{phonopy-4.2.1 → phonopy-4.2.2}/phonopy/interface/fleur.py

@@ -43,11 +43,9 @@ from collections.abc import Sequence
 import numpy as np
 from numpy.typing import NDArray
 
-from phonopy.interface.vasp import (
-    get_drift_forces,
-    sort_positions_by_symbols,
-)
+from phonopy.interface.vasp import get_drift_forces
 from phonopy.structure.atoms import PhonopyAtoms
+from phonopy.structure.cells import sort_positions_by_symbols
 
 
 def parse_set_of_forces(

{phonopy-4.2.1 → phonopy-4.2.2}/phonopy/interface/vasp.py

@@ -45,7 +45,6 @@ import warnings
 import xml.etree.cElementTree as etree
 import xml.etree.ElementTree
 import xml.parsers.expat
-from collections import Counter
 from collections.abc import Sequence
 from typing import Iterator, Literal, cast
 
@@ -60,6 +59,7 @@ from phonopy.file_IO import (
 from phonopy.physical_units import get_physical_units
 from phonopy.structure.atomic_data import get_atomic_data
 from phonopy.structure.atoms import PhonopyAtoms
+from phonopy.structure.cells import sort_positions_by_symbols
 from phonopy.structure.symmetry import elaborate_borns_and_epsilon
 
 
@@ -113,63 +113,6 @@ def get_scaled_positions_lines(scaled_positions: NDArray[np.double]) -> str:
     return "\n".join(_get_scaled_positions_lines(scaled_positions))
 
 
-def sort_positions_by_symbols(
-    symbols: Sequence[str | int] | NDArray[np.int64],
-    positions: NDArray[np.double] | None = None,
-) -> tuple[list[int], list[str | int], NDArray[np.double] | None, list[int]]:
-    """Sort atomic positions by symbols.
-
-    Sort positions by symbols (using the order defined by reduced_symbols)
-    using a stable sort algorithm. Written by @ExpHP, refactored by @atztogo.
-
-    symbols = ["A", "B", "A", "B"]
-    reduced_symbols = ["A", "B"]
-    sort_keys = [0, 1, 0, 1]
-    perm = [0, 2, 1, 3]
-    counts_dict = {'A': 2, 'B': 2}
-    counts_list = [2, 2]
-
-    Parameters
-    ----------
-    symbols : list[str] or list[int] or NDArray[np.int64]
-        Sequence of hashable objects. This may be a list of chemical symbols
-        or numbers.
-    positions : NDArray[np.double] or None, optional
-        Atomic positions. When None, sorted_positions is also None.
-
-    Returns
-    -------
-    sorted_positions = positions[perm]
-    For the others, see the example above.
-
-    Functions
-    ---------
-    _argsort_stable :
-        Alternative to `np.argsort(keys)` that uses a stable sorting algorithm
-        so that indices tied for the same value are listed in increasing order.
-
-    """
-
-    def _argsort_stable(keys):
-        # Python's built-in sort algorithm is a stable sort
-        return sorted(range(len(keys)), key=keys.__getitem__)
-
-    # dict in Python 3.7 or later is ordered dict.
-    reduced_symbols = list(dict.fromkeys(symbols))
-    counts_dict = Counter(symbols)
-    # list(counts_dict.values()) may be used...
-    counts_list = [counts_dict[s] for s in reduced_symbols]
-    sort_keys = [reduced_symbols.index(i) for i in symbols]
-    perm = _argsort_stable(sort_keys)
-
-    if positions is None:
-        sorted_positions = None
-    else:
-        sorted_positions = positions[perm]
-
-    return counts_list, reduced_symbols, sorted_positions, perm
-
-
 def _get_forces_points_and_energy(
     fp: typing.IO,
     use_expat: bool = True,

{phonopy-4.2.1 → phonopy-4.2.2}/phonopy/phonon/dos.py

@@ -99,6 +99,7 @@ class Dos:
         mesh_object: Mesh,
         sigma: float | None = None,
         use_tetrahedron_method: bool = False,
+        smearing_function: Literal["Normal", "Cauchy"] = "Normal",
         lang: Literal["C", "Rust"] = "Rust",
     ) -> None:
         """Init method.
@@ -111,6 +112,10 @@ class Dos:
         sigma : float, optional
             Sigma for smearing method. When set, the smearing method is
             used regardless of ``use_tetrahedron_method``.
+        smearing_function : {"Normal", "Cauchy"}, optional
+            Distribution used by the smearing method.  "Normal" is a normal
+            distribution and "Cauchy" is a Cauchy (Lorentzian) distribution.
+            Default is "Normal".
         lang : {"C", "Rust"}, optional
             Backend selector for the tetrahedron-method kernels.  Default
             is "C".
@@ -123,40 +128,25 @@ class Dos:
         # method applies only without sigma.
         self._use_tetrahedron_method = use_tetrahedron_method and sigma is None
         self._frequency_points: NDArray[np.double]
+        self._smearing_function: NormalDistribution | CauchyDistribution
         self._sigma = sigma
         self._lang: Literal["C", "Rust"] = lang
 
         if self._use_tetrahedron_method:
             self.set_draw_area()
         else:
-            self._sigma = self.set_draw_area()
-            self.set_smearing_function("Normal")
+            sigma_value = self.set_draw_area()
+            self._sigma = sigma_value
+            if smearing_function == "Cauchy":
+                self._smearing_function = CauchyDistribution(sigma_value)
+            else:
+                self._smearing_function = NormalDistribution(sigma_value)
 
     @property
     def frequency_points(self) -> NDArray[np.double]:
         """Return frequency points."""
         return self._frequency_points
 
-    def set_smearing_function(self, function_name: Literal["Normal", "Cauchy"]) -> None:
-        """Set function form for smearing method.
-
-        Parameters
-        ----------
-        function_name : str
-            'Normal': smearing is done by normal distribution.
-            'Cauchy': smearing is done by Cauchy distribution.
-
-        """
-        assert self._sigma is not None
-        if function_name == "Cauchy":
-            self._smearing_function = CauchyDistribution(self._sigma)
-        else:
-            self._smearing_function = NormalDistribution(self._sigma)
-
-    def set_sigma(self, sigma: float) -> None:
-        """Set sigma."""
-        self._sigma = sigma
-
     def set_draw_area(
         self,
         freq_min: float | None = None,
@@ -232,6 +222,7 @@ class TotalDos(Dos):
         mesh_object: Mesh,
         sigma: float | None = None,
         use_tetrahedron_method: bool = False,
+        smearing_function: Literal["Normal", "Cauchy"] = "Normal",
         lang: Literal["C", "Rust"] = "Rust",
     ) -> None:
         """Init method."""
@@ -239,6 +230,7 @@ class TotalDos(Dos):
             mesh_object,
             sigma=sigma,
             use_tetrahedron_method=use_tetrahedron_method,
+            smearing_function=smearing_function,
             lang=lang,
         )
         self._dos: NDArray[np.double] | None = None
@@ -259,13 +251,12 @@ class TotalDos(Dos):
         """Return total DOS."""
         return self._dos
 
-    def get_Debye_frequency(self) -> float | None:
+    @property
+    def debye_frequency(self) -> float | None:
         """Return a kind of Debye frequency."""
         return self._freq_Debye
 
-    def set_Debye_frequency(
-        self, num_atoms: int, freq_max_fit: float | None = None
-    ) -> None:
+    def run_debye_frequency(self, freq_max_fit: float | None = None) -> None:
         """Calculate a kind of Debye frequency."""
         try:
             from scipy.optimize import curve_fit
@@ -275,6 +266,8 @@ class TotalDos(Dos):
         if self._dos is None:
             raise RuntimeError("Run total DOS calculation first.")
 
+        num_atoms = len(self._mesh_object.primitive)
+
         def Debye_dos(freq, a):
             return a * freq**2
 
@@ -384,6 +377,7 @@ class ProjectedDos(Dos):
         use_tetrahedron_method: bool = False,
         direction: Sequence[float] | NDArray[np.double] | None = None,
         xyz_projection: bool = False,
+        smearing_function: Literal["Normal", "Cauchy"] = "Normal",
         lang: Literal["C", "Rust"] = "Rust",
     ) -> None:
         """Init method."""
@@ -391,31 +385,37 @@ class ProjectedDos(Dos):
             mesh_object,
             sigma=sigma,
             use_tetrahedron_method=use_tetrahedron_method,
+            smearing_function=smearing_function,
             lang=lang,
         )
-        if self._mesh_object.eigenvectors is None:
+        eigvecs = self._mesh_object.eigenvectors
+        if eigvecs is None:
             raise ValueError("Mesh object does not have eigenvectors.")
-        self._eigenvectors = self._mesh_object.eigenvectors
         self._projected_dos = None
 
         if xyz_projection:
-            self._eigvecs2 = np.abs(self._eigenvectors) ** 2
+            self._eigvecs2 = np.abs(eigvecs) ** 2
         else:
-            num_atom = self._frequencies.shape[1] // 3
-            i_x = np.arange(num_atom, dtype="int") * 3
-            i_y = np.arange(num_atom, dtype="int") * 3 + 1
-            i_z = np.arange(num_atom, dtype="int") * 3 + 2
+            n_ir, n_comp, n_mode = eigvecs.shape
+            # Split the component axis [x1,y1,z1,x2,y2,z2,...] into (atom, xyz).
+            ev = eigvecs.reshape(n_ir, n_comp // 3, 3, n_mode)
             if direction is None:
-                self._eigvecs2 = np.abs(self._eigenvectors[:, i_x, :]) ** 2
-                self._eigvecs2 += np.abs(self._eigenvectors[:, i_y, :]) ** 2
-                self._eigvecs2 += np.abs(self._eigenvectors[:, i_z, :]) ** 2
+                self._eigvecs2 = (np.abs(ev) ** 2).sum(axis=2)
             else:
-                d = np.array(direction, dtype="double")
-                d /= np.linalg.norm(direction)
-                proj_eigvecs = self._eigenvectors[:, i_x, :] * d[0]
-                proj_eigvecs += self._eigenvectors[:, i_y, :] * d[1]
-                proj_eigvecs += self._eigenvectors[:, i_z, :] * d[2]
-                self._eigvecs2 = np.abs(proj_eigvecs) ** 2
+                d = np.asarray(direction, dtype="double")
+                d = d / np.linalg.norm(d)
+                # Project each atom's xyz amplitude onto the direction (sum over
+                # the xyz axis j), then square.
+                proj = np.einsum("iajm,j->iam", ev, d)
+                self._eigvecs2 = np.abs(proj) ** 2
+
+        weights = self._mesh_object.primitive.mixture_weights
+        if weights is not None:
+            # Per-atom non-merge site-mixture concentration weight x_a scales
+            # each atom's PDOS linearly: |sqrt(x_a) e|^2 = x_a |e|^2. The xyz
+            # projection has 3 rows per atom.
+            row_weights = np.repeat(weights, 3) if xyz_projection else weights
+            self._eigvecs2 = self._eigvecs2 * row_weights[None, :, None]
 
     @property
     def projected_dos(self) -> NDArray[np.double] | None:

{phonopy-4.2.1 → phonopy-4.2.2}/phonopy/phonon/mesh.py

@@ -52,6 +52,7 @@ from phonopy.harmonic.dynamical_matrix import (
 from phonopy.phonon.grid import BZGrid, get_ir_grid_points, length2mesh
 from phonopy.phonon.group_velocity import GroupVelocity
 from phonopy.physical_units import get_physical_units
+from phonopy.structure.cells import Primitive
 from phonopy.structure.symmetry import Symmetry
 
 
@@ -470,6 +471,11 @@ class MeshBase:
         """Return half-grid shift flags per axis (0 or 1)."""
         return self._gp.is_shift
 
+    @property
+    def primitive(self) -> Primitive:
+        """Return the primitive cell."""
+        return self._cell
+
     @property
     def primitive_symmetry(self) -> Symmetry | None:
         """Return the primitive-cell Symmetry passed at construction, if any."""

{phonopy-4.2.1 → phonopy-4.2.2}/phonopy/qha/core.py

@@ -712,7 +712,7 @@ class QHA:
     def plot_gibbs_temperature(
         self,
         xlabel: str = "Temperature (K)",
-        ylabel: str = "Gibbs free energy",
+        ylabel: str = "Gibbs free energy (eV)",
     ) -> Any:
         """Return pyplot Gibbs free energy vs temperature."""
         import matplotlib.pyplot as plt

{phonopy-4.2.1 → phonopy-4.2.2}/phonopy/structure/atoms.py

@@ -801,6 +801,19 @@ class PhonopyAtoms:
             self._species_ids.max() >= len(self._species) or self._species_ids.min() < 0
         ):
             raise RuntimeError("species_ids out of range of species table.")
+        if len(set(self._species)) != len(self._species):
+            raise ValueError(
+                "species_table contains duplicate species; entries must be "
+                "unique so that species_ids identify a species unambiguously. "
+                "Build it via _dedup_species or "
+                "build_species_table_from_mixtures."
+            )
+        if len(np.unique(self._species_ids)) != len(self._species):
+            raise ValueError(
+                "species_table contains unused entries; every entry must be "
+                "referenced by some atom. Build it via _dedup_species or "
+                "prune unused entries before construction."
+            )
         if self._magnetic_moments is not None:
             if len(self._magnetic_moments) not in (len(self), len(self) * 3):
                 raise RuntimeError(
@@ -926,8 +939,12 @@ class PhonopyAtoms:
             lines.append("  coordinates: [ %18.15f, %18.15f, %18.15f ]" % tuple(pos))
             if mass is not None:
                 lines.append("  mass: %f" % mass)
-            if sp.weight is not None:
-                lines.append(f"  weight: {sp.weight}")
+            if self.has_weighted_species:
+                # In a non-merge site-mixture cell every atom carries an
+                # explicit weight so the yaml is self-describing; a pure
+                # site (weight=None in the model) is shown as 1.0.
+                w = sp.weight if sp.weight is not None else 1.0
+                lines.append(f"  weight: {w}")
             if mag is not None:
                 if mag.ndim == 0:
                     mag_str = f"{mag:.8f}"
@@ -1064,8 +1081,13 @@ def parse_cell_dict(cell_dict: CellDict) -> PhonopyAtoms | None:
             else:
                 mixture_per_atom.append(None)
             if "weight" in x:
-                weight_per_atom.append(float(x["weight"]))
+                # A pure site in a non-merge mixture cell is written as
+                # weight 1.0 for a self-describing yaml; normalize it back
+                # to None (the model form 1). The presence of the key marks
+                # a weighted-species cell, matching the writer's condition.
                 has_any_weight = True
+                w = float(x["weight"])
+                weight_per_atom.append(None if w == 1.0 else w)
             else:
                 weight_per_atom.append(None)
             if "mass" in x: