COGITOpost

Post-processing and plotting tools for visualizing COGITO results.

class COGITO_dft.COGITOpost.COGITO_TB_Model(directory: str, verbose: int = 0, file_suffix: str = '', file_type: str = 'npy', tb_file: str = 'TBparams', over_file: str = 'overlaps', orbs_orth: bool = False, spin_polar: bool = False)

Bases: object

read_input(file: str = 'tb_input.txt') → None

Reads the tb_input.txt for information about the unit cell, atoms, orbitals, fermi energy, energy shift, and spin polarization.

read_TBparams(file: str = 'TBparams', file_type: str = 'npy') → None

Reads in the tight binding (hopping) parameters from a file formatted like wannier90_hr.dat.

Parameters:

file (str) – The file name for the TB parameters.

read_overlaps(file: str = 'overlaps', file_type: str = 'npy') → None

Reads in the orbital overlaps from a file formatted like wannier90_hr.dat.

Parameters:

file (str) – The file name for the overlaps.

read_orbitals(file: str = 'orbitals.npy') → None

This function reads in the orbitals as coefficents for a gaussian expansion. The information in ‘orbitals.npy’ is combined with the orbital data in ‘tb_input.txt’.

Parameters:

file (str) – Orbital file.

normalize_params()

This function correctly normalized the overlap and hopping parameters such that the diagonal of overlap is one. i.e. overlap[orb1=orb2,trans123=0]=1. While the COGITO process gets nearly correctly normalized orbitals (0.99-1.01), generated the TB model from VASP psuedo is not correctly normalized. Running this function ensures that comparison between models of different types and normalizations is correct.

set_hoppings(value: float, orb1: int, orb2: int, trans: tuple, spin: int = 0) → None

Change a TB parameter.

Parameters:

• value (float) – The new parameter.

• orb1 (int) – The first orbital index of the parameter.

• orb2 (int) – The second orbital index of the parameter.

• trans (tuple) – The tuple of translation indices.

Return type:

None

restrict_params(maximum_dist: float = 12.0, minimum_value: float = 0.0001) → None

Generates self.use_tbparams, self.use_overlaps, and self.use_vecs_to_orbs which are used in the gen_ham() funciton. With this, the calculation of hamiltonians by gen_ham() is both sparse and vectorized.

Parameters:

• maximum_dist (float) – The maximmum distance between hopping parameters which should be included.

• minimum_value (float) – The minimum magnitude of hopping parameter which should be included.

static make_orbitals(self, cartXYZ)

static plot_orbitals(self)

static generate_gpnts(self, kpt: list)

Similar to from pymatgen.io.vasp.outputs.Wavecar but is vectorized.

Parameters:

kpt (list) – The k-point in reduced coordinates.

Returns:

The gpoints

Return type:

NDArray

static get_ham(self: object, kpt: list, return_overlap: bool = False, return_truevec: bool = True, spin: int = 0) → list

This function generates the hamiltonian and overlap matrices for a given kpt. Then it solves the generalized eigenvalue problem to return the eigvalues and vectors.

Parameters:

• self (object) – An object with the attributes of the COGITO_TB_Model class.

• kpt (list) – The kpoint to regenerate at in reduced coordinates.

• return_overlap (bool) – If True, the function will also return the overlap matrix at the kpt. Default is False.

• return_truevec (bool) – If True, the function will return the eigenvectors in the original nonorthogonal basis. Default if True.

• spin (int) – The spin of the parameters for a spin-polarized calculation. Default is 0–for non spin-polarized.

Returns:

Returns a list of the eigenvalues and eigenvectors (and overlap if return_overlap=True).

Return type:

list

static get_fullHam(self: object, kpt: list, spin: int = 0)

Find and return the full overlap and hamiltonian matrices (orb1,orb2,T1,T2,T3) but scaled with the phase of a specific k-point.

Parameters:

• self (object) – An object with the attributes of the COGITO_TB_Model class.

• kpt (list) – The kpoint to regenerate at in reduced coordinates.

• spin (int) – The spin of the parameters for a spin-polarized calculation. Default is 0–for non spin-polarized.

@return:

static get_neighbors(self) → list

This sorts the matrix of TB parameters into terms which are 1NN, 2NN, etc. Relevant for labeling equivalent bonds and creates NN numbers which is used in COOP and COHP plots.

static plot_crystal_field(self, atomnum: int = 0, orbitals: str = '', ylim: list = (-10, 0), spin: int = 0) → None

Plots the crystal field splitting diagram for the orbitals and atom given. Add stuff to plot the orbital type and orbital radius on the energy line (in pretty small font) Also have default to plot all the orbital on the atom.

