pymatgen.analysis namespace

Subpackages

Submodules

pymatgen.analysis.adsorption module

This module provides classes used to enumerate surface sites and to find adsorption sites on slabs.

pymatgen.analysis.bond_dissociation module

Module for BondDissociationEnergies.

class BondDissociationEnergies(molecule_entry: dict[str, str | dict[str, str | int]], fragment_entries: list[dict[str, str | dict[str, str | int]]], allow_additional_charge_separation: bool = False, multibreak: bool = False)[source]

Bases: MSONable

Standard constructor for bond dissociation energies. All bonds in the principle molecule are looped through and their dissociation energies are calculated given the energies of the resulting fragments, or, in the case of a ring bond, from the energy of the molecule obtained from breaking the bond and opening the ring. This class should only be called after the energies of the optimized principle molecule and all relevant optimized fragments have been determined, either from quantum chemistry or elsewhere. It was written to provide the analysis after running an atomate fragmentation workflow.

The provided entries must have the following keys: formula_pretty, initial_molecule, final_molecule. If a PCM is present, all entries should also have a pcm_dielectric key.

Parameters:

• molecule_entry (dict) – Entry for the principle molecule. Should have the keys mentioned above.

• fragment_entries (list[dict]) – Fragment entries. Each should have the keys mentioned above.

• allow_additional_charge_separation (bool) – If True, consider larger than normal charge separation among fragments. Defaults to False. See the definition of self.expected_charges below for more specific information.

• multibreak (bool) – If True, additionally attempt to break pairs of bonds. Defaults to False.

build_new_entry(frags: list, bonds: list) → list[source]

Build a new entry for bond dissociation that will be returned to the user.

Parameters:

• frags (list) – Fragments involved in the bond dissociation.

• bonds (list) – Bonds broken in the dissociation process.

Returns:

Formatted bond dissociation entries.

Return type:

list

filter_fragment_entries(fragment_entries: list) → None[source]

Filter the fragment entries.

Parameters:

fragment_entries (List) – Fragment entries to be filtered.

fragment_and_process(bonds)[source]

Fragment and process bonds.

Parameters:

bonds (list) – bonds to process.

search_fragment_entries(frag) → list[source]

Search all fragment entries for those isomorphic to the given fragment. We distinguish between entries where both initial and final MoleculeGraphs are isomorphic to the given fragment (entries) vs those where only the initial MoleculeGraph is isomorphic to the given fragment (initial_entries) vs those where only the final MoleculeGraph is isomorphic (final_entries).

Parameters:

frag – Fragment

pymatgen.analysis.bond_valence module

This module implements classes to perform bond valence analyses.

pymatgen.analysis.chempot_diagram module

This module implements the construction and plotting of chemical potential diagrams from a list of entries within a chemical system containing 2 or more elements. The chemical potential diagram is the mathematical dual to the traditional compositional phase diagram.

For more information, please cite/reference the paper below:

Todd, P. K., McDermott, M. J., Rom, C. L., Corrao, A. A., Denney, J. J., Dwaraknath, S. S., Khalifah, P. G., Persson, K. A., & Neilson, J. R. (2021). Selectivity in Yttrium Manganese Oxide Synthesis via Local Chemical Potentials in Hyperdimensional Phase Space. Journal of the American Chemical Society, 143(37), 15185-15194. https://doi.org/10.1021/jacs.1c06229

Please also consider referencing the original 1999 paper by H. Yokokawa, who outlined many of its possible uses:

Yokokawa, H. “Generalized chemical potential diagram and its applications to chemical reactions at interfaces between dissimilar materials.” JPE 20, 258 (1999). https://doi.org/10.1361/105497199770335794

class ChemicalPotentialDiagram(entries: list[PDEntry], limits: dict[Element, tuple[float, float]] | None = None, default_min_limit: float = -50.0, formal_chempots: bool = True)[source]

Bases: MSONable

The chemical potential diagram is the mathematical dual to the compositional phase diagram. To create the diagram, convex minimization is performed in energy (E) vs. chemical potential (μ) space by taking the lower convex envelope of hyperplanes. Accordingly, “points” on the compositional phase diagram become N-dimensional convex polytopes (domains) in chemical potential space.

For more information on this specific implementation of the algorithm, please cite/reference the paper below:

Todd, P. K., McDermott, M. J., Rom, C. L., Corrao, A. A., Denney, J. J., Dwaraknath, S. S., Khalifah, P. G., Persson, K. A., & Neilson, J. R. (2021). Selectivity in Yttrium Manganese Oxide Synthesis via Local Chemical Potentials in Hyperdimensional Phase Space. Journal of the American Chemical Society, 143(37), 15185-15194. https://doi.org/10.1021/jacs.1c06229

Parameters:

• entries (list[PDEntry]) – PDEntry-like objects containing a composition and energy. Must contain elemental references and be suitable for typical phase diagram construction. Entries must be within a chemical system of with 2+ elements.

• limits (dict[Element, float] | None) – Bounds of elemental chemical potentials (min, max), which are used to construct the border hyperplanes used in the HalfSpaceIntersection algorithm; these constrain the space over which the domains are calculated and also determine the size of the plotted diagram. Any elemental limits not specified are covered in the default_min_limit argument. e.g. {Element(“Li”): [-12.0, 0.0], …}

• default_min_limit (float) – Default minimum chemical potential limit (i.e., lower bound) for unspecified elements within the “limits” argument.

