TCMU 0.17.0__py3-none-any.whl

tcmu/__init__.py

@@ -0,0 +1,85 @@
+# Job imports
+from tcmu.cache import cache, cache_file, timed_cache
+from tcmu import log
+from tcmu.analysis.pyfrag import PyFragResult, get_pyfrag_results
+from tcmu.analysis.task_specific.irc import concatenate_irc_trajectories
+from tcmu.analysis.vdd.charge import VDDCharge
+
+# from tcmu.analysis.vdd.manager import VDDChargeManager, create_vdd_charge_manager # Don't load in vdd as it has an annoying pandas dependency that cannot be avoided upon importing
+from tcmu.analysis.vibration.ts_vibration import avg_relative_bond_length_delta, determine_ts_reactioncoordinate, validate_transitionstate
+from tcmu.cite import cite, _get_doi_data, _get_doi_data_from_title, _get_doi_data_from_query, _get_publisher_city, _get_journal_abbreviation
+from tcmu.connect import Connection, Local, Server, ServerFile
+from tcmu.data.functionals import categories, functional_name_from_path_safe_name, functionals, get_available_functionals, get_functional
+from tcmu.environment import requires_optional_package
+from tcmu.geometry import KabschTransform, MolTransform, Transform, apply_rotmat, get_rotmat, rotate, rotmat_to_angles, vector_align_rotmat
+from tcmu.results.read import get_info, quick_status, read, get_timing
+from tcmu.results.result import Result
+from tcmu.job.workflow import WorkFlow
+from tcmu.job import workflow_db, workflow_status
+from tcmu.job.adf import ADFFragmentJob, ADFJob, DensfJob
+from tcmu.job.ams import AMSJob
+from tcmu.job.crest import CRESTJob, QCGJob
+from tcmu.job.dftb import DFTBJob
+from tcmu.job.nmr import NMRJob
+from tcmu.job.orca import ORCAJob, GOATJob
+from tcmu.job.xtb import XTBJob
+from tcmu.molecule import from_string, guess_fragments, load, number_of_electrons, save, write_mol_to_amv_file, write_mol_to_xyz_file
+# from tcmu.report.report import SI
+from tcmu.timer import timer
+
+__all__ = [
+    "ADFFragmentJob",
+    "ADFJob",
+    "DensfJob",
+    "AMSJob",
+    "CRESTJob",
+    "QCGJob",
+    "DFTBJob",
+    "NMRJob",
+    "ORCAJob",
+    "GOATJob",
+    "XTBJob",
+    "log",
+    "from_string",
+    "guess_fragments",
+    "load",
+    "number_of_electrons",
+    "save",
+    "write_mol_to_amv_file",
+    "write_mol_to_xyz_file",
+    "get_info",
+    "quick_status",
+    "read",
+    "Result",
+    "timer",
+    "Connection",
+    "Local",
+    "Server",
+    "ServerFile",
+    "cache",
+    "cache_file",
+    "cite",
+    "requires_optional_package",
+    "Transform",
+    "KabschTransform",
+    "MolTransform",
+    "get_rotmat",
+    "rotmat_to_angles",
+    "apply_rotmat",
+    "rotate",
+    "vector_align_rotmat",
+    "PyFragResult",
+    "get_pyfrag_results",
+    "concatenate_irc_trajectories",
+    "VDDCharge",
+    "avg_relative_bond_length_delta",
+    "determine_ts_reactioncoordinate",
+    "validate_transitionstate",
+    "categories",
+    "functionals",
+    "functional_name_from_path_safe_name",
+    "get_functional",
+    "get_available_functionals",
+    # "SI",
+    "timed_cache",
+]

tcmu/analysis/pyfrag.py

