Source code for pymatgen.electronic_structure.cohp

# coding: utf-8
# Copyright (c) Pymatgen Development Team.
# Distributed under the terms of the MIT License.

"""
This module defines classes to represent crystal orbital Hamilton
populations (COHP) and integrated COHP (ICOHP), but can also be used
for crystal orbital overlap populations (COOP).
"""

import warnings
import re
import sys

import numpy as np

from monty.json import MSONable

from pymatgen.electronic_structure.core import Spin, Orbital
from pymatgen.core.sites import PeriodicSite
from pymatgen.core.structure import Structure
from pymatgen.io.lmto import LMTOCopl
from pymatgen.io.lobster import Cohpcar
from pymatgen.util.num import round_to_sigfigs
from pymatgen.util.coord import get_linear_interpolated_value

__author__ = "Marco Esters, Janine George"
__copyright__ = "Copyright 2017, The Materials Project"
__version__ = "0.2"
__maintainer__ = "Marco Esters, Janine George"
__email__ = "esters@uoregon.edu, janine.george@uclouvain.be"
__date__ = "Dec 13, 2017"


[docs]class Cohp(MSONable): """ Basic COHP object. """ def __init__(self, efermi, energies, cohp, are_coops=False, icohp=None): """ Args: are_coops: Indicates whether this object describes COHPs or COOPs. efermi: Fermi energy. energies: A sequence of energies. cohp ({Spin: np.array}): representing the COHP for each spin. icohp ({Spin: np.array}): representing the ICOHP for each spin. """ self.are_coops = are_coops self.efermi = efermi self.energies = np.array(energies) self.cohp = cohp self.icohp = icohp def __add__(self, other): """ Adds two COHP together. Checks that energy scales are the same. Otherwise, it raises a ValueError. It also adds ICOHP if present. If ICOHP is only present in one object, it displays a warning and will not add ICOHP. Args: other: Another COHP object. Returns: Sum of the two COHPs as a COHP object. """ if not all(np.equal(self.energies, other.energies)): raise ValueError("Energies of both COHP are not compatible.") populations = {spin: self.populations[spin] + other.populations[spin] for spin in self.cohp} if self.icohp is not None and other.icohp is not None: int_pop = {spin: self.icohp[spin] + other.icohp[spin] for spin in self.icohp} else: if self.icohp is not None or other.icohp is not None: warnings.warn("One of the COHP objects does not contain " "ICOHPs. Setting ICOHP to None.") int_pop = None return Cohp(self.efermi, self.energies, populations, icohp=int_pop) def __repr__(self): return self.__str__() def __str__(self): """ Returns a string that can be easily plotted (e.g. using gnuplot). """ cohpstring = "COOP" if self.are_coops else "COHP" header = ["Energy", cohpstring + "Up"] data = [self.energies, self.cohp[Spin.up]] if Spin.down in self.cohp: header.append(cohpstring + "Down") data.append(self.cohp[Spin.down]) if self.icohp: header.append("I" + cohpstring + "Up") data.append(self.icohp[Spin.up]) if Spin.down in self.cohp: header.append("I" + cohpstring + "Down") data.append(self.icohp[Spin.down]) formatheader = "#" + " ".join(["{:15s}" for __ in header]) formatdata = " ".join(["{:.5f}" for __ in header]) stringarray = [formatheader.format(*header)] for i, __ in enumerate(self.energies): stringarray.append(formatdata.format(*[d[i] for d in data])) return "\n".join(stringarray)
[docs] def as_dict(self): """ Json-serializable dict representation of COHP. """ d = {"@module": self.__class__.__module__, "@class": self.__class__.__name__, "are_coops": self.are_coops, "efermi": self.efermi, "energies": self.energies.tolist(), "COHP": {str(spin): pops.tolist() for spin, pops in self.cohp.items()}} if self.icohp: d["ICOHP"] = {str(spin): pops.tolist() for spin, pops in self.icohp.items()} return d
[docs] def get_cohp(self, spin=None, integrated=False): """ Returns the COHP or ICOHP for a particular spin. Args: spin: Spin. Can be parsed as spin object, integer (-1/1) or str ("up"/"down") integrated: Return COHP (False) or ICOHP (True) Returns: Returns the CHOP or ICOHP for the input spin. If Spin is None and both spins are present, both spins will be returned as a dictionary. """ if not integrated: populations = self.cohp else: populations = self.icohp if populations is None: return None if spin is None: return populations if isinstance(spin, int): spin = Spin(spin) elif isinstance(spin, str): s = {"up": 1, "down": -1}[spin.lower()] spin = Spin(s) return {spin: populations[spin]}
[docs] def get_icohp(self, spin=None): """ Convenient alternative to get the ICOHP for a particular spin. """ return self.get_cohp(spin=spin, integrated=True)
[docs] def get_interpolated_value(self, energy, integrated=False): """ Returns the COHP for a particular energy. Args: energy: Energy to return the COHP value for. """ inter = {} for spin in self.cohp: if not integrated: inter[spin] = get_linear_interpolated_value(self.energies, self.cohp[spin], energy) elif self.icohp is not None: inter[spin] = get_linear_interpolated_value(self.energies, self.icohp[spin], energy) else: raise ValueError("ICOHP is empty.") return inter
[docs] def has_antibnd_states_below_efermi(self, spin=None, limit=0.01): """ Returns dict indicating if there are antibonding states below the Fermi level depending on the spin spin: Spin limit: -COHP smaller -limit will be considered. """ warnings.warn("This method has not been tested on many examples. Check the parameter limit, pls!") populations = self.cohp number_energies_below_efermi = len([x for x in self.energies if x <= self.efermi]) if populations is None: return None if spin is None: dict_to_return = {} for sp, cohpvalues in populations.items(): if (max(cohpvalues[0:number_energies_below_efermi])) > limit: dict_to_return[sp] = True else: dict_to_return[sp] = False else: dict_to_return = {} if isinstance(spin, int): spin = Spin(spin) elif isinstance(spin, str): s = {"up": 1, "down": -1}[spin.lower()] spin = Spin(s) if (max(populations[spin][0:number_energies_below_efermi])) > limit: dict_to_return[spin] = True else: dict_to_return[spin] = False return dict_to_return
[docs] @classmethod def from_dict(cls, d): """ Returns a COHP object from a dict representation of the COHP. """ if "ICOHP" in d: icohp = {Spin(int(key)): np.array(val) for key, val in d["ICOHP"].items()} else: icohp = None return Cohp(d["efermi"], d["energies"], {Spin(int(key)): np.array(val) for key, val in d["COHP"].items()}, icohp=icohp, are_coops=d["are_coops"])
[docs]class CompleteCohp(Cohp): """ A wrapper class that defines an average COHP, and individual COHPs. .. attribute: are_coops Indicates whether the object is of COOPs or COHPs. .. attribute: efermi Fermi energy .. attribute: energies Sequence of energies .. attribute: structure Structure associated with the COHPs. .. attribute: cohp, icohp The average COHP/ICOHP. .. attribute: all_cohps A dict of COHPs for individual bonds of the form {label: COHP} .. attribute: orb_res_cohp Orbital-resolved COHPs. """ def __init__(self, structure, avg_cohp, cohp_dict, bonds=None, are_coops=False, orb_res_cohp=None): """ Args: structure: Structure assosciated with this COHP. avg_cohp: The average cohp as a COHP object. cohps: A dict of COHP objects for individual bonds of the form {label: COHP} bonds: A dict containing information on the bonds of the form {label: {key: val}}. The key-val pair can be any information the user wants to put in, but typically contains the sites, the bond length, and the number of bonds. If nothing is supplied, it will default to an empty dict. are_coops: indicates whether the Cohp objects are COHPs or COOPs. Defauls to False for COHPs. orb_res_cohp: Orbital-resolved COHPs. """ super().__init__(avg_cohp.efermi, avg_cohp.energies, avg_cohp.cohp, are_coops=are_coops, icohp=avg_cohp.icohp) self.structure = structure self.are_coops = are_coops self.all_cohps = cohp_dict self.orb_res_cohp = orb_res_cohp if bonds is None: self.bonds = {label: {} for label in self.all_cohps.keys()} else: self.bonds = bonds def __str__(self): if self.are_coops: return "Complete COOPs for " + str(self.structure) return "Complete COHPs for " + str(self.structure)
[docs] def as_dict(self): """ Json-serializable dict representation of CompleteCohp. """ d = {"@module": self.__class__.__module__, "@class": self.__class__.__name__, "are_coops": self.are_coops, "efermi": self.efermi, "structure": self.structure.as_dict(), "energies": self.energies.tolist(), "COHP": {"average": {str(spin): pops.tolist() for spin, pops in self.cohp.items()}}} if self.icohp is not None: d["ICOHP"] = {"average": {str(spin): pops.tolist() for spin, pops in self.icohp.items()}} for label in self.all_cohps.keys(): d["COHP"].update({label: {str(spin): pops.tolist() for spin, pops in self.all_cohps[label].cohp.items()}}) if self.all_cohps[label].icohp is not None: if "ICOHP" not in d.keys(): d["ICOHP"] = {label: {str(spin): pops.tolist() for spin, pops in self.all_cohps[label].icohp.items()}} else: d["ICOHP"].update({label: {str(spin): pops.tolist() for spin, pops in self.all_cohps[label].icohp.items()}}) if False in [bond_dict == {} for bond_dict in self.bonds.values()]: d["bonds"] = {bond: {"length": self.bonds[bond]["length"], "sites": [site.as_dict() for site in self.bonds[bond]["sites"]]} for bond in self.bonds} if self.orb_res_cohp: orb_dict = {} for label in self.orb_res_cohp: orb_dict[label] = {} for orbs in self.orb_res_cohp[label]: cohp = {str(spin): pops.tolist() for spin, pops in self.orb_res_cohp[label][orbs]["COHP"].items()} orb_dict[label][orbs] = {"COHP": cohp} icohp = {str(spin): pops.tolist() for spin, pops in self.orb_res_cohp[label][orbs]["ICOHP"].items()} orb_dict[label][orbs]["ICOHP"] = icohp orbitals = [[orb[0], orb[1].name] for orb in self.orb_res_cohp[label][orbs]["orbitals"]] orb_dict[label][orbs]["orbitals"] = orbitals d["orb_res_cohp"] = orb_dict return d
[docs] def get_cohp_by_label(self, label): """ Get specific COHP object. Args: label: string (for newer Lobster versions: a number) Returns: Returns the COHP object to simplify plotting """ if label.lower() == "average": return Cohp(efermi=self.efermi, energies=self.energies, cohp=self.cohp, are_coops=self.are_coops, icohp=self.icohp) return Cohp(efermi=self.efermi, energies=self.energies, cohp=self.all_cohps[label].get_cohp(spin=None, integrated=False), are_coops=self.are_coops, icohp=self.all_cohps[label].get_icohp(spin=None))
[docs] def get_summed_cohp_by_label_list(self, label_list, divisor=1): """ Returns a COHP object that includes a summed COHP divided by divisor Args: label_list: list of labels for the COHP that should be included in the summed cohp divisor: float/int, the summed cohp will be divided by this divisor Returns: Returns a COHP object including a summed COHP """ # check if cohps are spinpolarized or not first_cohpobject = self.get_cohp_by_label(label_list[0]) summed_cohp = first_cohpobject.cohp.copy() summed_icohp = first_cohpobject.icohp.copy() for label in label_list[1:]: cohp_here = self.get_cohp_by_label(label) summed_cohp[Spin.up] = np.sum([summed_cohp[Spin.up], cohp_here.cohp[Spin.up]], axis=0) if Spin.down in summed_cohp: summed_cohp[Spin.down] = np.sum([summed_cohp[Spin.down], cohp_here.cohp[Spin.down]], axis=0) summed_icohp[Spin.up] = np.sum([summed_icohp[Spin.up], cohp_here.icohp[Spin.up]], axis=0) if Spin.down in summed_icohp: summed_icohp[Spin.down] = np.sum([summed_icohp[Spin.down], cohp_here.icohp[Spin.down]], axis=0) divided_cohp = {} divided_icohp = {} divided_cohp[Spin.up] = np.divide(summed_cohp[Spin.up], divisor) divided_icohp[Spin.up] = np.divide(summed_icohp[Spin.up], divisor) if Spin.down in summed_cohp: divided_cohp[Spin.down] = np.divide(summed_cohp[Spin.down], divisor) divided_icohp[Spin.down] = np.divide(summed_icohp[Spin.down], divisor) return Cohp(efermi=first_cohpobject.efermi, energies=first_cohpobject.energies, cohp=divided_cohp, are_coops=first_cohpobject.are_coops, icohp=divided_icohp)
[docs] def get_summed_cohp_by_label_and_orbital_list(self, label_list, orbital_list, divisor=1): """ Returns a COHP object that includes a summed COHP divided by divisor Args: label_list: list of labels for the COHP that should be included in the summed cohp orbital_list: list of orbitals for the COHPs that should be included in the summed cohp (same order as label_list) divisor: float/int, the summed cohp will be divided by this divisor Returns: Returns a COHP object including a summed COHP """ # check length of label_list and orbital_list: if not len(label_list) == len(orbital_list): raise ValueError("label_list and orbital_list don't have the same length!") # check if cohps are spinpolarized or not first_cohpobject = self.get_orbital_resolved_cohp(label_list[0], orbital_list[0]) summed_cohp = first_cohpobject.cohp.copy() summed_icohp = first_cohpobject.icohp.copy() for ilabel, label in enumerate(label_list[1:], 1): cohp_here = self.get_orbital_resolved_cohp(label, orbital_list[ilabel]) summed_cohp[Spin.up] = np.sum([summed_cohp[Spin.up], cohp_here.cohp.copy()[Spin.up]], axis=0) if Spin.down in summed_cohp: summed_cohp[Spin.down] = np.sum([summed_cohp[Spin.down], cohp_here.cohp.copy()[Spin.down]], axis=0) summed_icohp[Spin.up] = np.sum([summed_icohp[Spin.up], cohp_here.icohp.copy()[Spin.up]], axis=0) if Spin.down in summed_icohp: summed_icohp[Spin.down] = np.sum([summed_icohp[Spin.down], cohp_here.icohp.copy()[Spin.down]], axis=0) divided_cohp = {} divided_icohp = {} divided_cohp[Spin.up] = np.divide(summed_cohp[Spin.up], divisor) divided_icohp[Spin.up] = np.divide(summed_icohp[Spin.up], divisor) if Spin.down in summed_cohp: divided_cohp[Spin.down] = np.divide(summed_cohp[Spin.down], divisor) divided_icohp[Spin.down] = np.divide(summed_icohp[Spin.down], divisor) return Cohp(efermi=first_cohpobject.efermi, energies=first_cohpobject.energies, cohp=divided_cohp, are_coops=first_cohpobject.are_coops, icohp=divided_icohp)
[docs] def get_orbital_resolved_cohp(self, label, orbitals): """ Get orbital-resolved COHP. Args: label: bond label (Lobster: labels as in ICOHPLIST/ICOOPLIST.lobster). orbitals: The orbitals as a label, or list or tuple of the form [(n1, orbital1), (n2, orbital2)]. Orbitals can either be str, int, or Orbital. Returns: A Cohp object if CompleteCohp contains orbital-resolved cohp, or None if it doesn't. Note: It currently assumes that orbitals are str if they aren't the other valid types. This is not ideal, but the easiest way to avoid unicode issues between python 2 and python 3. """ if self.orb_res_cohp is None: return None if isinstance(orbitals, (list, tuple)): cohp_orbs = [d["orbitals"] for d in self.orb_res_cohp[label].values()] orbs = [] for orbital in orbitals: if isinstance(orbital[1], int): orbs.append(tuple((orbital[0], Orbital(orbital[1])))) elif isinstance(orbital[1], Orbital): orbs.append(tuple((orbital[0], orbital[1]))) elif isinstance(orbital[1], str): orbs.append(tuple((orbital[0], Orbital[orbital[1]]))) else: raise TypeError("Orbital must be str, int, or Orbital.") orb_index = cohp_orbs.index(orbs) orb_label = list(self.orb_res_cohp[label].keys())[orb_index] elif isinstance(orbitals, str): orb_label = orbitals else: raise TypeError("Orbitals must be str, list, or tuple.") try: icohp = self.orb_res_cohp[label][orb_label]["ICOHP"] except KeyError: icohp = None return Cohp(self.efermi, self.energies, self.orb_res_cohp[label][orb_label]["COHP"], icohp=icohp, are_coops=self.are_coops)
[docs] @classmethod def from_dict(cls, d): """ Returns CompleteCohp object from dict representation. """ cohp_dict = {} efermi = d["efermi"] energies = d["energies"] structure = Structure.from_dict(d["structure"]) if "bonds" in d.keys(): bonds = {bond: {"length": d["bonds"][bond]["length"], "sites": tuple(PeriodicSite.from_dict(site) for site in d["bonds"][bond]["sites"])} for bond in d["bonds"]} else: bonds = None for label in d["COHP"]: cohp = {Spin(int(spin)): np.array(d["COHP"][label][spin]) for spin in d["COHP"][label]} try: icohp = {Spin(int(spin)): np.array(d["ICOHP"][label][spin]) for spin in d["ICOHP"][label]} except KeyError: icohp = None if label == "average": avg_cohp = Cohp(efermi, energies, cohp, icohp=icohp) else: cohp_dict[label] = Cohp(efermi, energies, cohp, icohp=icohp) if "orb_res_cohp" in d.keys(): orb_cohp = {} for label in d["orb_res_cohp"]: orb_cohp[label] = {} for orb in d["orb_res_cohp"][label]: cohp = {Spin(int(s)): np.array(d["orb_res_cohp"][label][orb]["COHP"][s], dtype=float) for s in d["orb_res_cohp"][label][orb]["COHP"]} try: icohp = {Spin(int(s)): np.array(d["orb_res_cohp"][label][orb]["ICOHP"][s], dtype=float) for s in d["orb_res_cohp"][label][orb]["ICOHP"]} except KeyError: icohp = None orbitals = [tuple((int(o[0]), Orbital[o[1]])) for o in d["orb_res_cohp"][label][orb]["orbitals"]] orb_cohp[label][orb] = {"COHP": cohp, "ICOHP": icohp, "orbitals": orbitals} # If no total COHPs are present, calculate the total # COHPs from the single-orbital populations. Total COHPs # may not be present when the cohpgenerator keyword is used # in LOBSTER versions 2.2.0 and earlier. if label not in d["COHP"] or d["COHP"][label] is None: cohp = {Spin.up: np.sum(np.array( [orb_cohp[label][orb]["COHP"][Spin.up] for orb in orb_cohp[label]]), axis=0)} try: cohp[Spin.down] = np.sum(np.array([orb_cohp[label][orb]["COHP"][Spin.down] for orb in orb_cohp[label]]), axis=0) except KeyError: pass orb_res_icohp = None in [orb_cohp[label][orb]["ICOHP"] for orb in orb_cohp[label]] if (label not in d["ICOHP"] or d["ICOHP"][label] is None) and orb_res_icohp: icohp = {Spin.up: np.sum(np.array([orb_cohp[label][orb]["ICOHP"][Spin.up] for orb in orb_cohp[label]]), axis=0)} try: icohp[Spin.down] = np.sum(np.array([orb_cohp[label][orb]["ICOHP"][Spin.down] for orb in orb_cohp[label]]), axis=0) except KeyError: pass else: orb_cohp = None if "average" not in d["COHP"].keys(): # calculate average cohp = np.array([np.array(c) for c in d["COHP"].values()]).mean(axis=0) try: icohp = np.array([np.array(c) for c in d["ICOHP"].values()]).mean(axis=0) except KeyError: icohp = None avg_cohp = Cohp(efermi, energies, cohp, icohp=icohp) return CompleteCohp(structure, avg_cohp, cohp_dict, bonds=bonds, are_coops=d["are_coops"], orb_res_cohp=orb_cohp)
[docs] @classmethod def from_file(cls, fmt, filename=None, structure_file=None, are_coops=False): """ Creates a CompleteCohp object from an output file of a COHP calculation. Valid formats are either LMTO (for the Stuttgart LMTO-ASA code) or LOBSTER (for the LOBSTER code). Args: cohp_file: Name of the COHP output file. Defaults to COPL for LMTO and COHPCAR.lobster/COOPCAR.lobster for LOBSTER. are_coops: Indicates whether the populations are COOPs or COHPs. Defaults to False for COHPs. fmt: A string for the code that was used to calculate the COHPs so that the output file can be handled correctly. Can take the values "LMTO" or "LOBSTER". structure_file: Name of the file containing the structure. If no file name is given, use CTRL for LMTO and POSCAR for LOBSTER. Returns: A CompleteCohp object. """ fmt = fmt.upper() if fmt == "LMTO": # LMTO COOPs and orbital-resolved COHP cannot be handled yet. are_coops = False orb_res_cohp = None if structure_file is None: structure_file = "CTRL" if filename is None: filename = "COPL" cohp_file = LMTOCopl(filename=filename, to_eV=True) elif fmt == "LOBSTER": if structure_file is None: structure_file = "POSCAR" if filename is None: filename = "COOPCAR.lobster" if are_coops \ else "COHPCAR.lobster" warnings.warn( "The bond labels are currently consistent with ICOHPLIST.lobster/ICOOPLIST.lobster, not with " "COHPCAR.lobster/COOPCAR.lobster. Please be aware!") cohp_file = Cohpcar(filename=filename, are_coops=are_coops) orb_res_cohp = cohp_file.orb_res_cohp else: raise ValueError("Unknown format %s. Valid formats are LMTO " "and LOBSTER." % fmt) structure = Structure.from_file(structure_file) efermi = cohp_file.efermi cohp_data = cohp_file.cohp_data energies = cohp_file.energies # Lobster shifts the energies so that the Fermi energy is at zero. # Shifting should be done by the plotter object though. spins = [Spin.up, Spin.down] if cohp_file.is_spin_polarized \ else [Spin.up] if fmt == "LOBSTER": energies += efermi if orb_res_cohp is not None: # If no total COHPs are present, calculate the total # COHPs from the single-orbital populations. Total COHPs # may not be present when the cohpgenerator keyword is used # in LOBSTER versions 2.2.0 and earlier. # TODO: Test this more extensively for label in orb_res_cohp: if cohp_file.cohp_data[label]["COHP"] is None: # print(label) cohp_data[label]["COHP"] = { sp: np.sum([orb_res_cohp[label][orbs]["COHP"][sp] for orbs in orb_res_cohp[label]], axis=0) for sp in spins} if cohp_file.cohp_data[label]["ICOHP"] is None: cohp_data[label]["ICOHP"] = \ {sp: np.sum([orb_res_cohp[label][orbs]["ICOHP"][sp] for orbs in orb_res_cohp[label]], axis=0) for sp in spins} if fmt == "LMTO": # Calculate the average COHP for the LMTO file to be # consistent with LOBSTER output. avg_data = {"COHP": {}, "ICOHP": {}} for i in avg_data: for spin in spins: rows = np.array([cohp_data[label][i][spin] for label in cohp_data]) avg = np.average(rows, axis=0) # LMTO COHPs have 5 significant figures avg_data[i].update({spin: np.array([round_to_sigfigs(a, 5) for a in avg], dtype=float)}) avg_cohp = Cohp(efermi, energies, avg_data["COHP"], icohp=avg_data["ICOHP"]) else: avg_cohp = Cohp(efermi, energies, cohp_data["average"]["COHP"], icohp=cohp_data["average"]["COHP"], are_coops=are_coops) del cohp_data["average"] cohp_dict = {label: Cohp(efermi, energies, cohp_data[label]["COHP"], icohp=cohp_data[label]["ICOHP"], are_coops=are_coops) for label in cohp_data} bond_dict = {label: {"length": cohp_data[label]["length"], "sites": [structure.sites[site] for site in cohp_data[label]["sites"]]} for label in cohp_data} return CompleteCohp(structure, avg_cohp, cohp_dict, bonds=bond_dict, are_coops=are_coops, orb_res_cohp=orb_res_cohp)
[docs]class IcohpValue(MSONable): """ Class to store information on an ICOHP or ICOOP value .. attribute:: num_bonds number of bonds used for the average cohp (relevant for Lobster versions <3.0) (int) .. attribute:: are_coops Boolean to indicate whether ICOOP or not .. attribute:: icohp dict={Spin.up: icohpvalue for spin.up, Spin.down: icohpvalue for spin.down} .. attribute:: summed_icohp: sum of icohp/icoop of both spin channels """ def __init__(self, label, atom1, atom2, length, translation, num, icohp, are_coops=False): """ Args: label: label for the icohp atom1: str of atom that is contributing to the bond atom2: str of second atom that is contributing to the bond length: float of bond lengths translation: translation list, e.g. [0,0,0] num: integer describing how often the bond exists icohp: dict={Spin.up: icohpvalue for spin.up, Spin.down: icohpvalue for spin.down} """ self._are_coops = are_coops self._label = label self._atom1 = atom1 self._atom2 = atom2 self._length = length self._translation = translation self._num = num self._icohp = icohp if Spin.down in self._icohp: self._is_spin_polarized = True else: self._is_spin_polarized = False def __str__(self): if not self._are_coops: if self._is_spin_polarized: return ("ICOHP " + str(self._label) + " between " + str(self._atom1) + " and " + str(self._atom2) + " (" + str(self._translation) + "): " + str(self._icohp[Spin.up]) + " eV (Spin up) and " + str(self._icohp[Spin.down]) + " eV (Spin down)") return ("ICOHP " + str(self._label) + " between " + str(self._atom1) + " and " + str(self._atom2) + " (" + str(self._translation) + "): " + str(self._icohp[Spin.up]) + " eV (Spin up)") if self._is_spin_polarized: return ("ICOOP " + str(self._label) + " between " + str(self._atom1) + " and " + str(self._atom2) + " (" + str(self._translation) + "): " + str(self._icohp[Spin.up]) + " (Spin up) and " + str(self._icohp[Spin.down]) + " (Spin down)") return ("ICOOP " + str(self._label) + " between " + str(self._atom1) + " and " + str(self._atom2) + " (" + str(self._translation) + "): " + str(self._icohp[Spin.up]) + " (Spin up)") @property def num_bonds(self): """ tells the number of bonds for which the ICOHP value is an average Returns: Int """ return self._num @property def are_coops(self): """ tells if ICOOPs or not Returns: Boolean """ return self._are_coops @property def is_spin_polarized(self): """ tells if spin polarized calculation or not Returns: Boolean """ return self._is_spin_polarized
[docs] def icohpvalue(self, spin=Spin.up): """ Args: spin: Spin.up or Spin.down Returns: icohpvalue (float) corresponding to chosen spin """ if not self.is_spin_polarized and spin == Spin.down: raise ValueError("The calculation was not performed with spin polarization") return self._icohp[spin]
@property def icohp(self): """ dict with icohps for spinup and spindown Return: dict={Spin.up: icohpvalue for spin.up, Spin.down: icohpvalue for spin.down} """ return self._icohp @property def summed_icohp(self): """ Adds ICOHPs of both spin channels for spin polarized compounds Returns: icohp value in eV """ if self._is_spin_polarized: sum_icohp = self._icohp[Spin.down] + self._icohp[Spin.up] else: sum_icohp = self._icohp[Spin.up] return sum_icohp
[docs]class IcohpCollection(MSONable): """ Class to store IcohpValues .. attribute:: are_coops Boolean to indicate whether ICOHPs or ICOOPs are stored .. attribute:: is_spin_polarized Boolean to indicate if the Lobster calculation was done spin polarized or not """ def __init__(self, list_labels, list_atom1, list_atom2, list_length, list_translation, list_num, list_icohp, is_spin_polarized, are_coops=False): """ Args: is_spin_polarized: Boolean to indicate if the Lobster calculation was done spin polarized or not Boolean to indicate if the Lobster calculation was done spin polarized or not are_coops: Boolean to indicate whether ICOHPs or ICOOPs are stored list_labels: list of labels for ICOHP/ICOOP values list_atom1: list of str of atomnames e.g. "O1" list_atom2: list of str of atomnames e.g. "O1" list_length: list of lengths of corresponding bonds in Angstrom list_translation: list of translation list, e.g. [0,0,0] list_num: list of equivalent bonds, usually 1 starting from Lobster 3.0.0 list_icohp: list of dict={Spin.up: icohpvalue for spin.up, Spin.down: icohpvalue for spin.down} """ self._are_coops = are_coops self._icohplist = {} self._is_spin_polarized = is_spin_polarized self._list_labels = list_labels self._list_atom1 = list_atom1 self._list_atom2 = list_atom2 self._list_length = list_length self._list_translation = list_translation self._list_num = list_num self._list_icohp = list_icohp for ilist, listel in enumerate(list_labels): self._icohplist[listel] = IcohpValue(listel, list_atom1[ilist], list_atom2[ilist], list_length[ilist], list_translation[ilist], list_num[ilist], list_icohp[ilist]) def __str__(self): joinstr = [] for value in self._icohplist.values(): joinstr.append(str(value)) return "\n".join(joinstr)
[docs] def get_icohp_by_label(self, label, summed_spin_channels=True, spin=Spin.up): """ get an icohp value for a certain bond as indicated by the label (bond labels starting by "1" as in ICOHPLIST/ICOOPLIST) Args: label: label in str format (usually the bond number in Icohplist.lobster/Icooplist.lobster summed_spin_channels: Boolean to indicate whether the ICOHPs/ICOOPs of both spin channels should be summed spin: if summed_spin_channels is equal to False, this spin indicates which spin channel should be returned Returns: float describing ICOHP/ICOOP value """ icohp_here = self._icohplist[label] if icohp_here._is_spin_polarized: if summed_spin_channels: return icohp_here.summed_icohp return icohp_here.icohpvalue(spin) return icohp_here.icohpvalue(spin)
[docs] def get_summed_icohp_by_label_list(self, label_list, divisor=1.0, summed_spin_channels=True, spin=Spin.up): """ get the sum of several ICOHP values that are indicated by a list of labels (labels of the bonds are the same as in ICOHPLIST/ICOOPLIST) Args: label_list: list of labels of the ICOHPs/ICOOPs that should be summed divisor: is used to divide the sum summed_spin_channels: Boolean to indicate whether the ICOHPs/ICOOPs of both spin channels should be summed spin: if summed_spin_channels is equal to False, this spin indicates which spin channel should be returned Returns: float that is a sum of all ICOHPs/ICOOPs as indicated with label_list """ sum_icohp = 0 for label in label_list: icohp_here = self._icohplist[label] if icohp_here.num_bonds != 1: warnings.warn("One of the ICOHP values is an average over bonds. This is currently not considered.") # prints warning if num_bonds is not equal to 1 if icohp_here._is_spin_polarized: if summed_spin_channels: sum_icohp = sum_icohp + icohp_here.summed_icohp else: sum_icohp = sum_icohp + icohp_here.icohpvalue(spin) else: sum_icohp = sum_icohp + icohp_here.icohpvalue(spin) return sum_icohp / divisor
[docs] def get_icohp_dict_by_bondlengths(self, minbondlength=0.0, maxbondlength=8.0): """ get a dict of IcohpValues corresponding to certaind bond lengths Args: minbondlength: defines the minimum of the bond lengths of the bonds maxbondlength: defines the maximum of the bond lengths of the bonds Returns: dict of IcohpValues, the keys correspond to the values from the initial list_labels """ newicohp_dict = {} for value in self._icohplist.values(): if value._length >= minbondlength and value._length <= maxbondlength: newicohp_dict[value._label] = value return newicohp_dict
[docs] def get_icohp_dict_of_site(self, site, minsummedicohp=None, maxsummedicohp=None, minbondlength=0.0, maxbondlength=8.0, only_bonds_to=None): """ get a dict of IcohpValue for a certain site (indicated by integer) Args: site: integer describing the site of interest, order as in Icohplist.lobster/Icooplist.lobster, starts at 0 minsummedicohp: float, minimal icohp/icoop of the bonds that are considered. It is the summed ICOHP value from both spin channels for spin polarized cases maxsummedicohp: float, maximal icohp/icoop of the bonds that are considered. It is the summed ICOHP value from both spin channels for spin polarized cases minbondlength: float, defines the minimum of the bond lengths of the bonds maxbondlength: float, defines the maximum of the bond lengths of the bonds only_bonds_to: list of strings describing the bonding partners that are allowed, e.g. ['O'] Returns: dict of IcohpValues, the keys correspond to the values from the initial list_labels """ newicohp_dict = {} for key, value in self._icohplist.items(): atomnumber1 = int(re.split(r'(\d+)', value._atom1)[1]) - 1 atomnumber2 = int(re.split(r'(\d+)', value._atom2)[1]) - 1 if site in (atomnumber1, atomnumber2): # manipulate order of atoms so that searched one is always atom1 if site == atomnumber2: save = value._atom1 value._atom1 = value._atom2 value._atom2 = save if only_bonds_to is None: second_test = True else: second_test = (re.split(r'(\d+)', value._atom2)[0] in only_bonds_to) if value._length >= minbondlength and value._length <= maxbondlength and second_test: if minsummedicohp is not None: if value.summed_icohp >= minsummedicohp: if maxsummedicohp is not None: if value.summed_icohp <= maxsummedicohp: newicohp_dict[key] = value else: newicohp_dict[key] = value else: if maxsummedicohp is not None: if value.summed_icohp <= maxsummedicohp: newicohp_dict[key] = value else: newicohp_dict[key] = value return newicohp_dict
[docs] def extremum_icohpvalue(self, summed_spin_channels=True, spin=Spin.up): """ get ICOHP/ICOOP of strongest bond Args: summed_spin_channels: Boolean to indicate whether the ICOHPs/ICOOPs of both spin channels should be summed spin: if summed_spin_channels is equal to False, this spin indicates which spin channel should be returned Returns: lowest ICOHP/largest ICOOP value (i.e. ICOHP/ICOOP value of strongest bond) """ if not self._are_coops: extremum = sys.float_info.max else: extremum = -sys.float_info.max if not self._is_spin_polarized: if spin == Spin.down: warnings.warn("This spin channel does not exist. I am switching to Spin.up") spin = Spin.up for value in self._icohplist.values(): if not value.is_spin_polarized or not summed_spin_channels: if not self._are_coops: if value.icohpvalue(spin) < extremum: extremum = value.icohpvalue(spin) # print(extremum) else: if value.icohpvalue(spin) > extremum: extremum = value.icohpvalue(spin) # print(extremum) else: if not self._are_coops: if value.summed_icohp < extremum: extremum = value.summed_icohp # print(extremum) else: if value.summed_icohp > extremum: extremum = value.summed_icohp # print(extremum) return extremum
@property def is_spin_polarized(self): """ :return: Whether it is spin polarized. """ return self._is_spin_polarized @property def are_coops(self): """ :return: Whether this is coops. """ return self._are_coops