vasppy.procar module

class KPoint(index, frac_coords, weight)[source]

Bases: object

cart_coords(reciprocal_lattice)[source]

Convert the reciprocal fractional coordinates for this k-point to reciprocal Cartesian coordinates.

Parameters:: reciprocal_lattice (np.array(float)) – 3x3 numpy array containing the Cartesian reciprocal lattice.
Returns:: The reciprocal Cartesian coordinates of this k-point.
Return type:: np.array

class Procar(spin=1, negative_occupancies='warn')[source]

Bases: object

Object for working with PROCAR data.

data

A 5D numpy array that stores the projection data.

Axes are k-points, bands, spin-channels, ions and sum over ions, lm-projections.

Type:: numpy.array(float)

bands

A numpy array of Band objects, that contain band index, energy, and occupancy data.

Type:: numpy.array(Band)

k_points

A numpy array of KPoint objects, that contain fractional coordinates and weights for each k-point.

Type:: numpy.array(KPoint)

number_of_k_points

The number of k-points.

Type:: int

number_of_bands

The number of bands.

Type:: int

spin_channels

Number of spin channels in the PROCAR data:

1 for non-spin-polarised calculations.
2 for spin-polarised calculations.
4 for non-collinear calculations.

Type:: int

number_of_ions

The number of ions.

Type:: int

number_of_projections

The number of projections, e.g. TODO

Type:: int

calculation

Dictionary of True | False values describing the calculation type.

Dictionary keys are ‘non_spin_polarised’, ‘non_collinear’, and ‘spin_polarised’.

Type:: dict

property bands

effective_mass_calc(k_point_indices, band_index, reciprocal_lattice, spin=1, printing=False)[source]

classmethod from_file(filename, negative_occupancies='warn', select_zero_weighted_k_points=False)[source]

Create a Procar object by reading the projected wavefunction character of each band from a VASP PROCAR file.

Parameters:

filename (str) – Filename of the PROCAR file.
negative_occupancies (Str, optional) –
Select how negative occupancies are handled. Options are:
- warn (default): Warn that some partial occupancies are negative.
- raise: Raise an AttributeError.
- ignore: Do nothing.
- zero: Negative partial occupancies will be set to zero.
select_zero_weighted_k_points (bool, optional) – Set to True to only read in zero-weighted k-points from the PROCAR file. Default is False.

Returns:

(vasppy.Procar)

classmethod from_files(filenames, **kwargs)[source]

Create a Procar object by reading the projected wavefunction character of each band from a series of VASP PROCAR files.

Useful when e.g. a band-structure calculation has been split over multiple VASP calculations, for example, when using hybrid functionals.

Parameters:

filename (str) – Filename of the PROCAR file.
**kwargs – See the from_file() method for a description of keyword arguments.

Returns:

(vasppy.Procar)

property k_points

property number_of_bands: The number of bands described by this Procar object.

property number_of_ions: The number of ions described by thie Procar object.

property number_of_k_points: The number of k-points described by this Procar object.

property number_of_projections: The number of lm-projections described by this Procar object.

property occupancy

parse_bands()[source]

parse_k_points()[source]

parse_projections()[source]

print_weighted_band_structure(spins=None, ions=None, orbitals=None, scaling=1.0, e_fermi=0.0, reciprocal_lattice=None)[source]

read_from_file(filename)[source]

sanity_check()[source]

select_bands_by_kpoint(band_indices)[source]

select_k_points(band_indices)[source]

property spin_channels: The number of spin-channels described by this Procar object.

weighted_band_structure(spins=None, ions=None, orbitals=None, scaling=1.0, e_fermi=0.0, reciprocal_lattice=None)[source]

x_axis(reciprocal_lattice: ndarray | None = None) → ndarray[source]

Generate the x-axis values for a band-structure plot.

Returns an array of cumulative distances in reciprocal space between sequential k-points.

Parameters:: reciprocal_lattice (np.array, optional) – 3x3 Cartesian reciprocal lattice. Default is None. If no reciprocal lattice is provided, the returned x-axis values will be sequential integers, giving even spacings between sequential k-points.
Returns:: An array of x-axis values.
Return type:: np.array

area_of_a_triangle_in_cartesian_space(a: ndarray, b: ndarray, c: ndarray) → float[source]

Returns the area of a triangle defined by three points in Cartesian space.

Parameters:

a (np.array) – Cartesian coordinates of point A.
b (np.array) – Cartesian coordinates of point B.
c (np.array) – Cartesian coordinates of point C.

Returns:

the area of the triangle.

Return type:

float

get_numbers_from_string(string: str) → list[float][source]

k_point_parser(string: str) → list[KPoint][source]

Parse k-point data from a PROCAR string.

Finds all lines of the form:

k-point    1 :    0.50000000 0.25000000 0.75000000     weight = 0.00806452

and extracts the k-point index, reciprocal fractional coordinates, and weight into a procar.KPoint object.

Parameters:: string (str) – String containing a full PROCAR file.
Returns:: A list of procar.KPoint objects.
Return type:: list(procar.KPoint)

least_squares_effective_mass(cartesian_k_points: ndarray, eigenvalues: ndarray) → float[source]

Calculate the effective mass using a least squares quadratic fit.

Parameters:

cartesian_k_points (np.array) – Cartesian reciprocal coordinates for the k-points.
eigenvalues (np.array) – Energy eigenvalues at each k-point to be used in the fit.

Returns:

The fitted effective mass.

Return type:

float

Raises:

ValueError – If the k-points do not sit on a straight line.

points_are_in_a_straight_line(points, tolerance=1e-07)[source]

Check whether a set of points fall on a straight line. Calculates the areas of triangles formed by triplets of the points. Returns False is any of these areas are larger than the tolerance.

Parameters:

points (list(np.array)) – list of Cartesian coordinates for each point.
(optional (tolerance) – float): the maximum triangle size for these points to be considered colinear. Default is 1e-7.

Returns:

True if all points fall on a straight line (within the allowed tolerance).

Return type:

(bool)

projections_parser(string)[source]

two_point_effective_mass(cartesian_k_points: ndarray, eigenvalues: ndarray) → float[source]

Calculate the effective mass given eigenvalues at two k-points.

Reimplemented from Aron Walsh’s original effective mass Fortran code.

Parameters:

cartesian_k_points (np.array) – 2D numpy array containing the k-points in (reciprocal) Cartesian coordinates.
eigenvalues (np.array) – numpy array containing the eigenvalues at each k-point.

Returns:

The effective mass.

Return type:

float