@@ -0,0 +1,175 @@
+import os
+from typing import List, Union
+
+import numpy as np
+from scm import plams
+
+import tcmu
+from tcmu.cache import cache
+from tcmu.environment import requires_optional_package
+from tcmu.geometry import parameter
+from tcmu.pathfunc import match
+
+
+def get_pyfrag_results(path):
+    return PyFragResult(path)
+
+
+class PyFragResult:
+    def __init__(self, path, step_prefix: str = "Step."):
+        self.path = path
+
+        self._frag_results = {}
+        self._step_results = []
+        self._order = []
+        self._mask = []
+        self._properties = {}
+
+        self.step_prefix = step_prefix
+
+        self._load()
+
+    def _load(self):
+        for frag_path, info in tcmu.log.loadbar(match(self.path, "frag_{frag}").items()):
+            self._frag_results[info.frag] = tcmu.read(frag_path)
+
+        for step_path, info in tcmu.log.loadbar(match(self.path, self.step_prefix + "{step}", sort_by="step").items()):
+            self._step_results.append({})
+            for dir_name in os.listdir(step_path):
+                p = os.path.join(step_path, dir_name)
+                res = tcmu.read(p)
+                self._step_results[-1][dir_name] = res
+
+            self._order.append(int(info.step.removeprefix("0")))
+            self._mask.append(True)
+
+        self._mask = np.array(self._mask)
+
+    def get_property(self, key: str, calc: str = "complex"):
+        if key in self._properties:
+            return self._properties[key][self._order][self._mask[self._order]]
+        p = np.array([res[calc].properties.get_multi_key(key) for res in self._step_results])
+        return p[self._order][self._mask[self._order]]
+
+    @property
+    def fragments(self):
+        return list(self._frag_results.keys())
+
+    def __len__(self):
+        return sum(self._mask)
+
+    def get_geometry(self, *args, **kwargs):
+        calc = kwargs.pop("calc", "complex")
+        g = np.array([parameter(res[calc].molecule.input, *args, **kwargs) for res in self._step_results])
+        return g[self._order][self._mask[self._order]]
+
+    def get_molecules(self, calc: str = "complex") -> List[plams.Molecule]:
+        mols = [res[calc].molecule.input for res in self._step_results]
+        return mols
+        return [mols[int(i)] for i in np.array(self._order)[self._mask[self._order]]]
+
+    def sort_by(self, val: Union[str, List], calc: str = "complex"):
+        if isinstance(val, str):
+            val = self.get_property(val, calc=calc)
+        self._order = np.argsort(val)
+
+    def set_mask(self, mask: list):
+        self._mask = mask
+
+    def set_coord(self, coord: list):
+        self._coord = coord
+
+    def coord(self):
+        return self._coord[self._order][self._mask[self._order]]
+
+    def set_property(self, name: str, vals):
+        self._properties[name] = vals
+
+    @property
+    def ts_idx(self):
+        energies = self.total_energy()
+        for i in range(len(self) - 2, 1, -1):
+            if energies[i - 1] < energies[i] and energies[i] < energies[i + 1]:
+                return i + 1
+
+    def total_energy(self):
+        return self.interaction_energy() + self.strain_energy()
+
+    def interaction_energy(self):
+        return self.get_property("energy.bond", "complex")
+
+    def strain_energy(self, fragment: str = ""):
+        if fragment is None:
+            t = 0
+            for frag in self.fragments:
+                t += self.strain_energy(frag)
+            return t
+
+        return self.get_property("energy.bond", f"frag_{fragment}") - self._frag_results[fragment].properties.energy.bond
+
+    @requires_optional_package("pyfmo")
+    def overlap(self, orb1, orb2, calc: str = "complex", absolute: bool = True):
+        S = np.array([orb.sfos[orb1] @ orb.sfos[orb2] for orb in self.orbs(calc)])
+        if absolute:
+            S = abs(S)
+        return S[self._order][self._mask[self._order]]
+
+    @requires_optional_package("pyfmo")
+    def orbital_energy_gap(self, orb1, orb2, calc: str = "complex"):
+        dE = np.array([abs(orb.sfos[orb1].energy - orb.sfos[orb2].energy) for orb in self.orbs(calc)])
+        return dE[self._order][self._mask[self._order]]
+
+    @requires_optional_package("pyfmo")
+    def sfo_coefficient(self, sfo, mo, calc: str = "complex"):
+        C = np.array([orb.sfos[sfo].coefficient(orb.mos[mo]) for orb in self.orbs(calc)])
+        return C[self._order][self._mask[self._order]]
+
+    @cache
+    @requires_optional_package("pyfmo")
+    def orbs(self, calc: str = "complex"):
+        import pyfmo
+
+        return [pyfmo.Orbitals(res[calc].files["adf.rkf"]) for res in self._step_results]
+
+
+if __name__ == "__main__":
+    import matplotlib.pyplot as plt
+
+    res_C = get_pyfrag_results("/Users/yumanhordijk/PhD/Projects/RadicalAdditionASMEDA/data/DFT/TS_C_O/PyFrag_OLYP_TZ2P")
+    res_X = get_pyfrag_results("/Users/yumanhordijk/PhD/Projects/RadicalAdditionASMEDA/data/DFT/TS_X_O/PyFrag_OLYP_TZ2P")
+
+    res_C.set_coord(res_C.get_geometry(0, 1))
+    res_X.set_coord(res_X.get_geometry(1, 2))
+
+    res_C.sort_by(res_C.coord())
+    res_X.sort_by(res_X.coord())
+
+    plt.figure()
+    plt.plot(res_C.coord(), res_C.overlap("Methyl(SOMO)_A", "Substrate(LUMO)_A"), label="C-addition")
+    plt.plot(res_X.coord(), res_X.overlap("Methyl(SOMO)_A", "Substrate(LUMO)_A"), label="X-addition")
+    plt.ylabel(r"$\langle SOMO | LUMO \rangle$")
+    plt.legend()
+    plt.xlim(3, 2.2)
+
+    plt.figure()
+    plt.plot(res_C.coord(), res_C.orbital_energy_gap("Methyl(SOMO)_A", "Substrate(LUMO)_A"), label="C-addition")
+    plt.plot(res_X.coord(), res_X.orbital_energy_gap("Methyl(SOMO)_A", "Substrate(LUMO)_A"), label="X-addition")
+    plt.ylabel(r"$|\epsilon_{SOMO} - \epsilon_{LUMO}|$")
+    plt.legend()
+    plt.xlim(3, 2.2)
+
+    plt.figure()
+    plt.plot(res_C.coord(), res_C.overlap("Methyl(LUMO)_B", "Substrate(7A_B)_B"), label="C-addition")
+    plt.plot(res_X.coord(), res_X.overlap("Methyl(LUMO)_B", "Substrate(7A_B)_B"), label="X-addition")
+    plt.ylabel(r"$\langle SUMO | HOMO \rangle$")
+    plt.legend()
+    plt.xlim(3, 2.2)
+
+    plt.figure()
+    plt.plot(res_C.coord(), res_C.orbital_energy_gap("Methyl(LUMO)_B", "Substrate(7A_B)_B"), label="C-addition")
+    plt.plot(res_X.coord(), res_X.orbital_energy_gap("Methyl(LUMO)_B", "Substrate(7A_B)_B"), label="X-addition")
+    plt.ylabel(r"$|\epsilon_{SUMO} - \epsilon_{HOMO}|$")
+    plt.legend()
+    plt.xlim(3, 2.2)
+
+    plt.show()