• formal_chempots (bool) – Whether to plot the formal (‘reference’) chemical potentials (i.e. μ_X - μ_X^0) or the absolute DFT reference energies (i.e. μ_X(DFT)). Default is True (i.e. plot formal chemical potentials).

property border_hyperplanes: ndarray[source]

Bordering hyperplanes.

property chemical_system: str[source]

The chemical system (A-B-C-…) of diagram object.

property domains: dict[str, ndarray][source]

Mapping of formulas to array of domain boundary points.

property el_refs: dict[Element, PDEntry][source]

A dictionary of elements and reference entries.

property entry_dict: dict[str, ComputedEntry][source]

Mapping between reduced formula and ComputedEntry.

get_plot(elements: list[Element | str] | None = None, label_stable: bool | None = True, formulas_to_draw: list[str] | None = None, draw_formula_meshes: bool | None = True, draw_formula_lines: bool | None = True, formula_colors: list[str] = ['rgb(27,158,119)', 'rgb(217,95,2)', 'rgb(117,112,179)', 'rgb(231,41,138)', 'rgb(102,166,30)', 'rgb(230,171,2)', 'rgb(166,118,29)', 'rgb(102,102,102)'], element_padding: float | None = 1.0) → Figure[source]

Plot the 2-dimensional or 3-dimensional chemical potential diagram using an interactive Plotly interface.

Elemental axes can be specified; if none provided, will automatically default to first 2-3 elements within the “elements” attribute.

In 3D, this method also allows for plotting of lower-dimensional “slices” of hyperdimensional polytopes (e.g., the LiMnO2 domain within a Y-Mn-O diagram). This allows for visualization of some of the phase boundaries that can only be seen fully in high dimensional space; see the “formulas_to_draw” argument.

Parameters:

• elements – list of elements to use as axes in the diagram. If None, automatically defaults to the first 2 or elements within the object’s “elements” attribute.

• label_stable – whether to label stable phases by their reduced formulas. Defaults to True.

• formulas_to_draw – for 3-dimensional diagrams, an optional list of formulas to plot on the diagram; if these are from a different chemical system a 3-d polyhedron “slice” will be plotted. Defaults to None.

• draw_formula_meshes – whether to draw a colored mesh for the optionally specified formulas_to_draw. Defaults to True.

• draw_formula_lines – whether to draw bounding lines for the optionally specified formulas_to_draw. Defaults to True.

• formula_colors – a list of colors to use in the plotting of the optionally specified formulas_to-draw. Defaults to the Plotly Dark2 color scheme.

• element_padding – if provided, automatically adjusts chemical potential axis limits of the plot such that elemental domains have the specified padding (in eV/atom), helping provide visual clarity. Defaults to 1.0.

Returns:

plotly.graph_objects.Figure

property hyperplane_entries: list[PDEntry][source]

List of entries corresponding to hyperplanes.

property hyperplanes: ndarray[source]

Array of hyperplane data.

property lims: ndarray[source]

Array of limits used in constructing hyperplanes.

get_2d_orthonormal_vector(line_pts: ndarray) → ndarray[source]

Calculates a vector that is orthonormal to a line given by a set of points. Used for determining the location of an annotation on a 2-d chemical potential diagram.

Parameters:

line_pts – a 2x2 array in the form of [[x0, y0], [x1, y1]] giving the coordinates of a line

Returns:

A length-2 vector that is orthonormal to the line.

Return type:

np.ndarray

get_centroid_2d(vertices: ndarray) → ndarray[source]

A bare-bones implementation of the formula for calculating the centroid of a 2D polygon. Useful for calculating the location of an annotation on a chemical potential domain within a 3D chemical potential diagram.

NOTE vertices must be ordered circumferentially!

Parameters:

vertices – array of 2-d coordinates corresponding to a polygon, ordered circumferentially

Returns:

Giving 2-d centroid coordinates.

Return type:

np.ndarray

simple_pca(data: ndarray, k: int = 2) → tuple[ndarray, ndarray, ndarray][source]

A bare-bones implementation of principal component analysis (PCA) used in the ChemicalPotentialDiagram class for plotting.

Parameters:

• data – array of observations

• k – Number of principal components returned

Returns:

projected data, eigenvalues, eigenvectors

Return type:

tuple

pymatgen.analysis.cost module

This module is used to estimate the cost of various compounds. Costs are taken from the a CostDB instance, for example a CSV file via CostDBCSV. For compounds with no cost listed, a Phase Diagram style convex hull optimization is performed to determine a set of compositions that can be mixed to give the desired compound with lowest total cost.

class CostAnalyzer(costdb: CostDB)[source]

Bases: object

Given a CostDB, figures out the minimum cost solutions via convex hull.

Parameters:

costdb (CostDB) – Cost database to use.

get_cost_per_kg(comp)[source]

Get best estimate of minimum cost/kg based on known data.

Parameters:

comp (CompositionLike) – chemical formula

Returns:

energy cost/kg

Return type:

float

get_cost_per_mol(comp: CompositionLike) → float[source]

Get best estimate of minimum cost/mol based on known data.

Parameters:

comp (CompositionLike) – chemical formula

Returns:

energy cost/mol

Return type:

float

get_lowest_decomposition(composition)[source]

Get the decomposition leading to lowest cost.

Parameters:

composition – Composition as a pymatgen.core.structure.Composition

Returns:

amount}

Return type:

Decomposition as a dict of {Entry

class CostDB[source]

Bases: ABC

Abstract class for representing a Cost database. Can be extended, e.g. for file-based or REST-based databases.

abstractmethod get_entries(chemsys)[source]

For a given chemical system, return an array of CostEntries.

Parameters:

chemsys (list[SpeciesLike]) – Elements defining the chemical system.

Returns:

list[CostEntries]

class CostDBCSV(filename)[source]

Bases: CostDB

Read a CSV file to get costs. Format is formula,cost_per_kg,name,BibTeX.

Parameters:

filename (str) – Filename of cost database.

get_entries(chemsys)[source]

For a given chemical system, return an array of CostEntries.

Parameters:

chemsys (list[Element]) – Elements defining the chemical system.

Returns:

array of CostEntries

class CostEntry(composition, cost, name, reference)[source]

Bases: PDEntry

Extends PDEntry to include a BibTeX reference and include language about cost.

Parameters:

• composition (Composition) – chemical composition of the entry

• cost (float) – per mol, NOT per kg of the full Composition

• name (str) – Optional parameter to name the entry. Defaults to the reduced chemical formula as in PDEntry.

• reference (str) – Reference data as BiBTeX string.

pymatgen.analysis.dimensionality module

This module provides functions to get the dimensionality of a structure.

A number of different algorithms are implemented. These are based on the following publications:

get_dimensionality_larsen:

• P. M. Larsen, M. Pandey, M. Strange, K. W. Jacobsen. Definition of a scoring parameter to identify low-dimensional materials components. Phys. Rev. Materials 3, 034003 (2019).

get_dimensionality_cheon:

• Cheon, G.; Duerloo, K.-A. N.; Sendek, A. D.; Porter, C.; Chen, Y.; Reed, E. J. Data Mining for New Two- and One-Dimensional Weakly Bonded Solids and Lattice-Commensurate Heterostructures. Nano Lett. 2017.

get_dimensionality_gorai:

• Gorai, P., Toberer, E. & Stevanovic, V. Computational Identification of Promising Thermoelectric Materials Among Known Quasi-2D Binary Compounds. J. Mater. Chem. A 2, 4136 (2016).

calculate_dimensionality_of_site(bonded_structure, site_index, inc_vertices=False)[source]

Calculate the dimensionality of the component containing the given site.

Implements directly the modified breadth-first-search algorithm described in Algorithm 1 of:

P. M. Larsen, M. Pandey, M. Strange, K. W. Jacobsen. Definition of a scoring parameter to identify low-dimensional materials components. Phys. Rev. Materials 3, 034003 (2019).

Parameters:

• bonded_structure (StructureGraph) – A structure with bonds, represented as a pymatgen structure graph. For example, generated using the CrystalNN.get_bonded_structure() method.

• site_index (int) – The index of a site in the component of interest.

• inc_vertices (bool, optional) – Whether to return the vertices (site images) of the component.

Returns:

If inc_vertices is False, the dimensionality of the

component will be returned as an int. If inc_vertices is true, the function will return a tuple of (dimensionality, vertices), where vertices is a list of tuples. E.g. [(0, 0, 0), (1, 1, 1)].

Return type:

int | tuple

find_clusters(struct, connected_matrix)[source]

Find bonded clusters of atoms in the structure with periodic boundary conditions.

If there are atoms that are not bonded to anything, returns [0,1,0]. (For faster computation time)

Author: Gowoon Cheon Email: gcheon@stanford.edu

Parameters:

• struct (Structure) – Input structure

• connected_matrix – Must be made from the same structure with find_connected_atoms() function.

Returns:

the size of the largest cluster in the crystal structure min_cluster: the size of the smallest cluster in the crystal structure clusters: list of bonded clusters found here, clusters are formatted as sets of indices of atoms

Return type:

max_cluster

find_connected_atoms(struct, tolerance=0.45, ldict=None)[source]

Find bonded atoms and returns a adjacency matrix of bonded atoms.

Author: “Gowoon Cheon” Email: “gcheon@stanford.edu”

Parameters:

• struct (Structure) – Input structure

• tolerance – length in angstroms used in finding bonded atoms. Two atoms are considered bonded if (radius of atom 1) + (radius of atom 2) + (tolerance) < (distance between atoms 1 and 2). Default value = 0.45, the value used by JMol and Cheon et al.

• ldict – dictionary of bond lengths used in finding bonded atoms. Values from JMol are used as default

Returns:

A numpy array of shape (number of atoms, number of atoms);

If any image of atom j is bonded to atom i with periodic boundary conditions, the matrix element [atom i, atom j] is 1.

Return type:

np.ndarray

get_dimensionality_cheon(structure_raw, tolerance=0.45, ldict=None, standardize=True, larger_cell=False)[source]

Algorithm for finding the dimensions of connected subunits in a structure. This method finds the dimensionality of the material even when the material is not layered along low-index planes, or does not have flat layers/molecular wires.

Author: “Gowoon Cheon” Email: “gcheon@stanford.edu”

See details at :

Cheon, G.; Duerloo, K.-A. N.; Sendek, A. D.; Porter, C.; Chen, Y.; Reed, E. J. Data Mining for New Two- and One-Dimensional Weakly Bonded Solids and Lattice-Commensurate Heterostructures. Nano Lett. 2017.

Parameters:

• structure_raw (Structure) – A pymatgen Structure object.

• tolerance (float) – length in angstroms used in finding bonded atoms. Two atoms are considered bonded if (radius of atom 1) + (radius of atom 2) + (tolerance) < (distance between atoms 1 and 2). Default value = 0.45, the value used by JMol and Cheon et al.

• ldict (dict) – dictionary of bond lengths used in finding bonded atoms. Values from JMol are used as default

• standardize – works with conventional standard structures if True. It is recommended to keep this as True.

• larger_cell –

  tests with 3x3x3 supercell instead of 2x2x2. Testing with 2x2x2 supercell is faster but misclassifies rare interpenetrated 3D

  structures. Testing with a larger cell circumvents this problem

Returns:

dimension of the largest cluster as a string. If there are ions

or molecules it returns ‘intercalated ion/molecule’

Return type:

str

get_dimensionality_gorai(structure, max_hkl=2, el_radius_updates=None, min_slab_size=5, min_vacuum_size=5, standardize=True, bonds=None)[source]

This method returns whether a structure is 3D, 2D (layered), or 1D (linear chains or molecules) according to the algorithm published in Gorai, P., Toberer, E. & Stevanovic, V. Computational Identification of Promising Thermoelectric Materials Among Known Quasi-2D Binary Compounds. J. Mater. Chem. A 2, 4136 (2016).

Note that a 1D structure detection might indicate problems in the bonding algorithm, particularly for ionic crystals (e.g., NaCl)

Users can change the behavior of bonds detection by passing either el_radius_updates to update atomic radii for auto-detection of max bond distances, or bonds to explicitly specify max bond distances for atom pairs. Note that if you pass both, el_radius_updates are ignored.

Parameters:

• structure (Structure) – structure to analyze dimensionality for

• max_hkl (int) – max index of planes to look for layers

• el_radius_updates (dict) – symbol->float to update atomic radii

• min_slab_size (float) – internal surface construction parameter

• min_vacuum_size (float) – internal surface construction parameter

• standardize (bool) – whether to standardize the structure before analysis. Set to False only if you already have the structure in a convention where layers / chains will be along low <hkl> indexes.

• bonds (dict[tuple, float]) – bonds are specified as a dict of 2-tuples of Species mapped to floats, the max bonding distance. For example, PO4 groups may be defined as {(“P”, “O”): 3}.

Returns:

the dimensionality of the structure - 1 (molecules/chains),

2 (layered), or 3 (3D)

Return type:

int

get_dimensionality_larsen(bonded_structure)[source]

Gets the dimensionality of a bonded structure.

The dimensionality of the structure is the highest dimensionality of all structure components. This method is very robust and can handle many tricky structures, regardless of structure type or improper connections due to periodic boundary conditions.

Requires a StructureGraph object as input. This can be generated using one of the NearNeighbor classes. For example, using the CrystalNN class:

bonded_structure = CrystalNN().get_bonded_structure(structure)

Based on the modified breadth-first-search algorithm described in:

P. M. Larsen, M. Pandey, M. Strange, K. W. Jacobsen. Definition of a scoring parameter to identify low-dimensional materials components. Phys. Rev. Materials 3, 034003 (2019).

Parameters:

bonded_structure (StructureGraph) – A structure with bonds, represented as a pymatgen structure graph. For example, generated using the CrystalNN.get_bonded_structure() method.

Returns:

The dimensionality of the structure.

Return type:

int

get_structure_components(bonded_structure, inc_orientation=False, inc_site_ids=False, inc_molecule_graph=False)[source]

Gets information on the components in a bonded structure.

Correctly determines the dimensionality of all structures, regardless of structure type or improper connections due to periodic boundary conditions.

Requires a StructureGraph object as input. This can be generated using one of the NearNeighbor classes. For example, using the CrystalNN class:

bonded_structure = CrystalNN().get_bonded_structure(structure)

Based on the modified breadth-first-search algorithm described in:

P. M. Larsen, M. Pandey, M. Strange, K. W. Jacobsen. Definition of a scoring parameter to identify low-dimensional materials components. Phys. Rev. Materials 3, 034003 (2019).

Parameters:

• bonded_structure (StructureGraph) – A structure with bonds, represented as a pymatgen structure graph. For example, generated using the CrystalNN.get_bonded_structure() method.

• inc_orientation (bool, optional) – Whether to include the orientation of the structure component. For surfaces, the miller index is given, for one-dimensional structures, the direction of the chain is given.

• inc_site_ids (bool, optional) – Whether to include the site indices of the sites in the structure component.

• inc_molecule_graph (bool, optional) – Whether to include MoleculeGraph objects for zero-dimensional components.

Returns:

Information on the components in a structure as a list

of dictionaries with the keys:

• ”structure_graph”: A pymatgen StructureGraph object for the

  component.

• ”dimensionality”: The dimensionality of the structure component as an

  int.

• ”orientation”: If inc_orientation is True, the orientation of the

  component as a tuple. E.g. (1, 1, 1)

• ”site_ids”: If inc_site_ids is True, the site indices of the

  sites in the component as a tuple.

• ”molecule_graph”: If inc_molecule_graph is True, the site a

  MoleculeGraph object for zero-dimensional components.

Return type:

list[dict]

zero_d_graph_to_molecule_graph(bonded_structure, graph)[source]

Converts a zero-dimensional networkx Graph object into a MoleculeGraph.

Implements a similar breadth-first search to that in calculate_dimensionality_of_site().

Parameters:

• bonded_structure (StructureGraph) – A structure with bonds, represented as a pymatgen structure graph. For example, generated using the CrystalNN.get_bonded_structure() method.

• graph (nx.Graph) – A networkx Graph object for the component of interest.

Returns:

A MoleculeGraph object of the component.

Return type:

MoleculeGraph

pymatgen.analysis.disorder module

This module provides various methods to analyze order/disorder in materials.

get_warren_cowley_parameters(structure: Structure, r: float, dr: float) → dict[tuple, float][source]

Warren-Crowley parameters.

Parameters:

• structure – Pymatgen Structure.

• r – Radius

• dr – Shell width

Returns:

-1.0, …}