Parameters:

• atomnum (int) – Which atom to plot for.

• orbitals (str) – Which orbitals to plot. If not set shows all the orbitals.

• ylim (list) – The limits of the y-axis in the plot, will default to good value if left (-10,0).

static plot_hopping(self, spin: int = 0) → None

Plots the log(hopping) versus distance between parameters. Used to check quality of tight binding model. Parameters should show a rough linear decay on plot. Although, it is common for them to flatten out after ~10Ang.

static plot_overlaps(self, spin: int = 0) → None

Plots the log(overlaps) versus distance between parameters. Used to check quality of tight binding model. Parameters should show a rough linear decay on plot. Although, it is common for them to flatten out after ~10Ang.

static compare_to_DFT(self, directory: str, extra_tag='') → list

This function reads the EIGENVAL from a DFT run, generates the energies from the TB model for the kpt grid. Then it plots and compares the error between the TB model energies and DFT energies.

Parameters:

• self (unknown) – An object of the class COGITO_TB_Model (can not be the BAND or UNIFORM classes!).

• directory (str) – The directory where the EIGENVAL file is.

Returns:

Saves a png of the DFT and COGITO bands at (self.directory+’compareDFT’ + self.file_suff + extra_tag + ‘.png’). txt: Saves a error values at self.directory + “DFT_band_error” + self.file_suff + extra_tag + “.txt” list: Returns a list of the (averaged over the valance bands) band distance (as defined by Marzari), average maximum error, and average band error.

Return type:

png

static get_COHP(self: object, orbs: dict, NN: int = None, include_onsite: bool = False, spin: int = 0) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

Calculates the COHP for the given orbitals and nearest neighbors.

Parameters:

• self (object) – An object of the class COGITO_BAND or COGITO_UNIFORM.

• orbs (dict) – Either a list of two dictionaries giving elements as keys and orbital types as items (eg [{“Pb”:[“s”,”d”],”O”:[“s”,”p”]},{“Pb”:[“s”]”O”:[“p”]}]) or give list of orb numbers [[1,2,3,5,6,7],[1,2,3,4,5,6,7,8]].

• NN (int) – An integer for which nearest neighbor number to include (eg 1 for 1NN) or None or “All” for all nearest neighbors.

• include_onsite (bool) – Includes atomic orbital energy terms (H_ab(R) where R=0 and a=b) instead of just bonding terms.

• spin (int) – The spin of the tight binding parameters; default is 0 works for nonspin-polarized.

Returns:

Returns COHP values in a [kpt,band] dimension.

Return type:

npt.NDArray

static get_ICOHP(self, spin: int = 0) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

Generates an ICOHP matrix with same dimension as TB parameters (orb1,orb2,T1,T2,T3). Used for fast calculation of energies in crystal bond plot or other integrated energy quantities.

static get_COOP(self: object, orbs: dict, NN: int = None, include_onsite: bool = False, spin: int = 0) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

Calculates the COOP for the given orbitals and nearest neighbors.

Parameters:

• self (object) – An object of the class COGITO_BAND or COGITO_UNIFORM.

• orbs (dict) – Either a list of two dictionaries giving elements as keys and orbital types as items (eg [{“Pb”:[“s”,”d”],”O”:[“s”,”p”]},{“Pb”:[“s”]”O”:[“p”]}]) or give list of orb numbers [[1,2,3,5,6,7],[1,2,3,4,5,6,7,8]].

• NN (int) – An integer for which nearest neighbor number to include (eg 1 for 1NN) or None or “All” for all nearest neighbors.

• include_onsite (bool) – Includes atomic overlap terms (S_ab(R) where R=0 and a=b) instead of just bonding terms, this can be used with NN=0 to give a projected bandstructure.

• spin (int) – The spin of the tight binding parameters; default is 0 works for nonspin-polarized.

Returns:

Returns COOP values in a [kpt,band] dimension.

Return type:

npt.NDArray

static get_ICOOP(self, spin: int = 0) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

Generates an ICOOP matrix with same dimension as TB parameters (orb1,orb2,T1,T2,T3). Used for fast calculation of bond charges in crystal bond plot or other integrated charge quantities.

static get_bond_occup(self, spin: int = 0) → ndarray[tuple[Any, ...], dtype[_ScalarT]]

Generates an bond occupancy matrix with same dimension as TB parameters (orb1,orb2,T1,T2,T3). Used for fast calculation of bond charges in crystal bond plot or other integrated charge quantities.

class COGITO_dft.COGITOpost.COGITO_BAND(TB_model: object, num_kpts: int = 100)

