"""macrodensity.plotting contains different configs of plotting functions such as band
alignment diagrams and potentials at different grid points."""
from __future__ import division, print_function
import os
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from ase.io import cube, vasp
from matplotlib import cm
from scipy.interpolate import interp1d
from macrodensity.averages import (
macroscopic_average,
planar_average,
travelling_volume_average,
volume_average,
)
from macrodensity.density import gradient_magnitude
from macrodensity.io import read_gulp_potential, read_vasp_density
from macrodensity.tools import _find_active_space, create_plotting_mesh
from macrodensity.utils import (
density_2_grid,
matrix_2_abc,
numbers_2_grid,
points_2_plane,
vector_2_abscissa,
)
MODULE_DIR = os.path.dirname(os.path.abspath(__file__))
plt.style.use(f"{MODULE_DIR}/macrodensity.mplstyle")
def energy_band_alignment_diagram(
energies: dict,
ylims: list = (-8, 0),
width: float = 1.0,
cols: list = ["#74356C", "#efce19"],
textsize: int = 24,
arrowhead: float = 0.4,
outfile: str = "BandAlignment",
references: dict = {},
edge=None,
fig_format: str = "pdf",
) -> plt.figure:
"""Plot an energy band alignment diagram for a list of materials.
Parameters:
energies (dict): A dictionary mapping each material name to a tuple
containing its ionization potential (IP) and electron affinity
(EA) (e.g. {"CdS": (4.4, 7.7), ...}).
ylims (tuple, optional): The limits for the energy/y axis (in eV).
Default is (-8.0, 0.0)
width (float, optional): The width of the bars representing IP and EA.
Default is 1.0.
cols (list, optional): A list of colors to use for the bars.
Default is ['#74356C','#efce19'].
textsize (int, optional): The font size for the text in the plot.
Default is 22.
arrowhead (float, optional): The size of the arrowhead for the energy arrows.
Default is 0.7.
outfile (str, optional): The base name for the output file to be saved.
Default is 'BandAlignment'.
references (dict, optional): A dictionary of reference points to be
shown as dashed lines on the plot (e.g. {label: reference_value}.
Default is an empty dictionary.
edge (None or str, optional): The edge color for the bars.
If None, there will be no edge color. Default is None.
fig_format (str, optional): The format used to save the image.
Default is "pdf".
Returns:
Figure: A matplotlib figure object containing the energy band alignment
diagram.
Example:
>>> energies = [(5.2, 2.8), (4.9, 3.1), (5.5, 2.6)]
>>> materials = ['Material A', 'Material B', 'Material C']
>>> energy_band_alignment_diagram(energies, materials, ylims=(-9.0, 0.0), width=0.8,
cols=['#74356C', '#efce19'], textsize=18,
arrowhead=0.5, outfile='BandAlignment',
references={'Reference 1': 3.0, 'Reference 1', 'Reference 2': 4.0},
edge='black')"""
energies_list = list(energies.values())
materials = list(energies.keys())
fig, ax1 = plt.subplots(1, 1, sharex=True)
fig.set_size_inches(len(energies) * 3, abs(ylims[0]) * 0.75)
mpl.rcParams["xtick.labelsize"] = textsize
mpl.rcParams["ytick.labelsize"] = textsize
mpl.rcParams["ytick.direction"] = "in"
mpl.rcParams["ytick.major.width"] = 3
mpl.rcParams["ytick.major.size"] = 7
mpl.rcParams["ytick.minor.size"] = 4
mpl.rcParams["axes.linewidth"] = 3
ax2 = ax1.twinx()
ind = np.arange(len(energies_list))
ax1.set_prop_cycle(color=cols)
# Bars for the IP and background colour
for i in ind:
ax1.bar(i, ylims[0], width, edgecolor=None)
ax1.bar(i, -energies_list[i][1], width, color="w", edgecolor=None)
# Reset the colours back to the start and plot the EA
ax1.set_prop_cycle(color=cols)
for i in ind:
ax1.bar(i, -energies_list[i][0], width, edgecolor=None, alpha=0.8)
# Set the limits of the axes
ax1.set_ylim(ylims[0], ylims[1])
ax2.set_ylim(ylims[0], ylims[1])
ax1.set_xlim(-0.5, len(energies_list) - 0.5)
# Set the names
ax1.set_xticks(ind)
ax1.set_xticklabels(materials, size=textsize)
ran = [float(k) for k in np.arange(0, abs(ylims[0]) + 2, 2)]
ax1.set_yticks([float(k) for k in np.arange(ylims[0], 2, 2)])
ax1.set_yticklabels(ran[::-1], size=textsize)
# Add tick for vacuum level
ran = ["" for k in np.arange(0, abs(ylims[0]) + 2, 2)]
ax2.set_yticks([float(k) for k in np.arange(ylims[0], 2, 2)])
ran[0] = "Vacuum Level"
ax2.set_yticklabels(ran[::-1], size=textsize)
ax1.set_ylabel("Energy (eV)", size=textsize)
# Offsets
os1 = 0.15 # Offset of the text 'IP' in the plot
os2 = 0.2 # Offset of the text 'EA' in the plot
for i, en in enumerate(energies_list):
ax1.arrow(
i - 0.25,
-en[0],
0,
en[0] - arrowhead,
width=0.005,
head_length=arrowhead,
head_width=0.07,
fc="black",
ec="None",
)
ax1.arrow(
i - 0.25,
0,
0,
-en[1] + arrowhead,
width=0.005,
head_length=arrowhead,
head_width=0.07,
fc="black",
ec="None",
)
ax1.arrow(
i - 0.25,
0,
0,
-en[0] + arrowhead,
width=0.005,
head_length=arrowhead,
head_width=0.07,
fc="black",
ec="None",
)
loc_ip = -(en[0] + en[1]) / 2
ax1.text(i - os1, loc_ip, "IP %3.1f" % en[1], fontsize=textsize)
loc_ea = -en[0] / 2
ax1.text(i - os2, loc_ea, "EA %3.1f" % en[0], fontsize=textsize)
# Don't show minor ticks on x-axis
ax1.tick_params(axis="x", which="minor", bottom="off")
ax2.tick_params(axis="x", which="minor", bottom="off")
for label, value in references.items():
ax1.hlines(
-value, -0.5, len(energies_list) - 0.5, linestyles="--", colors="r"
)
ax1.text(
len(energies_list) - 0.45,
-value - 0.1,
label,
fontsize=textsize,
color="r",
)
fig.savefig(f"{outfile}.{fig_format}", bbox_inches="tight")
print(f"Figure saved as {outfile}.{fig_format}")
plt.close(fig)
return fig
def plot_active_space(
cube_size: list,
cube_origin: list,
tolerance: float = 1e-4,
input_file="LOCPOT",
print_output=True,
) -> tuple:
"""Plot the active space (vacuum and non-vacuum regions) based on potential
variations.
This function analyzes the potential variations within the specified
cubes of the given size and determines whether each cube belongs to
the vacuum or non-vacuum region based on the provided tolerance.
This function also plots the cube potentials of vacuum and
non vacuum cubes.
Parameters:
cube_size (list of int): The size of the cubes in units of mesh
points (NGX/Y/Z) for analysis.
cube_origin (list of float): The starting point (origin) of the
cubes in fractional coordinates (range [0, 1]).
tolerance (float, optional): The cutoff variance value to
distinguish vacuum from non-vacuum cubes. Default is 1E-4.
input_file (str, optional): The file with VASP output for potential.
Default is 'LOCPOT'.
print_output (bool, optional): Whether to print the analysis results.
Default is True.
Returns:
tuple: A tuple containing the number of cubes identified as
vacuum and non-vacuum regions.
Note:
The function calculates the potential variation within each
cube and compares it to the tolerance value. Cubes with potential
variations below the tolerance are considered vacuum regions,
while others are non-vacuum regions.
Example:
>>> cube_size = [2, 2, 2]
>>> cube_origin = [0.0, 0.0, 0.0]
>>> plot_active_space(cube_size, cube_origin, tolerance=1E-5)
"""
def _plot_cube_potentials(
coords_vac,
potential_vac,
coords_non_vac,
potential_non_vac,
color_map="viridis",
alpha=0.5,
):
fig = plt.figure(figsize=plt.figaspect(0.4))
# First ax
ax = fig.add_subplot(121, projection="3d")
x, y, z = zip(*coords_vac)
norm_pots = (potential_vac - np.min(potential_vac)) / (
np.max(potential_vac) - np.min(potential_vac)
)
cmap = plt.get_cmap(color_map)
colors = cmap(norm_pots)
ax.scatter(x, y, z, c=colors, alpha=alpha)
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
ax.set_title("Vacuum region")
# set up the axes for the second plot
ax2 = fig.add_subplot(1, 2, 2, projection="3d")
x, y, z = zip(*coords_non_vac)
norm_pots = (potential_non_vac - np.min(potential_non_vac)) / (
np.max(potential_non_vac) - np.min(potential_non_vac)
)
cmap = plt.get_cmap(color_map)
colors = cmap(norm_pots)
ax2.scatter(x, y, z, c=colors, alpha=alpha)
ax2.set_xlabel("X")
ax2.set_ylabel("Y")
ax2.set_zlabel("Z")
ax2.set_title("Non-vacuum region")
norm = plt.Normalize(
vmin=np.min(potential_vac), vmax=np.max(potential_vac)
)
fig.colorbar(
cm.ScalarMappable(norm=norm, cmap=cmap),
ax=[ax, ax2],
fraction=0.08,
pad=0.08,
shrink=0.5,
)
return fig
dict_output = _find_active_space(
input_file=input_file,
cube_size=cube_size,
cube_origin=cube_origin,
tolerance=tolerance,
print_output=True,
)
vacuum, non_vacuum, vac_pot, nvac_pot = (
dict_output["Vacuum"],
dict_output["Non-vacuum"],
dict_output["Vacuum Potential"],
dict_output["Non-vacuum Potential"],
)
fig = _plot_cube_potentials(
coords_vac=vacuum,
potential_vac=vac_pot,
coords_non_vac=non_vacuum,
potential_non_vac=nvac_pot,
color_map="viridis",
)
return fig
def plot_on_site_potential(
species: str,
sample_cube: list,
potential_file: str = "LOCPOT",
coordinate_file: str = "POSCAR",
output_file: str = "OnSitePotential.csv",
img_file: str = "OnSitePotential.png",
) -> tuple:
"""Plot on-site electrostatic potential for a specific species.
This function reads the electronic potential from the specified VASP
output file (LOCPOT) and the atomic coordinates from the POSCAR file.
It then calculates the on-site electrostatic potential for the
specified species and generates a histogram to visualize
its distribution across the sample cube.
Parameters:
species (str): The chemical symbol of the species whose on-site
potential is of interest.
sample_cube (list of int): The size of the sampling cube
in units of mesh points (NGX/Y/Z).
potential_file (str, optional): The filename of the VASP output file
containing the electronic potential (LOCPOT). Default is 'LOCPOT'.
coordinate_file (str, optional): The filename of the POSCAR file
containing atomic coordinates. Default is 'POSCAR'.
output_file (str, optional): Name of the output data file
to store the on-site potential values.
Default is 'OnSitePotential.csv'.
img_file (str, optional): Name of the output image file
for the histogram plot. Default is 'OnSitePotential.png'.
Returns:
tuple: A tuple containing the on-site potential values and the figure object.
Example:
>>> species = 'O'
>>> sample_cube = [2, 2, 2]
>>> potential_file = 'LOCPOT'
>>> coordinate_file = 'POSCAR'
>>> output_file = 'OnSitePotential.csv'
>>> img_file = 'OnSitePotential.png'
>>> on_site_potential = plot_on_site_potential(species, sample_cube, potential_file, coordinate_file, output_file, img_file)
... (plot generated and on-site potential data saved to 'OnSitePotential.png' and 'OnSitePotential.csv')
"""
# Get potential
if (
"vasp" in potential_file
or "LOCPOT" in potential_file
or "CHGCAR" in potential_file
):
vasp_pot, NGX, NGY, NGZ, lattice = read_vasp_density(potential_file)
vector_a, vector_b, vector_c, av, bv, cv = matrix_2_abc(lattice)
resolution_x = vector_a / NGX
resolution_y = vector_b / NGY
resolution_z = vector_c / NGZ
grid_pot, electrons = density_2_grid(
vasp_pot, NGX, NGY, NGZ, config="VASP"
)
elif "cube" in potential_file:
grid_pot, atoms = cube.read_cube_data(potential_file)
vector_a = np.linalg.norm(atoms.cell[1])
vector_b = np.linalg.norm(atoms.cell[1])
vector_c = np.linalg.norm(atoms.cell[2])
NGX = len(grid_pot)
NGY = len(grid_pot[0])
NGZ = len(grid_pot[0][0])
resolution_x = vector_a / NGX
resolution_y = vector_b / NGY
resolution_z = vector_c / NGZ
elif "gulp" in potential_file or ".out" in potential_file:
gulp_pot, NGX, NGY, NGZ, lattice = read_gulp_potential(potential_file)
vector_a, vector_b, vector_c, av, bv, cv = matrix_2_abc(lattice)
resolution_x = vector_a / NGX
resolution_y = vector_b / NGY
resolution_z = vector_c / NGZ
grid_pot = density_2_grid(gulp_pot, NGX, NGY, NGZ, config="GULP")
else:
raise ValueError(f"File {potential_file} not recognised!")
grad_x, grad_y, grad_z = np.gradient(
grid_pot[:, :, :], resolution_x, resolution_y, resolution_z
)
coords = vasp.read_vasp(coordinate_file)
scaled_coords = coords.get_scaled_positions()
symbols = coords.get_chemical_symbols()
ox_coords = []
for i, atom in enumerate(coords):
if symbols[i] == species:
ox_coords.append(scaled_coords[i])
grid_position = np.zeros(shape=(3))
potentials_list = []
i = 0
num_bins = 20
for coord in ox_coords:
i = i + 1
grid_position[0] = coord[0]
grid_position[1] = coord[1]
grid_position[2] = coord[2]
cube = sample_cube
origin = [
grid_position[0] - 2,
grid_position[1] - 2,
grid_position[2] - 1,
]
cube_potential, cube_var = volume_average(
origin, cube, grid_pot, NGX, NGY, NGZ
)
potentials_list.append(cube_potential)
## PLOTTING
fig, ax = plt.subplots()
n, bins, patches = ax.hist(
potentials_list, num_bins, facecolor="#6400E1", alpha=0.5
)
ax.set_xlabel("Hartree potential (V)")
ax.set_ylabel("% of centres")
plt.savefig(img_file)
## SAVING
df = pd.DataFrame.from_dict({"Potential": potentials_list}, orient="index")
df = df.transpose()
df.to_csv(output_file)
return df, fig
def plot_planar_average(
lattice_vector: float,
input_file: str = "LOCPOT", # VASP potential file by default
axis: str = "z",
output_file: str = "planar_average.csv",
img_file: str = "planar_average.png",
new_resolution: int = 3000,
) -> tuple:
"""Calculate planar and macroscopic averages of potential data from different
fileconfigs like gulp, cube, and vasp.
Args:
lattice_vector (float): Size (in A) of the repeating unit which is
used to calculate the macroscopic average. Typically, this would
be the lattice vector of the bulk material in the direction for which
the planar average is being calculated.
input_file (str): Path to the input potential file.
axis (str, Optional): Axis along which to calculate the
planar and macroscopic averages ('x', 'y', or 'z').
Default is "z".
output_file (str): Path to save the output CSV file.
img_file (str): Path to save the output image file.
new_resolution (int): New resolution for interpolation.
Returns:
tuple: A tuple containing a dataframe with the planar average
and macroscopic average and a figure object.
"""
def _plot(planar, macro, img_file):
fig, ax = plt.subplots()
ax.set_ylabel("V (V)")
ax.set_xlabel("Grid Position")
ax.plot(planar, label="Planar")
ax.plot(macro, label="Macroscopic")
ax.legend(frameon=True)
fig.savefig(img_file)
return fig
def _save_df(planar, macro, output_file, interpolated_potential=None):
if interpolated_potential:
df = pd.DataFrame.from_dict(
{
"Planar": planar,
"Macroscopic": macro,
"Interpolated": interpolated_potential,
},
orient="index",
)
else:
df = pd.DataFrame.from_dict(
{"Planar": planar, "Macroscopic": macro}, orient="index"
)
df = df.transpose()
df.to_csv(output_file)
return df
# Check axis is valid
if axis not in ["x", "y", "z"]:
raise ValueError(
f'Axis {axis} not recognised! Must be "x", "y", or "z".'
)
if "cube" in input_file:
potential, atoms = cube.read_cube_data(input_file)
vector_a = np.linalg.norm(atoms.cell[1])
vector_b = np.linalg.norm(atoms.cell[1])
vector_c = np.linalg.norm(atoms.cell[2])
NGX = len(potential)
NGY = len(potential[0])
NGZ = len(potential[0][0])
resolution_x = vector_a / NGX
resolution_y = vector_b / NGY
resolution_z = vector_c / NGZ
## PLANAR AVERAGE
planar = planar_average(potential, NGX, NGY, NGZ, axis=axis)
## MACROSCOPIC AVERAGE
axis_to_resolution = {
"x": resolution_x,
"y": resolution_y,
"z": resolution_z,
}
macro = macroscopic_average(
planar,
lattice_vector,
axis_to_resolution[axis]
)
## PLOTTING
fig = _plot(planar, macro, img_file)
## SAVING
df = _save_df(planar, macro, output_file)
elif "gulp" in input_file or ".out" in input_file:
pot, NGX, NGY, NGZ, lattice = read_gulp_potential(input_file)
vector_a, vector_b, vector_c, av, bv, cv = matrix_2_abc(lattice)
resolution_x = vector_a / NGX
resolution_y = vector_b / NGY
resolution_z = vector_c / NGZ
# TODO: Update config parameter in density_2_grid to be consistent with
# code naming in other functions (e.g. if here we use GULP to refer to GULP,
# should do the same in other functions)
# Also use lower case for config variable following python conventions (eg config -> config)
grid_pot = density_2_grid(pot, NGX, NGY, NGZ, config="GULP")
## POTENTIAL PLANAR AVERAGE
planar = planar_average(grid_pot, NGX, NGY, NGZ, axis=axis)
np.savetxt(output_file, planar)
## MACROSCOPIC AVERAGE
axis_to_ng = {"x": NGX, "y": NGY, "z": NGZ}
axis_to_vector = {"x": vector_a, "y": vector_b, "z": vector_c}
new_abscissa = np.linspace(0, axis_to_ng[axis] - 1, new_resolution)
f = interp1d(range(axis_to_ng[axis]), planar, kind="cubic")
interpolated_potential = [f(i) for i in new_abscissa]
macro = macroscopic_average(
planar, lattice_vector, axis_to_vector[axis] / new_resolution
)
## PLOTTING
fig = _plot(planar, macro, img_file)
## SAVING
df = _save_df(planar, macro, output_file, interpolated_potential)
elif (
"vasp" in input_file
or "LOCPOT" in input_file
or "CHGCAR" in input_file
):
pot, NGX, NGY, NGZ, lattice = read_vasp_density(input_file)
vector_a, vector_b, vector_c, av, bv, cv = matrix_2_abc(lattice)
resolution_x = vector_a / NGX
resolution_y = vector_b / NGY
resolution_z = vector_c / NGZ
grid_pot, electrons = density_2_grid(pot, NGX, NGY, NGZ, config="VASP")
## PLANAR AVERAGE
planar = planar_average(grid_pot, NGX, NGY, NGZ, axis=axis)
## MACROSCOPIC AVERAGE
axis_to_resolution = {
"x": resolution_x,
"y": resolution_y,
"z": resolution_z,
}
macro = macroscopic_average(
planar, lattice_vector, axis_to_resolution[axis]
)
## PLOTTING
fig = _plot(planar, macro, img_file)
## SAVING
df = _save_df(planar, macro, output_file)
else:
raise ValueError(f"File {input_file} not recognised!")
return df, fig
def plot_field_at_point(
a_point: list,
b_point: list,
c_point: list,
input_file: str = "LOCPOT",
grad_calc: bool = False,
) -> plt.figure:
"""Plot the electric field magnitude and direction on a user-defined plane.
This function plots the electric field magnitude and direction on a user-defined plane
defined by three points: a_point, b_point, and c_point.
The function reads the electronic potential data from the specified
input file (e.g., LOCPOT) and calculates the electric field (gradient of the potential).
The electric field is then visualized by plotting contours of the
electric field magnitude and arrows indicating the direction of the
electric field on the defined plane.
Parameters:
a_point (list): The fractional coordinates of the first point defining the plane.
b_point (list): The fractional coordinates of the second point defining the plane.
c_point (list): The fractional coordinates of the third point defining the plane.
input_file (str, optional): The filename of the file containing the
electronic potential (e.g., LOCPOT). Default is 'LOCPOT'.
grad_calc (bool): if True , calculates the gradient of the field.
Default is False due to computational expense
Returns:
Figure: A matplotlib figure object containing the electric field contours and arrows.
Example:
>>> a_point = [0.1, 0.2, 0.3]
>>> b_point = [0.4, 0.5, 0.6]
>>> c_point = [0.7, 0.8, 0.9]
>>> input_file = 'LOCPOT'
>>> plot_field_at_point(a_point, b_point, c_point, input_file)
"""
# ------------------------------------------------------------------
# Get the potential
# ------------------------------------------------------------------
vasp_pot, NGX, NGY, NGZ, lattice = read_vasp_density(input_file)
vector_a, vector_b, vector_c, av, bv, cv = matrix_2_abc(lattice)
resolution_x = vector_a / NGX
resolution_y = vector_b / NGY
resolution_z = vector_c / NGZ
grid_pot, electrons = density_2_grid(
vasp_pot, NGX, NGY, NGZ, config="VASP"
)
## Get the gradiens (Field), if required.
## Comment out if not required, due to compuational expense.
if grad_calc == True:
print("Calculating gradients (Electic field, E=-Grad.V )...")
grad_x, grad_y, grad_z = np.gradient(
grid_pot[:, :, :], resolution_x, resolution_y, resolution_z
)
else:
pass
# ------------------------------------------------------------------
## Get the equation for the plane
## This is the section for plotting on a user defined plane;
## uncomment commands if this is the option that you want.
##------------------------------------------------------------------
## Convert the fractional points to grid points on the density surface
a = numbers_2_grid(a_point, NGX, NGY, NGZ)
b = numbers_2_grid(b_point, NGX, NGY, NGZ)
c = numbers_2_grid(c_point, NGX, NGY, NGZ)
plane_coeff = points_2_plane(a, b, c)
## Calculate magnitude of gradient.
# Should be able to use numpy.linalg.norm for this, but the Python array indices are causing me grief
X2 = np.multiply(grad_x, grad_x)
Y2 = np.multiply(grad_y, grad_y)
Z2 = np.multiply(grad_z, grad_z)
grad_mag = np.linalg.norm(np.add(X2, Y2, Z2), axis=-1)
# This was my, non working, attempt to use the built in function.
# grad_mag=np.linalg.norm( [grad_y,grad_y,grad_z], axis=3)
## This function in Macrodensity averages Efield ACROSS Z for Slab calculations
xx, yy, grd = md.create_plotting_mesh(
NGX, NGY, NGZ, plane_coeff, grad_mag
) # AVG over full volume
# Here we construct the same xx,yy,grd variables with a SLICE, forming a plane in XY at particular ZSLICE
xx, yy = np.mgrid[0:NGX, 0:NGY]
ZSLICE = NGZ / 2 # Chosses where in the Z axis the XY slice is cut through
# Slice of magnitude of electric field, for contour plotting
grd = grad_mag[:, :, ZSLICE]
# Slices of x and y components for arrow plotting
grad_x_slice = grad_x[:, :, ZSLICE]
grad_y_slice = grad_y[:, :, ZSLICE]
# OK, that's all our data
# This code tiles the data to (2,2) to re-expand unit cell to a 2x2 supercell in XY
xx, yy = np.mgrid[0 : 2 * NGX, 0 : 2 * NGY]
grd = np.tile(grd, (2, 2))
grad_x_slice = np.tile(grad_x_slice, (2, 2))
grad_y_slice = np.tile(grad_y_slice, (2, 2))
# End of tiling code
## Contours of the above sliced data
fig, ax = plt.subplots()
ax.contour(xx, yy, grd, 6, cmap=cm.cubehelix)
# Also generate a set of Efield arrows ('quiver') for this data.
# Specifying the drawing parameters is quite frustrating - they are very brittle + poorly documented.
ax.quiver(
xx,
yy,
grad_x_slice,
grad_y_slice,
color="grey",
units="dots",
width=1,
headwidth=3,
headlength=4,
) # ,
# units='xy', scale=10., zorder=3, color='blue',
# width=0.007, headwidth=3., headlength=4.)
plt.axis(
"equal"
) # force square aspect ratio; this assuming X and Y are equal.
plt.show()
return fig
def plot_plane_field(
a_point: list,
b_point: list,
c_point: list,
input_file: str = "LOCPOT"
) -> plt.figure:
"""Plot the electric field on a user-defined plane and display it as a contour plot.
Parameters:
a_point (list): Fractional coordinates of the first point that defines the plane.
b_point (list): Fractional coordinates of the second point that defines the plane.
c_point (list): Fractional coordinates of the third point that defines the plane.
input_file (str, optional): The filename of the VASP LOCPOT file containing the
electrostatic potential. Default is 'LOCPOT'.
Returns:
Figure: A matplotlib figure object containing the electric field contours.
Note:
- The function reads the electrostatic potential from the specified VASP LOCPOT file.
- The plane is defined by three points: a_point, b_point, and c_point.
- The electric field (gradient of the electrostatic potential) is computed using finite differences.
- The function creates a contour plot of the electric field on the defined plane.
"""
# ------------------------------------------------------------------
# Get the potential
# ------------------------------------------------------------------
vasp_pot, NGX, NGY, NGZ, lattice = read_vasp_density(input_file)
vector_a, vector_b, vector_c, av, bv, cv = matrix_2_abc(lattice)
resolution_x = vector_a / NGX
resolution_y = vector_b / NGY
resolution_z = vector_c / NGZ
grid_pot, electrons = density_2_grid(
vasp_pot, NGX, NGY, NGZ, config="VASP"
)
## Get the gradiens (Field), if required.
## Comment out if not required, due to compuational expense.
grad_x, grad_y, grad_z = np.gradient(
grid_pot[:, :, :], resolution_x, resolution_y, resolution_z
)
# ------------------------------------------------------------------
## Get the equation for the plane
## This is the section for plotting on a user defined plane;
## uncomment commands if this is the option that you want.
##------------------------------------------------------------------
## Convert the fractional points to grid points on the density surface
a = numbers_2_grid(a_point, NGX, NGY, NGZ)
b = numbers_2_grid(b_point, NGX, NGY, NGZ)
c = numbers_2_grid(c_point, NGX, NGY, NGZ)
plane_coeff = points_2_plane(a, b, c)
## Get the gradients
XY = np.multiply(grad_x, grad_y)
grad_mag = np.multiply(XY, grad_z)
## Create the plane
# print(NGX,NGY,NGZ,plane_coeff,grad_mag)
xx, yy, grd = create_plotting_mesh(NGX, NGY, NGZ, plane_coeff, grad_mag)
print(create_plotting_mesh(NGX, NGY, NGZ, plane_coeff, grad_mag)[10])
## Plot the surface
fig, ax = plt.subplots()
ax.contour(xx, yy, grd, 1)
plt.show()
return fig
def plot_active_plane(
cube_size: list,
cube_origin: list,
tolerance: float = 1e-4,
input_file: str = "LOCPOT",
grad_calc: bool = False,
) -> plt.figure:
"""Plot the active plane with contour and planar average of the electric field and
potential.
Parameters:
cube_size (list): The size of the cube used for sampling the active plane.
cube_origin (list): The origin point of the cube in fractional coordinates.
tolerance (float, optional): The cutoff variance for identifying active and
non-active cubes. Default is 1E-4.
input_file (str, optional): The filename of the VASP LOCPOT file containing
the electrostatic potential. Default is 'LOCPOT'.
grad_calc (bool): if True , calculates the gradient of the field.
Default is False due to computational expense
Returns:
Figure: A matplotlib figure object containing the electric field contours and planar average.
Note:
- The function reads the electrostatic potential from the specified VASP LOCPOT
file.
- The active plane is determined by sampling the potential in a cube around the
cube_origin point.
- The cutoff_varience parameter sets the threshold for distinguishing active and
non-active cubes based on their variance in potential.
- The function creates a contour plot of the electric field on the active plane.
- It also plots the planar average of the electric field and potential throughout the material.
"""
# ------------------------------------------------------------------
# Get the potential
# ------------------------------------------------------------------
vasp_pot, NGX, NGY, NGZ, lattice = read_vasp_density(input_file)
vector_a, vector_b, vector_c, av, bv, cv = matrix_2_abc(lattice)
resolution_x = vector_a / NGX
resolution_y = vector_b / NGY
resolution_z = vector_c / NGZ
grid_pot, electrons = density_2_grid(
vasp_pot, NGX, NGY, NGZ, config="VASP"
)
potential_variance = np.var(grid_pot)
cutoff_variance = tolerance
active_cube = (
potential_variance >= cutoff_variance
) # using tolerance in input parameter
# Input section (define the plane with 3 points, fractional coordinates)
a_point = [0, 0, 0]
b_point = [1, 0, 1]
c_point = [0, 1, 0]
if active_cube:
## Get the gradiens (Field), if required.
## Comment out if not required, due to compuational expense.
if grad_calc == True:
print("Calculating gradients (Electic field, E=-Grad.V )...")
grad_x, grad_y, grad_z = np.gradient(
grid_pot[:, :, :], resolution_x, resolution_y, resolution_z
)
else:
pass
## Convert the fractional points to grid points on the density surface
a = numbers_2_grid(a_point, NGX, NGY, NGZ)
b = numbers_2_grid(b_point, NGX, NGY, NGZ)
c = numbers_2_grid(c_point, NGX, NGY, NGZ)
plane_coeff = points_2_plane(a, b, c)
## Get the gradients
XY = np.multiply(grad_x, grad_y)
grad_mag = np.multiply(XY, grad_z)
## Create the plane
xx, yy, grd = create_plotting_mesh(NGX, NGY, NGZ, plane_coeff, grad_x)
## Plot the surface
plt.contourf(
xx, yy, grd
) # This only plots the surface (no contour for the potentials)
plt.show()
else:
print("The cube is not active (variance is below tolerance set)")
##------------------------------------------------------------------
## Plotting a planar average (Field/potential) throughout the material
##------------------------------------------------------------------
## FIELDS
planar = planar_average(grad_x, NGX, NGY, NGZ)
## POTENTIAL
planar = planar_average(grid_pot, NGX, NGY, NGZ)
## MACROSCOPIC AVERAGE
macro = macroscopic_average(planar, 4.80, resolution_z)
fig, ax = plt.subplots()
ax.plot(planar)
ax.plot(macro)
plt.savefig("Planar.eps")
plt.show()
return fig
def plot_variation_along_vector(
vector: list = [1, 1, 1],
cube_size: list = [1, 1, 1],
origin_point: list = [0, 0, 0],
vector_magnitude: int = 280,
input_file: str = "LOCPOT",
show_electric_field: bool = True,
img_file: str = "potential_variation.png",
output_file: str = "potential_variation.csv",
):
"""Plot the potential and field variation along a specified vector.
This function calculates the volume average of the electronic potential as
function of the position along the specified vector. The volume average is
performed by moving a cube of specified dimensions along the vector from the
specified origin position. The magnitude parameter determines the distance
covered in each direction from the origin. The resulting potential values
at each position are plotted, and the data is saved to a CSV file.
Parameters:
vector (:obj:`list`, optional): The vector along which the cube moves
for volume averaging. Default is [1, 1, 1].
cube_size (:obj:`list`, optional): The size of the cube used for
volume averaging in units of mesh points (NGX/Y/Z). Default is [1, 1, 1].
origin_point (:obj:`list`, optional): The starting position of the cube
in fractional coordinates. Default is [0, 0, 0].
magnitude (:obj:`float`, optional): The distance covered by the cube in
each direction from the origin along the vector (in Angstroms).
Default is 280.
input_file (:obj:`str`, optional): The filename of the file containing
the electronic potential (e.g., LOCPOT). Default is 'LOCPOT'.
output_file (:obj:`str,` optional): Name of the output data file to store
the volume-averaged potential data. Default is 'MovingCube.csv'.
img_file (:obj:`str`, optional): Name of the output image file for the
potential plot. Default is 'MovingCube.png'.
Returns:
:obj:`fig`: A figure showing the volume-averaged potential values
at each position along the vector.
"""
vasp_pot, NGX, NGY, NGZ, lattice = read_vasp_density(input_file)
vector_a, vector_b, vector_c, av, bv, cv = matrix_2_abc(lattice)
resolution_x = vector_a / NGX
resolution_y = vector_b / NGY
resolution_z = vector_c / NGZ
grid_pot, electrons = density_2_grid(vasp_pot, NGX, NGY, NGZ)
grad_x, grad_y, grad_z = np.gradient(
grid_pot[:, :, :], resolution_x, resolution_y, resolution_z
)
# Average along vector
cubes_potential = travelling_volume_average(
grid=grid_pot,
cube=cube_size,
origin=origin_point,
vector=vector,
nx=NGX,
ny=NGY,
nz=NGZ,
magnitude=vector_magnitude,
)
abscissa = vector_2_abscissa(
vector,
vector_magnitude,
resolution_x,
resolution_y,
resolution_z,
)
# Plotting potential
fig, ax = plt.subplots()
ax.plot(abscissa, cubes_potential)
ax.set_xlabel("$z (\AA)$")
ax.set_ylabel("Potential (V)")
# Plot field
if show_electric_field:
# Getting the field and plotting it
grad_mag = gradient_magnitude(grad_x, grad_y, grad_z)
cubes_field = travelling_volume_average(
grid=grad_mag,
cube=cube_size,
origin=origin_point,
vector=vector,
nx=NGX,
ny=NGY,
nz=NGZ,
magnitude=vector_magnitude,
)
ax.plot(abscissa, cubes_field)
ax.set_ylabel("Magnitude")
ax.legend(
["Potential (eV)", "Field Magnitude (eV/$\AA$))"], frameon=True
)
fig.savefig(img_file)
# Save dataframe
df = pd.DataFrame.from_dict({"Potential": cubes_potential}, orient="index")
df = df.transpose()
df.to_csv(output_file)
return fig
"""macrodensity.plotting contains different configs of plotting functions such as band
alignment diagrams and potentials at different grid points."""
from __future__ import division, print_function
import os
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from ase.io import cube, vasp
from matplotlib import cm
from scipy.interpolate import interp1d
from macrodensity.averages import (
macroscopic_average,
planar_average,
travelling_volume_average,
volume_average,
)
from macrodensity.density import gradient_magnitude
from macrodensity.io import read_gulp_potential, read_vasp_density
from macrodensity.tools import _find_active_space, create_plotting_mesh
from macrodensity.utils import (
density_2_grid,
matrix_2_abc,
numbers_2_grid,
points_2_plane,
vector_2_abscissa,
)
MODULE_DIR = os.path.dirname(os.path.abspath(__file__))
plt.style.use(f"{MODULE_DIR}/macrodensity.mplstyle")
def energy_band_alignment_diagram(
energies: dict,
ylims: list = (-8, 0),
width: float = 1.0,
cols: list = ["#74356C", "#efce19"],
textsize: int = 24,
arrowhead: float = 0.4,
outfile: str = "BandAlignment",
references: dict = {},
edge=None,
fig_format: str = "pdf",
) -> plt.figure:
"""Plot an energy band alignment diagram for a list of materials.
Parameters:
energies (dict): A dictionary mapping each material name to a tuple
containing its ionization potential (IP) and electron affinity
(EA) (e.g. {"CdS": (4.4, 7.7), ...}).
ylims (tuple, optional): The limits for the energy/y axis (in eV).
Default is (-8.0, 0.0)
width (float, optional): The width of the bars representing IP and EA.
Default is 1.0.
cols (list, optional): A list of colors to use for the bars.
Default is ['#74356C','#efce19'].
textsize (int, optional): The font size for the text in the plot.
Default is 22.
arrowhead (float, optional): The size of the arrowhead for the energy arrows.
Default is 0.7.
outfile (str, optional): The base name for the output file to be saved.
Default is 'BandAlignment'.
references (dict, optional): A dictionary of reference points to be
shown as dashed lines on the plot (e.g. {label: reference_value}.
Default is an empty dictionary.
edge (None or str, optional): The edge color for the bars.
If None, there will be no edge color. Default is None.
fig_format (str, optional): The format used to save the image.
Default is "pdf".
Returns:
Figure: A matplotlib figure object containing the energy band alignment
diagram.
Example:
>>> energies = [(5.2, 2.8), (4.9, 3.1), (5.5, 2.6)]
>>> materials = ['Material A', 'Material B', 'Material C']
>>> energy_band_alignment_diagram(energies, materials, ylims=(-9.0, 0.0), width=0.8,
cols=['#74356C', '#efce19'], textsize=18,
arrowhead=0.5, outfile='BandAlignment',
references={'Reference 1': 3.0, 'Reference 1', 'Reference 2': 4.0},
edge='black')"""
energies_list = list(energies.values())
materials = list(energies.keys())
fig, ax1 = plt.subplots(1, 1, sharex=True)
fig.set_size_inches(len(energies) * 3, abs(ylims[0]) * 0.75)