Return type:

Warren-Crowley parameters in the form of a dict, e.g. {(Element Mo, Element W)

pymatgen.analysis.energy_models module

This module implements a EnergyModel abstract class and some basic implementations. Basically, an EnergyModel is any model that returns an “energy” for any given structure.

pymatgen.analysis.eos module

This module implements various equation of states.

Note: Most of the code were initially adapted from ASE and deltafactor by @gmatteo but has since undergone major refactoring.

class Birch(volumes: Sequence[float], energies: Sequence[float])[source]

Bases: EOSBase

Birch EOS.

Parameters:

• volumes (Sequence[float]) – in Ang^3.

• energies (Sequence[float]) – in eV.

class BirchMurnaghan(volumes: Sequence[float], energies: Sequence[float])[source]

Bases: EOSBase

BirchMurnaghan EOS.

Parameters:

• volumes (Sequence[float]) – in Ang^3.

• energies (Sequence[float]) – in eV.

class DeltaFactor(volumes: Sequence[float], energies: Sequence[float])[source]

Bases: PolynomialEOS

Fitting a polynomial EOS using delta factor.

Parameters:

• volumes (Sequence[float]) – in Ang^3.

• energies (Sequence[float]) – in eV.

fit(order: int = 3) → None[source]

Overridden since this eos works with volume**(2/3) instead of volume.

class EOS(eos_name: str = 'murnaghan')[source]

Bases: object

Convenient wrapper. Retained in its original state to ensure backward compatibility.

Fit equation of state for bulk systems.

The following equations are supported:

murnaghan: PRB 28, 5480 (1983)

birch: Intermetallic compounds: Principles and Practice, Vol I:

Principles. pages 195-210

birch_murnaghan: PRB 70, 224107

pourier_tarantola: PRB 70, 224107

vinet: PRB 70, 224107

deltafactor

numerical_eos: 10.1103/PhysRevB.90.174107.

Usage:

eos = EOS(eos_name=’murnaghan’) eos_fit = eos.fit(volumes, energies) eos_fit.plot()

Parameters:

eos_name (str) – Type of EOS to fit.

MODELS: ClassVar[dict[str, Any]] = {'birch': <class 'pymatgen.analysis.eos.Birch'>, 'birch_murnaghan': <class 'pymatgen.analysis.eos.BirchMurnaghan'>, 'deltafactor': <class 'pymatgen.analysis.eos.DeltaFactor'>, 'murnaghan': <class 'pymatgen.analysis.eos.Murnaghan'>, 'numerical_eos': <class 'pymatgen.analysis.eos.NumericalEOS'>, 'pourier_tarantola': <class 'pymatgen.analysis.eos.PourierTarantola'>, 'vinet': <class 'pymatgen.analysis.eos.Vinet'>}[source]

fit(volumes: Sequence[float], energies: Sequence[float]) → EOSBase[source]

Fit energies as function of volumes.

Parameters:

• volumes (Sequence[float]) – in Ang^3

• energies (Sequence[float]) – in eV

Returns:

EOSBase object

Return type:

EOSBase

class EOSBase(volumes: Sequence[float], energies: Sequence[float])[source]

Bases: ABC

Abstract class that must be subclassed by all equation of state implementations.

Parameters:

• volumes (Sequence[float]) – in Ang^3.

• energies (Sequence[float]) – in eV.

property b0: float[source]

The bulk modulus in units of energy/unit of volume^3.

property b0_GPa: FloatWithUnit[source]

The bulk modulus in GPa. This assumes the energy and volumes are in eV and Ang^3.

property b1[source]

The derivative of bulk modulus w.r.t. pressure(dimensionless).

property e0: float[source]

The min energy.

eos_params: Sequence | None[source]

fit() → None[source]

Do the fitting. Does least square fitting. If you want to use custom fitting, must override this.

func(volume)[source]

The equation of state function with the parameters other than volume set to the ones obtained from fitting.

Parameters:

volume (float | list[float]) – volumes in Ang^3

Returns:

numpy.array

plot(width: float = 8, height: float | None = None, ax: Axes = None, dpi: float | None = None, **kwargs) → Axes[source]

Plot the equation of state.

Parameters:

• width (float) – Width of plot in inches. Defaults to 8in.

• height (float) – Height of plot in inches. Defaults to width * golden ratio.

• ax (plt.Axes) – If supplied, changes will be made to the existing Axes. Otherwise, new Axes will be created.

• dpi (float) – DPI.

• kwargs (dict) – additional args fed to pyplot.plot. supported keys: style, color, text, label

Returns:

The matplotlib axes.

Return type:

plt.Axes

plot_ax(ax: Axes | None = None, fontsize: float = 12, **kwargs) → plt.Figure[source]

Plot the equation of state on axis ax.

Parameters:

• ax – matplotlib Axes or None if a new figure should be created.

• fontsize – Legend fontsize.

Returns:

matplotlib figure.

Return type:

plt.Figure

Keyword arguments controlling the display of the figure:

kwargs	Meaning
title	Title of the plot (Default: None).
show	True to show the figure (default: True).
savefig	“abc.png” or “abc.eps” to save the figure to a file.
size_kwargs	Dictionary with options passed to fig.set_size_inches e.g. size_kwargs=dict(w=3, h=4)
tight_layout	True to call fig.tight_layout (default: False)
ax_grid	True (False) to add (remove) grid from all axes in fig. Default: None i.e. fig is left unchanged.
ax_annotate	Add labels to subplots e.g. (a), (b). Default: False
fig_close	Close figure. Default: False.

property results: dict[str, Any][source]

A summary dict.

property v0[source]

The minimum or the reference volume in Ang^3.

exception EOSError[source]

Bases: Exception

Error class for EOS fitting.

class Murnaghan(volumes: Sequence[float], energies: Sequence[float])[source]

Bases: EOSBase

Murnaghan EOS.

Parameters:

• volumes (Sequence[float]) – in Ang^3.

• energies (Sequence[float]) – in eV.

class NumericalEOS(volumes: Sequence[float], energies: Sequence[float])[source]

Bases: PolynomialEOS

A numerical EOS.

Parameters:

• volumes (Sequence[float]) – in Ang^3.

• energies (Sequence[float]) – in eV.

fit(min_ndata_factor: int = 3, max_poly_order_factor: int = 5, min_poly_order: int = 2) → None[source]

Fit the input data to the ‘numerical eos’, the equation of state employed in the quasiharmonic Debye model described in the paper: 10.1103/PhysRevB.90.174107.

credits: Cormac Toher

Parameters:

• min_ndata_factor (int) – parameter that controls the minimum number of data points that will be used for fitting. minimum number of data points = total data points-2*min_ndata_factor

• max_poly_order_factor (int) – parameter that limits the max order of the polynomial used for fitting. max_poly_order = number of data points used for fitting - max_poly_order_factor

• min_poly_order (int) – minimum order of the polynomial to be considered for fitting.

class PolynomialEOS(volumes: Sequence[float], energies: Sequence[float])[source]

Bases: EOSBase

Derives from EOSBase. Polynomial based equations of states must subclass this.

Parameters:

• volumes (Sequence[float]) – in Ang^3.

• energies (Sequence[float]) – in eV.

fit(order: int) → None[source]

Do polynomial fitting and set the parameters. Uses numpy polyfit.

Parameters:

order (int) – order of the fit polynomial

class PourierTarantola(volumes: Sequence[float], energies: Sequence[float])[source]

Bases: EOSBase

Pourier-Tarantola EOS.

Parameters:

• volumes (Sequence[float]) – in Ang^3.

• energies (Sequence[float]) – in eV.

class Vinet(volumes: Sequence[float], energies: Sequence[float])[source]

Bases: EOSBase

Vinet EOS.

Parameters:

• volumes (Sequence[float]) – in Ang^3.

• energies (Sequence[float]) – in eV.

pymatgen.analysis.ewald module

This module provides classes for calculating the Ewald sum of a structure.

pymatgen.analysis.excitation module

This module defines an excitation spectrum class.

class ExcitationSpectrum(x, y)[source]

Bases: Spectrum

Basic excitation spectrum object.

x[source]

The sequence of energies.

Type:

Sequence[float]

y[source]

The sequence of mu(E).

Type:

Sequence[float]

Parameters:

• x – A sequence of x-ray energies in eV

• y – A sequence of intensity values.

XLABEL = 'Energy (eV)'[source]

YLABEL = 'Intensity'[source]

pymatgen.analysis.fragmenter module

Perform fragmentation of molecules.

class Fragmenter(molecule: Molecule, edges: list | None = None, depth: int = 1, open_rings: bool = False, use_metal_edge_extender: bool = False, opt_steps: int = 10000, prev_unique_frag_dict: dict | None = None, assume_previous_thoroughness: bool = True)[source]

Bases: MSONable

Molecule fragmenter class.

Standard constructor for molecule fragmentation.

Parameters:

• molecule (Molecule) – The molecule to fragment.

• edges (list) – List of index pairs that define graph edges, aka molecule bonds. If not set, edges will be determined with OpenBabel. Defaults to None.

• depth (int) – The number of levels of iterative fragmentation to perform, where each level will include fragments obtained by breaking one bond of a fragment one level up. Defaults to 1. However, if set to 0, instead all possible fragments are generated using an alternative, non-iterative scheme.

• open_rings (bool) – Whether or not to open any rings encountered during fragmentation. Defaults to False. If true, any bond that fails to yield disconnected graphs when broken is instead removed and the entire structure is optimized with OpenBabel in order to obtain a good initial guess for an opened geometry that can then be put back into QChem to be optimized without the ring just reforming.

• use_metal_edge_extender (bool) – Whether or not to attempt to add additional edges from O, N, F, or Cl to any Li or Mg atoms present that OpenBabel may have missed. Defaults to False. Most important for ionic bonding. Note that additional metal edges may yield new “rings” (e.g. -C-O-Li-O- in LiEC) that will not play nicely with ring opening.

• opt_steps (int) – Number of optimization steps when opening rings. Defaults to 10000.

• prev_unique_frag_dict (dict) – A dictionary of previously identified unique fragments. Defaults to None. Typically only used when trying to find the set of unique fragments that come from multiple molecules.

• assume_previous_thoroughness (bool) – Whether or not to assume that a molecule / fragment provided in prev_unique_frag_dict has all of its unique subfragments also provided in prev_unique_frag_dict. Defaults to True. This is an essential optimization when trying to find the set of unique fragments that come from multiple molecules if all of those molecules are being fully iteratively fragmented. However, if you’re passing a prev_unique_frag_dict which includes a molecule and its fragments that were generated at insufficient depth to find all possible subfragments to a fragmentation calculation of a different molecule that you aim to find all possible subfragments of and which has common subfragments with the previous molecule, this optimization will cause you to miss some unique subfragments.

open_ring(mol_graph: MoleculeGraph, bond: list, opt_steps: int) → MoleculeGraph[source]

Open a ring using OpenBabel’s local opt. Given a molecule graph and a bond, convert the molecule graph into an OpenBabel molecule, remove the given bond, perform the local opt with the number of steps determined by self.steps, and then convert the resulting structure back into a molecule graph to be returned.

pymatgen.analysis.functional_groups module

Determine functional groups present in a Molecule.

class FunctionalGroupExtractor(molecule, optimize=False)[source]

Bases: object

This class is used to algorithmically parse a molecule (represented by an instance of pymatgen.analysis.graphs.MoleculeGraph) and determine arbitrary functional groups.

Instantiation method for FunctionalGroupExtractor.

Parameters:

• molecule – Either a filename, a pymatgen.core.structure.Molecule object, or a pymatgen.analysis.graphs.MoleculeGraph object.

• optimize – Default False. If True, then the input molecule will be modified, adding Hydrogens, performing a simple conformer search, etc.

categorize_functional_groups(groups)[source]

Determine classes of functional groups present in a set.

Parameters:

groups – Set of functional groups.

Returns:

dict containing representations of the groups, the indices of where the group occurs in the MoleculeGraph, and how many of each type of group there is.

get_all_functional_groups(elements=None, func_groups=None, catch_basic=True)[source]

Identify all functional groups (or all within a certain subset) in the molecule, combining the methods described above.

Parameters:

• elements – List of elements that will qualify a carbon as special (if only certain functional groups are of interest). Default None.

• func_groups – List of strs representing the functional groups of interest. Default to None, meaning that all of the functional groups defined in this function will be sought.

• catch_basic – bool. If True, use get_basic_functional_groups and other methods

Returns:

list of sets of ints, representing groups of connected atoms

get_basic_functional_groups(func_groups=None)[source]

Identify functional groups that cannot be identified by the Ertl method of get_special_carbon and get_heteroatoms, such as benzene rings, methyl groups, and ethyl groups.

TODO: Think of other functional groups that are important enough to be added (ex: do we need ethyl, butyl, propyl?)

Parameters:

func_groups – List of strs representing the functional groups of interest. Default to None, meaning that all of the functional groups defined in this function will be sought.

Returns:

list of sets of ints, representing groups of connected atoms

get_heteroatoms(elements=None)[source]

Identify non-H, non-C atoms in the MoleculeGraph, returning a list of their node indices.

Parameters:

• elements – List of elements to identify (if only certain

• interest). (functional groups are of)

Returns:

set of ints representing node indices

get_special_carbon(elements=None)[source]

Identify Carbon atoms in the MoleculeGraph that fit the characteristics defined Ertl (2017), returning a list of their node indices.

The conditions for marking carbon atoms are (quoted from Ertl):

“- atoms connected by non-aromatic double or triple bond to any heteroatom - atoms in nonaromatic carbon-carbon double or triple bonds - acetal carbons, i.e. sp3 carbons connected to two or more oxygens, nitrogens or sulfurs; these O, N or S atoms must have only single bonds - all atoms in oxirane, aziridine and thiirane rings”

Parameters:

elements – List of elements that will qualify a carbon as special (if only certain functional groups are of interest). Default None.

Returns:

set of ints representing node indices

link_marked_atoms(atoms)[source]

Take a list of marked “interesting” atoms (heteroatoms, special carbons) and attempt to connect them, returning a list of disjoint groups of special atoms (and their connected hydrogens).

Parameters:

atoms – set of marked “interesting” atoms, presumably identified using other functions in this class.

Returns:

list of sets of ints, representing groups of connected atoms

pymatgen.analysis.graphs module

Module for graph representations of crystals and molecules.

pymatgen.analysis.hhi module

This module is used to estimate the Herfindahl-Hirschman Index, or HHI, of chemical compounds. The HHI is a measure of how geographically confined or dispersed the elements comprising a compound are. A low HHI is desirable because it means the component elements are geographically dispersed.

Data/strategy from “Data-Driven Review of Thermoelectric Materials: Performance and Resource Considerations” by Gaultois et al., published in Chemistry of Materials (2013).

pymatgen.analysis.interface_reactions module

This module provides a class to predict and analyze interfacial reactions between two solids, with or without an open element (e.g., flowing O2).

class GrandPotentialInterfacialReactivity(c1: Composition, c2: Composition, grand_pd: GrandPotentialPhaseDiagram, pd_non_grand: PhaseDiagram, include_no_mixing_energy: bool = False, norm: bool = True, use_hull_energy: bool = True)[source]

Bases: InterfacialReactivity

Extends upon InterfacialReactivity to allow for modelling possible reactions at the interface between two solids in the presence of an open element. The thermodynamics of the open system are provided by the user via the GrandPotentialPhaseDiagram class.

Parameters:

• c1 – Reactant 1 composition

• c2 – Reactant 2 composition

• grand_pd – Grand potential phase diagram object built from all elements in composition c1 and c2.

• include_no_mixing_energy – No_mixing_energy for a reactant is the opposite number of its energy above grand potential convex hull. In cases where reactions involve elements reservoir, this param determines whether no_mixing_energy of reactants will be included in the final reaction energy calculation. By definition, if pd is not a GrandPotentialPhaseDiagram object, this param is False.

• pd_non_grand – PhaseDiagram object but not GrandPotentialPhaseDiagram object built from elements in c1 and c2.

• norm – Whether or not the total number of atoms in composition of reactant will be normalized to 1.

• use_hull_energy – Whether or not use the convex hull energy for a given composition for reaction energy calculation. If false, the energy of ground state structure will be used instead. Note that in case when ground state can not be found for a composition, convex hull energy will be used associated with a warning message.

get_no_mixing_energy()[source]

Generate the opposite number of energy above grand potential convex hull for both reactants.

Returns:

[(reactant1, no_mixing_energy1),(reactant2,no_mixing_energy2)].

class InterfacialReactivity(c1: Composition, c2: Composition, pd: PhaseDiagram, norm: bool = True, use_hull_energy: bool = False, **kwargs)[source]

Bases: MSONable

Model an interface between two solids and its possible reactions. The two reactants are provided as Composition objects (c1 and c2), along with the relevant compositional PhaseDiagram object. Possible reactions are calculated by finding all points along a tie-line between c1 and c2 where there is a “kink” in the phase diagram; i.e. a point or facet of the phase diagram.

Please consider citing one or both of the following papers if you use this code in your own work.

References

Richards, W. D., Miara, L. J., Wang, Y., Kim, J. C., &amp; Ceder, G. (2015). Interface stability in solid-state batteries. Chemistry of Materials, 28(1), 266-273. https://doi.org/10.1021/acs.chemmater.5b04082

Xiao, Y., Wang, Y., Bo, S.-H., Kim, J. C., Miara, L. J., &amp; Ceder, G. (2019). Understanding interface stability in solid-state batteries. Nature Reviews Materials, 5(2), 105-126. https://doi.org/10.1038/s41578-019-0157-5

Parameters:

• c1 – Reactant 1 composition

• c2 – Reactant 2 composition

• pd – Phase diagram object built from all elements in composition c1 and c2.

• norm – Whether or not the total number of atoms in composition of reactant will be normalized to 1.

• use_hull_energy – Whether or not use the convex hull energy for a given composition for reaction energy calculation. If false, the energy of ground state structure will be used instead. Note that in case when ground state can not be found for a composition, convex hull energy will be used associated with a warning message.

EV_TO_KJ_PER_MOL = 96.4853[source]

classmethod get_chempot_correction(element: str, temp: float, pres: float)[source]

Get the normalized correction term Δμ for chemical potential of a gas phase consisting of element at given temperature and pressure, referenced to that in the standard state (T_std = 298.15 K, T_std = 1 bar). The gas phase is limited to be one of O2, N2, Cl2, F2, H2. Calculation formula can be found in the documentation of Materials Project website.

Parameters:

• element – The string representing the element.

• temp – The temperature of the gas phase in Kelvin.

• pres – The pressure of the gas phase in Pa. # codespell:ignore pres

Returns:

The correction of chemical potential in eV/atom of the gas phase at given temperature and pressure.

get_critical_original_kink_ratio()[source]

Get a list of molar mixing ratio for each kink between ORIGINAL (instead of processed) reactant compositions. This is the same list as mixing ratio obtained from get_kinks method if self.norm = False.

Returns:

A list of floats representing molar mixing ratios between the original reactant compositions for each kink.

get_dataframe() → DataFrame[source]

Get a pandas DataFrame representation of the data produced by the get_kinks() method.

get_kinks() → list[tuple[int, float, float, Reaction, float]][source]

Find all the kinks in mixing ratio where reaction products changes along the tie-line of composition self.c1 and composition self.c2.

Returns:

(index, mixing ratio, reaction energy in eV/atom, Reaction object, reaction energy per mol of formula in kJ/mol).

Return type:

List object of tuples, each of which contains 5 elements

property labels[source]

A dictionary containing kink information: {index: ‘x= mixing_ratio energy= reaction_energy reaction_equation’}. e.g. {1: ‘x= 0 energy = 0 Mn -> Mn’,

2: ‘x= 0.5 energy = -15 O2 + Mn -> MnO2’, 3: ‘x= 1 energy = 0 O2 -> O2’}.

property minimum[source]

The minimum reaction energy E_min and corresponding mixing ratio x_min as tuple[float, float]: (x_min, E_min).

plot(backend: Literal['plotly', 'matplotlib'] = 'plotly') → Figure | plt.Figure[source]

Plots reaction energy as a function of mixing ratio x in self.c1 - self.c2 tie line.

Parameters:

backend ("plotly" | "matplotlib") – Plotting library used to create the plot. Defaults to “plotly” but can also be “matplotlib”.

Returns:

Plot of reaction energies as a function of mixing ratio

property products[source]

List of formulas of potential products. e.g. [‘Li’,’O2’,’Mn’].