Bases: object

get_bandstructure(num_kpts: int = 100) → None

The function automatically generates a kpath using pymatgen and kpathseek. Then calculates the band energies and vectors for the kpath.

Parameters:

num_kpts (int) – The number of kpoints between EACH kpath.

Returns:

Nothing

Return type:

None

plotBS(ax: object = None, ylim: list = (-10, 10), color_label: str = '', colors: ndarray[tuple[Any, ...], dtype[_ScalarT]] = array([], dtype=float64), colorhalf: float = 10) → object

Parameters:

• ax (object) – (matplotlib.pyplot axis): Axis to save the bandstructure to, otherwise generate new axis.

• ylim (list) – Limits on the y-axis of plot.

• color_label (str) – When being plotted from another function, this passes “COHP” or “COOP”.

• colors (npt.NDArray) – Magnitude for each point to use in color plotting, passed by get_COHP() function.

• colorhalf (float) – Sets scale of color bar.

Returns:

matplotlib.pyplot axis with bandstructure plotted.

Return type:

object

plotlyBS(ylim=(-10, 10), color_label='', colors=None, colorhalf=None, orbProj: bool = False) → object

Plots bandstructure (or projected bandstructure) using plotly graph_objects.

Parameters:

• ylim (unknown) – Limits on the y-axis of plot.

• color_label (unknown) – When being plotted from another function, this passes “COHP” or “COOP”.

• colors (unknown) – Magnitude for each point to use in color plotting, passed by get_COHP() function.

• colorhalf (unknown) – Sets scale of color bar.

Returns:

plotly figure with bandstructure plotted.

Return type:

object

get_COHP(orbs: dict, NN: int = None, ylim: list = (-10, 10), colorhalf: float = 10, include_onsite: bool = False, from_dash: bool = False) → None

Calculates and plots the projected COHP values for each band and k-point on band structure.

Parameters:

• orbs (dict) – Either a list of two dictionaries giving elements as keys and orbital types as items (eg [{“Pb”:[“s”,”d”],”O”:[“s”,”p”]},{“Pb”:[“s”]”O”:[“p”]}]) or give list of orb numbers [[1,2,3,5,6,7],[1,2,3,4,5,6,7,8]].

• NN (int) – An integer for which nearest neighbor number to include (eg 1 for 1NN) or None or “All” for all nearest neighbors.

• ylim (list) – The limits of the y-axis (energy) of the band structure plot.

• colorhalf (float) – Set the magnitude for the color bar; For default value of 10, it is set automatically to average(COHP)*3.

• include_onsite (bool) – Includes atomic orbital energy terms (H_ab(R) where R=0 and a=b) instead of just bonding terms.

• from_dash (bool) – Flag to set when calling from the dash app, sets plotting backend to plotly and returns the axis.

Returns:

Nothing

Return type:

None

get_COOP(orbs: dict, NN: int = None, ylim: list = (-10, 10), colorhalf: float = 10, include_onsite: bool = False, from_dash=False, color_label: str = 'COOP', orbProj: bool = False) → None

Calculates and plots the projected COOP values for each band and k-point on band structure.

Parameters:

• orbs (dict) – either a list of two dictionaries giving elements as keys and orbital types as items (eg [{“Pb”:[“s”,”d”],”O”:[“s”,”p”]},{“Pb”:[“s”]”O”:[“p”]}]) or give list of orb numbers [[1,2,3,5,6,7],[1,2,3,4,5,6,7,8]].

• NN (int) – An integer for which nearest neighbor number to include (eg 1 for 1NN) or None or “All” for all nearest neighbors.

• ylim (list) – The limits of the y-axis (energy) of the band structure plot.

• colorhalf (float) – Set the magnitude for the color bar; For default value of 10, it is set automatically to average(COOP)*3.

• include_onsite (bool) – Includes atomic overlap terms (S_ab(R) where R=0 and a=b) instead of just bonding terms, this can be used with NN=0 to give a projected bandstructure.

• from_dash (unknown) – Flag to set when calling from the dash app, sets plotting backend to plotly and returns the axis.

Returns:

Nothing

Return type:

None

get_projectedBS(orbdict: dict, ylim: list = (-10, 10), colorhalf: float = 10) → None

Returns the COGITO-orbital projected band structure. By construction, this performs the projection by Mulliken-style analysis. Projection without Mulliken is obfuscated by the nonorthogonal nature of the orbitals, which causes much larger projection at high energy states due to antibonding.

Parameters:

• orbdict (dict) – Single dictionary of orbitals to include in projection. For example, {“Pb”:[“s”,”d”],”O”:[“s”,”p”]}.

• ylim (tuple) – The y-axis limits.

• colorhalf (float) – The upper and lower value for the projection. The code will find a reasonable value. For this, colorhalf=1 would be good. (Default is only 10 for signaling auto-update in later code.)

Returns:

Saves the projection plot at self.directory+”projectedBS”+elem+”.html”.

Return type:

html

make_COHP_dashapp(pathname: str = '/COGITO_COHP/') → None

This function generate a dash app which allows the user to interactively select orbitals and nearest neighbors to examine their project COHP band structure quickly.

Parameters:

pathname (str) – Name appended to the default pathname for the html.

Returns:

Nothing

Return type:

None

class COGITO_dft.COGITOpost.COGITO_UNIFORM(TB_model: object, grid: tuple)

Bases: object

get_uniform(grid: tuple) → None

Sets up the uniform grid, calculating all eigenenergies and eigenvectors, and adjust fermi energy to ensure charge conservation.

Parameters:

grid (tuple) – The kpoint grid to use for the uniform sampling.

get_occupation(spin: int = 0)

This function prints information about electron occupation/partitioning. It prints a version using Mulliken to assign charge to orbitals and one that just uses the onsite orbital terms. The onsite one will not be charge balanced as some charge is in bonds. It also prints the atomic partial charge by Mulliken population.

get_COHP(orbs: dict, NN: int = None, ylim: list = (-10, 10), sigma=0.1, include_onsite: bool = False)

Calculates and plots the projected COHP values on the density of states.

Parameters:

• orbs (dict) – Either a list of two dictionaries giving elements as keys and orbital types as items (eg [{“Pb”:[“s”,”d”],”O”:[“s”,”p”]},{“Pb”:[“s”]”O”:[“p”]}]) or give list of orb numbers [[1,2,3,5,6,7],[1,2,3,4,5,6,7,8]].

• NN (int) – An integer for which nearest neighbor number to include (eg 1 for 1NN) or None or “All” for all nearest neighbors.

• ylim (list) – The limits of the y-axis (energy) of the DOS plot.

• sigma (float) – Sets the spread (in energy) of the gaussian for the each wavefunction COHP. The full pCOHP is created by summing the gaussians. This should trade off with k-point resolution. Low resolution requires high sigma (0.2) to smear between points. High resoltion can have low sigma (0.02).

• include_onsite (bool) – Includes atomic orbital energy terms (H_ab(R) where R=0 and a=b) instead of just bonding terms.

Returns:

Saves projected COHP DOS to self.directory+’COHP_DOS.png’.

Return type:

png

get_ICOHP()

Generates an ICOHP matrix with from the TB_Model static function. Then reduces the matrix size. Used for fast calculation of energies in crystal bond plot or other integrated energy quantities.

save_ICOHP()

Saves the smaller ICOHP matrix to (self.directory+”ICOHP”+str(key)+”.npy”) for reading in later with COGITOico.

get_COOP(orbs: dict, NN: int = None, ylim: list = (-10, 10), sigma=0.1, include_onsite: bool = False, orbProj: bool = False, label: str = '')

Calculates and plots the projected COOP values on the density of states.

Parameters:

• orbs (dict) – Either a list of two dictionaries giving elements as keys and orbital types as items (eg [{“Pb”:[“s”,”d”],”O”:[“s”,”p”]},{“Pb”:[“s”]”O”:[“p”]}]) or give list of orb numbers [[1,2,3,5,6,7],[1,2,3,4,5,6,7,8]].

• NN (int) – An integer for which nearest neighbor number to include (eg 1 for 1NN) or None or “All” for all nearest neighbors.

• ylim (list) – The limits of the y-axis (energy) of the DOS plot.

• sigma (float) – Sets the spread (in energy) of the gaussian for the each wavefunction COOP. The full pCOOP is created by summing the gaussians. This should trade off with k-point resolution. Low resolution requires high sigma (0.2) to smear between points. High resoltion can have low sigma (0.02).

• include_onsite (bool) – Includes atomic orbital energy terms (H_ab(R) where R=0 and a=b) instead of just bonding terms.

Returns:

Saves projected COOP DOS to self.directory+’COOP_DOS.png’.

Return type:

png

get_projectedDOS(elem: str, ylim: list = (-10, 10), sigma: float = 0.1) → None

Returns the COGITO-orbital projected density of states for a specific element. By construction, this performs the projection by Mulliken-style analysis. Projection without Mulliken is obfuscated by the nonorthogonal nature of the orbitals, which causes much larger projection at high energy states due to antibonding.