tcmu/analysis/task_specific/irc.py

@@ -0,0 +1,96 @@
+import pathlib as pl
+from typing import List, Tuple, Union
+
+import numpy as np
+from scm.plams import Molecule
+
+from tcmu.log import log
+from tcmu.results.read import read
+from tcmu.results.result import Result
+
+
+def create_result_objects(job_dirs: Union[List[str], List[pl.Path]]) -> List[Result]:
+    """Creates a list of Result objects from a list of directories."""
+    return [read(pl.Path(file)) for file in job_dirs]
+
+
+def _get_converged_energies(res: Result) -> List[float]:
+    """Returns a list of energies of the converged geometries."""
+    return [energy for converged, energy in zip(res.history.converged, res.history.energy) if converged]  # type: ignore
+
+
+def _get_converged_molecules(res: Result) -> List[Molecule]:
+    """Returns a list of molecules of the converged geometries."""
+    return [mol for converged, mol in zip(res.history.converged, res.history.molecule) if converged]  # type: ignore
+
+
+def _concatenate_irc_trajectories_by_rmsd(irc_trajectories: List[List[Molecule]], energies: Union[List[List[float]], None]) -> Tuple[List[Molecule], List[float]]:
+    """
+    Concatenates lists of molecules by comparing the RMSD values of the end and beginnings of the trajectory.
+    The entries that are closest to each other are used to concatenate the trajectories.
+
+    Parameters:
+        irc_trajectories: A list of lists of Molecule objects representing the trajectories.
+        energies: A list of lists of float values representing the energies.
+
+    Returns:
+        A tuple containing a list of Molecule objects and a list of energies.
+
+    Raises:
+        ValueError: If the RMSD values are not as expected.
+    """
+    concatenated_mols: List[Molecule] = irc_trajectories[0][::-1]
+    concatenated_energies: List[float] = energies[0][::-1] if energies is not None else []
+
+    for traj_index in range(len(irc_trajectories) - 1):
+        # Calculate RMSD values of two connected trajectories to compare the connection points / molecules
+        rmsd_matrix = np.array([[Molecule.rmsd(irc_trajectories[traj_index][i], irc_trajectories[traj_index + 1][j]) for j in [0, -1]] for i in [0, -1]])
+
+        # Flatten the matrix and find the index of the minimum value
+        lowest_index = np.argmin(rmsd_matrix.flatten())
+
+        log(f"Lowest RMSD values: {rmsd_matrix.flatten()}", 10)
+
+        # Starting points are connected
+        if lowest_index == 0:
+            concatenated_mols += irc_trajectories[traj_index + 1][1:]
+            concatenated_energies += energies[traj_index + 1][1:] if energies is not None else []
+        # Ending points are connected
+        elif lowest_index == 1:
+            concatenated_mols += irc_trajectories[traj_index + 1][::-1]
+            concatenated_energies += energies[traj_index + 1][::-1] if energies is not None else []
+        # Something went wrong
+        else:
+            raise ValueError(f"The RMSD values are not as expected: {rmsd_matrix.flatten()} with {lowest_index=}.")
+
+    return concatenated_mols, concatenated_energies
+
+
+def concatenate_irc_trajectories(result_objects: List[Result], reverse: bool = False) -> Tuple[List[Molecule], List[float]]:
+    """
+    Concatenates trajectories from irc calculations, often being forward and backward, through the RMSD values.
+
+    Parameters:
+        job_dirs: A list of directories containing the ams.rkf files.
+        user_log_level: The log level set by the user.
+        reverse: A boolean indicating whether to reverse the trajectory. Default is False.
+
+    Returns:
+        A tuple containing a list of Molecule objects and a list of energies.
+
+    Raises:
+        Exception: If an exception is raised in the try block, it is caught and printed.
+    """
+    traj_geometries: List[List[Molecule]] = [[] for _ in result_objects]
+    traj_energies: List[List[float]] = [[] for _ in result_objects]
+
+    for i, res_obj in enumerate(result_objects):
+        traj_geometries[i] = _get_converged_molecules(res_obj)
+        traj_energies[i] = _get_converged_energies(res_obj)
+
+    concatenated_mols, concatenated_energies = _concatenate_irc_trajectories_by_rmsd(traj_geometries, traj_energies)
+
+    if reverse:
+        concatenated_mols = concatenated_mols[::-1]
+        concatenated_energies = concatenated_energies[::-1]
+    return concatenated_mols, concatenated_energies