Parameters:

• elem (str) – String of the element label. For example, “Pb”.

• ylim (tuple) – The y-axis limits.

• sigma (float) – Sets the spread (in energy) of the gaussian for the each wavefunction COOP. The full pCOOP is created by summing the gaussians. This should trade off with k-point resolution. Low resolution requires high sigma (0.2) to smear between points. High resoltion can have low sigma (0.02).

Returns:

Saves the projection plot at self.directory+elem+’projectedDOS.png’.

Return type:

png

get_ICOOP()

Generates an ICOOP matrix with from the TB_Model static function. Then reduces the matrix size. Used for fast calculation of energies in crystal bond plot or other integrated energy quantities.

get_bond_occup()

Generates an bond occupation matrix with from the TB_Model static function. Then reduces the matrix size. Used for fast calculation of energies in crystal bond plot or other integrated energy quantities.

get_all_integrated()

This function efficiently gets the ICOHP, ICOHP, and bond occupation (density matrix) @return:

save_bond_occup()

Saves the smaller bond occupation (density) matrix to (self.directory+”bond_occup”+str(key)+”.npy”) for reading in later with COGITOico.

save_ICOOP()

Saves the smaller ICOOP matrix to (self.directory+”ICOOP”+str(key)+”.npy”) for reading in later with COGITOico.

make_bond(atmind1, atmind2, center1, center2, orbCOOP, cartXYZ)

This is a function which will generate populate the cartXYZ grid with values for the bond density between the atoms given using the orbCOOP provided.

Parameters:

• atmind1 (unknown) – The atom number for the first atom.

• atmind2 (unknown) – The atom number for the second atom.

• center1 (unknown) – The center of the first atom (not using self.primATOMs).

• center2 (unknown) – The center of the second atom (not using self.primATOMs).

• orbCOOP (unknown) – The orbCOOP which reveals how much of each orbital combo that is included in the bond. Dimension nxm where n is the # of orbitals for atom 1 and m is # of orbitals for atom 2.

• cartXYZ (unknown) – The 3D flattened grid that the bond density is calculated on.

Returns:

A 1D array (3D flattened) of the bond density.

Return type:

unknown

get_bonds_figure(energy_cutoff: float = 0.1, bond_max: float = 3.0, elem_colors: list = [], atom_colors: list = [], atom_labels: list = [], plot_atom: int = None, one_atom: bool = False, fovy: float = 10, return_fig: bool = False) → None

This is deprecated. This will plot the crystal structure atoms with line weighted by iCOHP. Each line should also be hoverable to reveal the number and amounts that are s-s,s-p, and p-p.

Parameters:

• energy_cutoff (float) – This is the minimum bond magnitude that will be plotted.

• bond_max (float) – The maximum bond distance that will be plotted outside the primitive cell.

• elem_colors (list) – Colors for the elements based on order in tb_input. Length of list should be the number of unique elements. Can either be integer list to reference the default colors or list of plotly compatable colors.

• atom_colors (list) – Colors for the atoms based on order in tb_input. Length of list should be the number of atoms in the primitive cell. Can either be integer list to reference the default colors or list of plotly compatable colors. If not set defaults to elem_colors.

• atom_labels (list) – List of atom labels as a string.

• plot_atom (int) – Set with one_atom=True, plots only one atom and it’s bonds, this passes the atom number to plot.

• one_atom (bool) – Whether only the atom defined in plot_atom should be plotted; default is False.

• fovy (float) – field of view in the vertical direction. Use this tag to adjust depth perception in crystal. Set between 3 (for close to orthographic) and 30 (for good perspective depth).

• return_fig (bool) – If False, this function saves figure to crystal_bonds.html. If True, this function will return the plotly figure object.

Returns:

Saves the crystal bond plot to (self.directory + “crystal_bonds.html”). Also plots figure if self.show_figs = True.

Return type:

html

get_bonds_charge_figure(energy_cutoff: float = 0.1, bond_max: float = 3.0, elem_colors: list = [], atom_colors: list = [], atom_labels: list = [], auto_label: str = '', plot_atom: int = None, one_atom: bool = False, fovy: float = 10, return_fig: bool = False) → None

Plots the crystal structure atoms with bonds plotted based on iCOHP. Each line should also be hoverable to reveal the number and amounts that are s-s,s-p, and p-p. The charge and magnetic moment will also be plotted acording to auto_label.

Parameters:

• energy_cutoff (float) – This is the minimum bond magnitude that will be plotted.

• bond_max (float) – Atoms are plotted outside the primitive cell only if they have a bond with a primitive cell atom that is shorter than this amount. This does not filter bonds between atoms that are already plotted.

• elem_colors (list) – Colors for the elements based on order in tb_input. Length of list should be the number of unique elements. Can either be integer list to reference the default colors or list of plotly compatable colors.

• atom_colors (list) – Colors for the atoms based on order in tb_input. Length of list should be the number of atoms in the primitive cell. Can either be integer list to reference the default colors or list of plotly compatable colors. If not set defaults to elem_colors.

• atom_labels (list) – List of atom labels as a string.

• auto_label (str) – Different options for plotting includes: (can include multiple in the string) “mulliken” -Plots the onsite charge and mag (if spin_polar) on atoms by mulliken population (overrides atom_labels). “full” - Plots the charge and magnetics moments (if spin_polar) on atoms and bonds (overrides atom_labels). “color” - Colors the atoms and bonds based on their charge (overrides atom_colors or elem_colors). “color mag” - Colors the atoms and bonds based on their magnetic moments (overrides atom_colors or elem_colors). NOTE: Only use “mulliken” OR “full”, NOT both

• plot_atom (int) – Set with one_atom=True, plots only one atom and it’s bonds, this passes the atom number to plot.

• one_atom (bool) – Whether only the atom defined in plot_atom should be plotted; default is False.

• fovy (float) – field of view in the vertical direction. Use this tag to adjust depth perception in crystal. Set between 3 (for close to orthographic) and 30 (for good perspective depth).

• return_fig (bool) – If False, this function saves figure to crystal_bonds.html. If True, this function will return the plotly figure object.

Returns:

Depends on return_fig parameter.

Return type:

None

get_bond_density_figure(energy_cutoff: float = 0.1, iso_max: float = 0.03, iso_min: float = -0.003, elem_colors: list = [], atom_colors: list = [], atom_labels: list = [], auto_label: str = '', plot_atom: int = None, one_atom: bool = False, bond_max: float = 3.0, fovy: float = 10, return_fig: bool = False) → None

Plots the crystal structure atoms with bonds plotted based on iCOHP. Each line should also be hoverable to reveal the number and amounts that are s-s,s-p, and p-p. The charge and magnetic moment will also be plotted acording to auto_label.

Parameters:

• energy_cutoff (float) – This is the minimum bond magnitude that will be plotted.

• iso_max (float) – The positive isosurface for plotting the bonds.

• iso_min (float) – The negative isosurface for plotting the bonds.

• elem_colors (list) – Colors for the elements based on order in tb_input. Length of list should be the number of unique elements. Can either be integer list to reference the default colors or list of plotly compatable colors.

• atom_colors (list) – Colors for the atoms based on order in tb_input. Length of list should be the number of atoms in the primitive cell. Can either be integer list to reference the default colors or list of plotly compatable colors. If not set defaults to elem_colors.

• atom_labels (list) – List of atom labels as a string.

• auto_label (str) – Different options for plotting includes: (can include multiple in the string) “mulliken” - Plots the onsite charge and mag (if spin_polar) on atoms by mulliken population (overrides atom_labels). “full” - Plots the charge and magnetics moments (if spin_polar) on atoms and bonds (overrides atom_labels). “color” - Colors the atoms and bonds based on their charge (overrides atom_colors or elem_colors). “color mag” - Colors the atoms and bonds based on their magnetic moments (overrides atom_colors or elem_colors). NOTE: Only use “mulliken” OR “full”, NOT both.

• plot_atom (int) – Set with one_atom=True, plots only one atom and it’s bonds, this passes the atom number to plot.

• one_atom (bool) – Whether only the atom defined in plot_atom should be plotted; default is False.

• bond_max (float) – Atoms are plotted outside the primitive cell only if they have a bond with a primitive cell atom that is shorter than this amount. This does not filter bonds between atoms that are already plotted.

• fovy (float) – field of view in the vertical direction. Use this tag to adjust depth perception in crystal. Set between 3 (for close to orthographic) and 30 (for good perspective depth).

• return_fig (bool) – If False, this function saves figure to crystal_bonds.html. If True, this function will return the plotly figure object.

Returns:

Depends on return_fig parameter. Default is to return nothing but save “crystal_bonds.html”.

Return type:

html, or object

jsonify_bonddata(minimum_cohp: float = 1e-05, make_bond_info_txt=True)