tcmu/analysis/vdd/charge.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class VDDCharge:
+    atom_index: int  # index of the atom in the molecules
+    atom_symbol: str  # symbol of the atom
+    charge: float  # mili-electrons
+    frag_index: int  # index of the fragment in the fragments list
+
+    def change_unit(self, ratio: float):
+        self.charge *= ratio

tcmu/analysis/vdd/manager.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+from importlib.util import find_spec
+
+from tcmu import environment, errors
+
+if find_spec("pandas") is None:
+    raise errors.TCMUMissingOptionalPackageError("pandas")
+
+import copy
+import pathlib as pl
+from itertools import zip_longest
+from typing import Dict, List, Literal, Optional, Sequence, Set, Union
+
+import numpy as np
+import pandas as pd
+
+from tcmu.analysis.vdd import charge
+from tcmu.constants import VDD_UNITS
+from tcmu.results import result
+
+PRINT_FORMAT = {"me": "%+.0f", "e": "%+.3f"}
+
+__all__ = ["VDDChargeManager", "create_vdd_charge_manager"]
+
+
+def create_vdd_charge_manager(results: result.Result) -> VDDChargeManager:
+    """Create a VDDChargeManager from a Result object."""
+    vdd_charges: Dict[str, List[charge.VDDCharge]] = {}
+    atom_symbols = results.molecule.atom_symbols  # type: ignore
+    frag_indices = results.molecule.frag_indices  # type: ignore
+    calc_dir = pl.Path(results.files["root"])  # type: ignore
+    is_fragment_calculation = results.adf.used_regions  # type: ignore
+    mol_charge = results.molecule.mol_charge  # type: ignore
+
+    # Convert the VDD charges to VDDCharge objects
+    for irrep, charge_array in results.properties.vdd.items():  # type: ignore
+        irrep = "vdd" if irrep == "charges" else irrep
+        vdd_charges[irrep] = []
+        for atom_index, (frag_index, vdd_charge) in enumerate(zip(frag_indices, charge_array)):
+            atom_symbol = atom_symbols[atom_index]
+            vdd_charges[irrep].append(charge.VDDCharge(atom_index + 1, atom_symbol, vdd_charge, frag_index))
+
+    return VDDChargeManager(vdd_charges, is_fragment_calculation, calc_dir, mol_charge)
+
+
+class VDDChargeManager:
+    """Class to manage the VDD charges. It can be used to print the VDD charges in a nice table and write them to a text file or excel file."""
+
+    def __init__(self, vdd_charges: Dict[str, List[charge.VDDCharge]], is_fragment_calculation: bool, calc_dir: pl.Path, mol_charge: int):
+        self.vdd_charges = vdd_charges
+        self.is_fragment_calculation = is_fragment_calculation
+        self.calc_dir = calc_dir
+        self.mol_charge = mol_charge
+        self.name = self.calc_dir.name if self.calc_dir is not None else ""
+        self.unit = "e"  # unit of the VDD charges. Available units are "me" (mili-electrons) and "e" (electrons)
+        self.irreps: Set[str] = set(self.vdd_charges.keys())
+        self.change_unit("me")
+
+    def __str__(self) -> str:
+        """Prints the VDD charges in a nice table. Checks if the calculation is a fragment calculation and prints the summed VDD charges if it is."""
+        individual_charges_table = self.get_vdd_charges_table()
+        summed_charges_table = self.get_summed_vdd_charges_table()
+
+        ret_str = f"{self.name}\nVDD charges (in unit {self.unit}):\n{individual_charges_table}\n\n"
+        if self.is_fragment_calculation:
+            ret_str += f"Summed VDD charges (in unit {self.unit}):\n{summed_charges_table}\n"
+
+        return ret_str
+
+    def charge_is_conserved(self) -> bool:
+        """Check if the total charge of the molecule is conserved. The total charge is the sum of the VDD charges."""
+        tolerance = 1e-4 if self.unit == "e" else 1e-1
+        is_conserved = np.isclose(self.mol_charge, sum([charge.charge for charge in self.vdd_charges["vdd"]]), atol=tolerance)
+        return is_conserved  # type: ignore since numpy _bool is not recognized as bool
+
+    def change_unit(self, new_unit: str) -> None:
+        """Change the unit of the VDD charges. Available units are "me" (mili-electrons) and "e" (electrons)."""
+        if new_unit not in VDD_UNITS:
+            raise ValueError(f"Unit {new_unit} is not available. Choose from {VDD_UNITS.keys()}")
+
+        if new_unit == self.unit:
+            return
+
+        ratio = VDD_UNITS[new_unit] / VDD_UNITS[self.unit]
+        [charge.change_unit(ratio) for charges in self.vdd_charges.values() for charge in charges]
+        self.unit = new_unit
+
+    def get_vdd_charges(self, unit: Literal["e", "me"] = "me") -> Dict[str, List[charge.VDDCharge]]:
+        """Get the VDD charges in the specified unit ([me] or [e])."""
+        self.change_unit(unit)
+        return copy.deepcopy(self.vdd_charges)
+
+    def get_summed_vdd_charges(self, irreps: Optional[Sequence[str]] = None, unit: Literal["e", "me"] = "me") -> Dict[str, Dict[str, float]]:
+        """Get the summed VDD charges per fragment for the specified unit ([me] or [e])."""
+        self.change_unit(unit)
+        irreps = irreps if irreps is not None else list(self.irreps)
+        summed_vdd_charges: Dict[str, Dict[str, float]] = {}
+
+        for irrep in irreps:
+            summed_vdd_charges[irrep] = {}
+            for vdd_charge in self.vdd_charges[irrep]:
+                frag_index = str(vdd_charge.frag_index)
+                summed_vdd_charges[irrep].setdefault(frag_index, 0.0)
+                summed_vdd_charges[irrep][frag_index] += vdd_charge.charge
+
+        return copy.deepcopy(summed_vdd_charges)
+
+    def get_vdd_charges_dataframe(self) -> pd.DataFrame:
+        """Get the VDD charges as a pandas DataFrame in a specified unit ([me] or [e])."""
+
+        frag_indices = [charge.frag_index for charge in self.vdd_charges["vdd"]]
+        atom_symbols = [f"{charge.atom_index}{charge.atom_symbol}" for charge in self.vdd_charges["vdd"]]
+        charges = [[charge.charge for charge in charges] for _, charges in self.vdd_charges.items()]
+        headers = ["Frag", "Atom"] + [irrep for irrep, _ in self.vdd_charges.items()]
+        combined_table = list(zip_longest(frag_indices, atom_symbols, *charges, fillvalue=""))
+        df = pd.DataFrame(combined_table, columns=headers).rename(columns={"vdd": "Total"})
+        return df
+
+    def get_summed_vdd_charges_dataframe(self) -> pd.DataFrame:
+        """Get the summed VDD charges as a pandas DataFrame in a specified unit ([me] or [e])."""
+        summed_data = self.get_summed_vdd_charges()
+        summed_data["Frag"] = {str(key): int(key) for key in summed_data["vdd"].keys()}
+        df = pd.DataFrame(summed_data).pipe(lambda df: df[df.columns.tolist()[-1:] + df.columns.tolist()[:-1]])  # move the "Frag" column to the front
+        return df.rename(columns={"vdd": "Total"})
+
+    def get_vdd_charges_table(self) -> str:
+        df = self.get_vdd_charges_dataframe()
+        return df.to_string(float_format=lambda x: PRINT_FORMAT[self.unit] % x, justify="center", index=False, col_space=6)
+
+    def get_summed_vdd_charges_table(self) -> str:
+        df = self.get_summed_vdd_charges_dataframe()
+        return df.to_string(float_format=lambda x: PRINT_FORMAT[self.unit] % x, justify="center", col_space=6, index=False)
+
+    @staticmethod
+    def write_to_txt(output_dir: Union[str, pl.Path], managers: Union[VDDChargeManager, Sequence[VDDChargeManager]], unit: str = "me") -> None:
+        """Write the VDD charges to a text file. It is a static method because multiple managers can be written to the same file."""
+        out_dir = pl.Path(output_dir) if not isinstance(output_dir, pl.Path) else output_dir
+        files = [out_dir / "VDD_charges_per_atom.txt", out_dir / "VDD_charges_per_fragment.txt"]
+        managers = managers if isinstance(managers, Sequence) else [managers]
+
+        # Print charges per atom and per fragment in seperate files
+        for i, file in enumerate(files):
+            with open(file, "w") as f:
+                f.write("VDD charges:\n")
+                for manager in managers:
+                    f.write(f"{manager.name} (unit = {manager.unit})\n")
+                    if i == 0:
+                        f.write(manager.get_vdd_charges_table())
+                    else:
+                        f.write(manager.get_summed_vdd_charges_table()) if manager.is_fragment_calculation else f.write("No fragment calculation\n")
+                    f.write("\n\n")
+
+    @environment.requires_optional_package("openpyxl")
+    def write_to_excel(self, output_file: Optional[Union[str, pl.Path]] = None) -> None:
+        """Write the VDD charges to an excel file. Results are written to two sheets: "VDD charges" and "Summed VDD charges"."""
+        file = pl.Path(output_file) if output_file is not None else self.calc_dir / f"vdd_charges_{self.name}.xlsx"
+        file = file.with_suffix(".xlsx") if not file.suffix == ".xlsx" else file
+
+        df = self.get_vdd_charges_dataframe()
+
+        with pd.ExcelWriter(file) as writer:
+            df.to_excel(writer, sheet_name=f"VDD charges (in {self.unit})", index=False, float_format=PRINT_FORMAT[self.unit])
+            if self.is_fragment_calculation:
+                df_summed = self.get_summed_vdd_charges_dataframe()
+                df_summed.to_excel(writer, sheet_name=f"Summed VDD charges  (in {self.unit})", index=False, float_format=PRINT_FORMAT[self.unit])
+
+    @environment.requires_optional_package("matplotlib")
+    def plot_vdd_charges_per_atom(self, output_file: Optional[Union[str, pl.Path]] = None, unit: str = "me") -> None:
+        """Plot the VDD charges as a bar graph for each irrep."""
+        import matplotlib.pyplot as plt
+
+        file = pl.Path(output_file) if output_file is not None else self.calc_dir / f"vdd_charges_{self.name}.png"
+        file = file.with_suffix(".png") if not file.suffix == ".png" else file
+        self.change_unit(unit)
+
+        # Increase the global font size
+        plt.rcParams.update({"font.size": 14})
+
+        num_irreps = len(self.vdd_charges)
+        n_max_charges = max([len(charges) for charges in self.vdd_charges.values()])
+        _, axs = plt.subplots(num_irreps, 1, figsize=(n_max_charges * 1.15, 5 * num_irreps), sharey=True)
+        axs = [axs] if num_irreps == 1 else axs
+
+        # Initialize a variable to keep track of the most positive/negative values
+        adjusted_abs_max_values = []
+
+        counter = 1
+        for ax, (irrep, charges) in zip(axs, self.vdd_charges.items()):
+            atom_symbols = [f"{charge.atom_index}{charge.atom_symbol} ({charge.frag_index})" for charge in charges]
+            charge_values = [charge.charge for charge in charges]
+
+            bars = ax.bar(atom_symbols, charge_values, color="sandybrown", edgecolor="black")
+            if counter == len(axs):
+                ax.set_xlabel("Atom (#Fragment Number)")
+            ax.set_ylabel(f"Charge ({unit})")
+            ax.set_title(f"VDD Charges {self.name} - {irrep}")
+            ax.yaxis.grid(True)  # Only display vertical grid lines
+
+            # Add the charge value on top of each bar. If the value is negative, place the text below the bar
+            for bar in bars:
+                yval = bar.get_height()
+                x_pos = bar.get_x() + bar.get_width() / 2
+
+                if yval <= 0:
+                    ax.text(x_pos, yval + yval * 0.1, int(yval), va="top", ha="center")
+                else:
+                    ax.text(x_pos, yval + yval * 0.1, int(yval), va="bottom", ha="center")
+                adjusted_abs_max_values.append(yval + yval * 0.1)
+            counter += 1
+
+        # Making sure the values do not extend outside the plot. Also determines the y-axis limits for all subplotss
+        min_value, max_value = min(adjusted_abs_max_values), max(adjusted_abs_max_values)
+
+        # Axes adjustments
+        # Set the y-axis limits for all subplots based on the most positive/negative values
+        for ax in axs:
+            ax.set_ylim([min_value - abs(min_value) * 0.2, max_value + abs(max_value) * 0.2])
+
+        # plt.tight_layout()
+        plt.savefig(file, dpi=300)