This function covers the raw ICOHP and ICOOP and bond_occup matrices into something more interpretable while still preserving norms. This constructs three json files: all_bonds.json : includes bonds between all atoms that have a elements above the minimum_cohp. all_unique_bonds : groups the all_bonds into unique ones for more interpretable viewing. all_atoms.json : all onsite atom information, including the bond orb_orb_dict + added onsite and mulliken orbital occupations and partial charges + lone-pair-like energy (cohp) contributions. The structure of the all_bonds json: {“uniq_bonds by “el1_el2_dist_energy”: { “bondlength”: float, “degeneracy”: int, “cohp”: float , “coop”: float, “bondmagmom”: float, “all atom-atom bonds in this set by ‘atm1_atm2_T1_T2_T3’:{ # just ‘atm1_atm2’ is not enough since atoms can bond outside unit cell “atmorbs1, atmorbs2”: [[int…],[int…]] # used to reference orbital energy, radius, and shape “cohp”: [float…] , “coop”: [float…], “bondlength”: float, “bondmagmom”: float, “angle”?:float, # same data just without averaging “orb-orb e.g. ‘s-d’”: { “cohp”: [float…], “coop”: [float…], # is referenced to spin state. For non spin-polarized: [float], for spin-polar: [float,float] “orbnums1, orbnums2”: [[int…],[int…]] for orbital numbers e.g. for s-p: [[0],[1,2,3]], # orbital number referenced to atom already selected “bond_occup_matrix”: [numorbs1×numorbs2…], “orb_ediff_matrix”: [numorbs1×numorbs2…], “cohp_matrix”: [numorbs1×numorbs2…], “coop_matrix”: [numorbs1×numorbs2…], “S_matrix”: [numorbs1×numorbs2…], “H_matrix”: [numorbs1×numorbs2…], } } } @return:

get_bond_info()

Creates the bond_info.txt file which lists all the relavent bonds by there involved atoms, length, energy, charge, and multiplicity.

get_COHP_DOS_bybond(sigma=0.1, return_fig: bool = False)

Creates an interactive plot pCOHP DOS plot for all relevant bonds and their orbital decomposition.

Returns:

Plotly figure object.

Return type:

object

get_crystal_plus_COHP(energy_cutoff: float = 0.05, bond_max: float = 3, auto_label: str = 'mulliken', fovy: float = 10) → None

The will plot the crystal bond plot on the left with interactivity to a COHP DOS plot on the right.

Parameters:

• energy_cutoff (float) – This is the minimum bond magnitude that will be plotted.

• bond_max (float) – Atoms are plotted outside the primitive cell only if they have a bond with a primitive cell atom that is shorter than this amount. This does not filter bonds between atoms that are already plotted.

• auto_label (str) – Different options for plotting includes: (can include multiple in the string) “mulliken” - Plots the onsite charge and mag (if spin_polar) on atoms by mulliken population (overrides atom_labels). “full” - Plots the charge and magnetics moments (if spin_polar) on atoms and bonds (overrides atom_labels). “color” - Colors the atoms and bonds based on their charge (overrides atom_colors or elem_colors). “color mag” - Colors the atoms and bonds based on their magnetic moments (overrides atom_colors or elem_colors). NOTE: Only use “mulliken” OR “full”, NOT both.

• fovy (float) – field of view in the vertical direction. Use this tag to adjust depth perception in crystal.

Returns:

Nothing, but saved to ‘bond_cohp_plot.html’.

Return type:

None

static get_mulliken_charge(self: object, elem: str, only_onsite=False) → float

Returns the atomic partial charge by Mulliken partitioning. If the calculation is spin polarized, also returns the atomic magnetization by Mulliken. If the element label (str) is used, the code returns the average charge/magnetization for the element type.

Parameters:

• elem (str or int) – Either the element label (e.g. “Pb”) or the index of the atom in the list of atoms (as seen in tb_input.txt). When is the element label, the function will return a value for each atom of that type.

• only_onsite (bool) – Default False. If True, don’t actually do the Mulliken repartitioning from bonds, only include onsite charges. Note if True: Summing only atoms with onsite charge will not be charge neutral, need to include bond charge for neutrality.

Returns:

Atomic partial charge or if spin polarized, (partial charge, atomic magnetic moment).

If elem is element label (e.g. “Pb”), returns a list for charge and magmom.

Return type:

(float or tuple)

class COGITO_dft.COGITOpost.COGITO_BS_widget(TB_model: object, num_kpts: int = 100)

Bases: object

get_bandstructure(num_kpts: int = 100) → None

The function automatically generates a kpath using pymatgen and kpathseek. Then calculates the band energies and vectors for the kpath.

Parameters:

num_kpts (int) – The number of kpoints between EACH kpath.

Returns:

Nothing

Return type:

None

plotlyBS(ylim=(-10, 10), selectedDot=None, plotnew=False) → object

Plots bandstructure (or projected bandstructure) using plotly graph_objects.

Parameters:

ylim (unknown) – Limits on the y-axis of plot.

Returns:

Plotly figure with bandstructure plotted.

Return type:

object

plotBS(ax=None, selectedDot=None, plotnew=False, ylim=None)

Parameters:

• ax (unknown) – (matplotlib.pyplot axis): Axis to save the bandstructure to, otherwise generate new axis.

• selectedDot (unknown) – (1D integer array): Gives kpoint and band index of the dot selected to make green circle. eg: [3,4]

Returns:

matplotlib.pyplot axis with bandstructure plotted.

Return type:

unknown

get_significant_bonds(band, kpoint, spin)

plot_bond_run(num_bond=0)

change_sig_bonds(old_vals, new_vals, tbvals=None, num_bond=None)

To change tight-binding parameter, need to know two orbitals and three translations.

make_BS_widget(app=None)

get_coulomb()

This function is for me trying out building the coulomb operator 4D kernel from the COGITO gaussian functions. In this I will test first using outside method to calculate overlap / coulomb operator. (Compare directly calculated overlap to overlap params!) Then I will verify whether the sum of terms converges or diverges (should diverge). Then I will try out how to repartition the coulomb operator to a convergent sum. My main method for this is to take the next closest density in a equal amount of charge and have it cancel. This should converge with the decrease in distance between consequetive layers. Test on PbO. @return:

COGITO_dft.COGITOpost.func_for_rad(x, a, b, c, d, e, f, g, h, l)

COGITO_dft.COGITOpost.complex128funs(phi, theta, sphharm_key)

COGITO_dft.COGITOpost.run_cogito_model(dir: str = './', tag: str = '', eigfile: str = 'EIGENVAL', tb_file: str = 'TBparams', over_file: str = 'overlaps', file_type: str = 'npy', save_quality_info: bool = True, show_figs: bool = True, save_crystal_bonds: bool = True, save_bondswCOHP: bool = True, save_ico: bool = True, max_dist: float = 15, min_val: float = 1e-05, auto_label: str = 'full', densify: float = 1, energy_cutoff: float = 0.2, bond_max: float = 3, crystal_field=[])

This function solves the COGITO TB model for specific k-points. Options for grids are uniform, band structure, or provided (via EIGENVAL). Primarily, this function saves all atom and bond data (from a uniform grid) to jsons for later analysis. By toggling the various ‘save_*’ options (all default true), this function can also plot parameter decay and band error, make the crystal bond diagrams (w or w/o the interactive COHP plots), and save ICOHP and ICOOP for more computationally effecient analysis. This can also plot the crystal field splitting of orbital energy levels on an atoms specified by a supplied ‘crystal_field’ list.

Parameters:

• dir (str) – The directory that contains the COGITO output files.

• tag (str) – The tag appended to COGITO output files.

• eigfile (str) – The EIGVAL file to use for compare_to_DFT(). Note: is appended to dir.

• tb_file (str) – The file name for the tight binding parmaeters.

• over_file (str) – The file name for the overlap parameters.

• file_type (str) – The suffix of the parameters. Options are ‘npy’ or ‘txt’. If ‘txt’, is same format as wannier90.

• save_quality_info (bool) – Whether to make hopping/overlap decay plots and DFT band error analysis.

• show_figs (bool) – If called, does not call any plt.show() or fig.show().

• save_crystal_bonds (bool) – Whether to make and save the crystal bonds plot.

• save_bondswCOHP (bool) – Whether to make and save the crystal bonds plot interacting with the COHP vs energy.

• save_ico (bool) – Whether to save integrated COHP and COOP data for speedy use in COGITOico.py.

• max_dist (float) – Maximum interatomic distance for including hopping or overlap parameters.

• min_val (float) – The minimum value cutoff to include parameters.

• auto_label (str) – Determines how to partition charge for crystal bond plots. ‘mulliken’ does Mulliken paritioning to atomic site, ‘full’ doesn’t repartition but plots charges on atoms and bonds.

• densify (float) – Increase k-point density by this factor.

• energy_cutoff (float) – The minimum energy cutoff to plot a bond in crystal bond plots.

• bond_max (float) – Atoms are plotted outside the primitive cell only if they have a bond with a primitive cell atom that is shorter than this amount. This does not filter bonds between atoms that are already plotted.

• crystal_field (list) – List of all the atoms that the crystal field diagram is plotted for (e.g. ‘0 1 3’).

Returns:

COGITO_dft.COGITOpost.main(argv=None)