cclib 1.8.1__tar.gz → 2.0a1__tar.gz

{cclib-1.8.1/cclib.egg-info → cclib-2.0a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cclib
-Version: 1.8.1
+Version: 2.0a1
 Summary: parsers and algorithms for computational chemistry
 Author-email: cclib development team <cclib@googlegroups.com>
 Maintainer-email: cclib development team <cclib@googlegroups.com>
@@ -79,7 +79,7 @@ Requires-Dist: cclib[bridges]; extra == "all"
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.8280878.svg)](https://doi.org/10.5281/zenodo.8280878)
 [![PyPI version](http://img.shields.io/pypi/v/cclib.svg?style=flat)](https://pypi.python.org/pypi/cclib)
 [![GitHub release](https://img.shields.io/github/release/cclib/cclib.svg?style=flat)](https://github.com/cclib/cclib/releases)
-[![build status](https://github.com/cclib/cclib/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/cclib/cclib/actions/workflows/cclib_pytest.yml)
+[![build status](https://github.com/cclib/cclib/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/cclib/cclib/actions/workflows/ci.yml)
 [![license](http://img.shields.io/badge/license-BSD-blue.svg?style=flat)](https://github.com/cclib/cclib/blob/master/LICENSE)
 
 <img src="./logo.png" alt="cclib logo" width="100" />

{cclib-1.8.1 → cclib-2.0a1}/README.md

@@ -3,7 +3,7 @@
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.8280878.svg)](https://doi.org/10.5281/zenodo.8280878)
 [![PyPI version](http://img.shields.io/pypi/v/cclib.svg?style=flat)](https://pypi.python.org/pypi/cclib)
 [![GitHub release](https://img.shields.io/github/release/cclib/cclib.svg?style=flat)](https://github.com/cclib/cclib/releases)
-[![build status](https://github.com/cclib/cclib/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/cclib/cclib/actions/workflows/cclib_pytest.yml)
+[![build status](https://github.com/cclib/cclib/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/cclib/cclib/actions/workflows/ci.yml)
 [![license](http://img.shields.io/badge/license-BSD-blue.svg?style=flat)](https://github.com/cclib/cclib/blob/master/LICENSE)
 
 <img src="./logo.png" alt="cclib logo" width="100" />

{cclib-1.8.1 → cclib-2.0a1}/cclib/__init__.py

@@ -20,17 +20,29 @@ as well as example methods that take parsed data as input.
 from cclib._version import __version__
 
 # isort: off
-from cclib import parser, progress, method, bridge, io
+# from cclib import parser, progress, method, bridge
+from cclib import (
+    io,
+    file_handler,
+    collection,
+    combinator,
+    driver,
+    attributes,
+    attribute_parsers,
+    tree,
+)
 # isort: on
 
 # The test module can be imported if it was installed with cclib.
-try:
-    from cclib import test
-except ImportError:
-    pass
+# todo try:
+# todo     from cclib import test
+# todo except ImportError:
+# todo     pass
 
 # The objects below constitute our public API. These names will not change
 # over time. Names in the sub-modules will typically also be backwards
 # compatible, but may sometimes change when code is moved around.
-ccopen = io.ccopen
-ccwrite = io.ccwrite
+# ccopen = io.ccopen
+# ccwrite = io.ccwrite
+
+ccDriver = driver.ccDriver

cclib-2.0a1/cclib/_version.py

@@ -0,0 +1 @@
+__version__ = "2.0a1"

cclib-2.0a1/cclib/attribute_parsers/__init__.py

@@ -0,0 +1,26 @@
+# Copyright (c) 2024, the cclib development team
+#
+# This file is part of cclib (http://cclib.github.io) and is distributed under
+# the terms of the BSD 3-Clause License.
+from cclib.attribute_parsers import utils
+from cclib.attribute_parsers.aooverlaps import aooverlaps
+from cclib.attribute_parsers.atombasis import atombasis
+from cclib.attribute_parsers.atomcharges import atomcharges
+from cclib.attribute_parsers.atomcoords import atomcoords
+from cclib.attribute_parsers.atommasses import atommasses
+from cclib.attribute_parsers.atomnos import atomnos
+from cclib.attribute_parsers.base_parser import base_parser
+from cclib.attribute_parsers.charge import charge
+from cclib.attribute_parsers.coreelectrons import coreelectrons
+from cclib.attribute_parsers.data import ccData
+from cclib.attribute_parsers.gbasis import gbasis
+from cclib.attribute_parsers.mocoeffs import mocoeffs
+from cclib.attribute_parsers.moenergies import moenergies
+from cclib.attribute_parsers.mosyms import mosyms
+from cclib.attribute_parsers.mult import mult
+from cclib.attribute_parsers.natom import natom
+from cclib.attribute_parsers.nbasis import nbasis
+from cclib.attribute_parsers.nmo import nmo
+from cclib.attribute_parsers.scfenergies import scfenergies
+from cclib.attribute_parsers.scftargets import scftargets
+from cclib.attribute_parsers.scfvalues import scfvalues

cclib-2.0a1/cclib/attribute_parsers/aooverlaps.py

@@ -0,0 +1,57 @@
+# Copyright (c) 2024, the cclib development team
+#
+# This file is part of cclib (http://cclib.github.io) and is distributed under
+# the terms of the BSD 3-Clause License.
+from typing import Optional
+
+from cclib.attribute_parsers import utils
+from cclib.attribute_parsers.base_parser import base_parser
+
+import numpy as np
+
+
+class aooverlaps(base_parser):
+    """
+    Docstring? Units?
+    """
+
+    known_codes = ["gaussian"]
+
+    @staticmethod
+    def gaussian(file_handler, ccdata) -> Optional[dict]:
+        # Molecular orbital overlap matrix.
+        # Has to deal with lines such as:
+        #   *** Overlap ***
+        #   ****** Overlap ******
+        # Note that Gaussian sometimes drops basis functions,
+        #  causing the overlap matrix as parsed below to not be
+        line = file_handler.last_line
+        if line[1:4] == "***" and (line[5:12] == "Overlap" or line[8:15] == "Overlap"):
+            # Ensure that this is the main calc and not a fragment
+            # if ccdata.counterpoise != 0:
+            #   return
+            constructed_aooverlaps = np.zeros((ccdata.nbasis, ccdata.nbasis), "d")
+            # Overlap integrals for basis fn#1 are in aooverlaps[0]
+            base = 0
+            colmNames = file_handler.virtual_next()
+            while base < ccdata.nbasis:
+                for i in range(ccdata.nbasis - base):  # Fewer lines this time
+                    line = file_handler.virtual_next()
+                    parts = line.split()
+                    for j in range(len(parts) - 1):  # Some lines are longer than others
+                        k = float(parts[j + 1].replace("D", "E"))
+                        constructed_aooverlaps[base + j, i + base] = k
+                        constructed_aooverlaps[i + base, base + j] = k
+                base += 5
+                colmNames = file_handler.virtual_next()
+            return {aooverlaps.__name__: constructed_aooverlaps}
+
+    @staticmethod
+    def parse(file_handler, program: str, ccdata) -> Optional[dict]:
+        constructed_data = None
+        if program in aooverlaps.known_codes:
+            file_handler.virtual_set()
+            program_parser = getattr(aooverlaps, program)
+            constructed_data = program_parser(file_handler, ccdata)
+            file_handler.virtual_reset()
+        return constructed_data

cclib-2.0a1/cclib/attribute_parsers/atombasis.py

@@ -0,0 +1,176 @@
+# Copyright (c) 2024, the cclib development team
+#
+# This file is part of cclib (http://cclib.github.io) and is distributed under
+# the terms of the BSD 3-Clause License.
+import re
+from typing import Optional
+
+from cclib.attribute_parsers import utils
+from cclib.attribute_parsers.base_parser import base_parser
+
+import numpy as np
+
+
+class atombasis(base_parser):
+    """
+    Docstring? Units?
+    """
+
+    known_codes = ["gaussian", "psi4", "qchem"]
+
+    @staticmethod
+    def gaussian(file_handler, ccdata) -> Optional[dict]:
+        # ccdata is "const" here and we don't need to modify it yet. The driver will set the attr
+        dependency_list = ["nmo", "nbasis"]
+        line = file_handler.last_line
+        constructed_data = None
+        if (
+            line[5:35] == "Molecular Orbital Coefficients"
+            or line[5:41] == "Alpha Molecular Orbital Coefficients"
+            or line[5:40] == "Beta Molecular Orbital Coefficients"
+        ):
+            constructed_atombasis = []
+            if not base_parser.check_dependencies(dependency_list, ccdata, "atombasis"):
+                return None
+            beta = False
+            if line[5:40] == "Beta Molecular Orbital Coefficients":
+                beta = True
+            base = 0
+            curr_atombasis = []
+            for base in range(0, ccdata.nmo, 5):
+                colNames = file_handler.virtual_next()
+                symmetries = file_handler.virtual_next()
+                eigenvalues = file_handler.virtual_next()
+                for i in range(ccdata.nbasis):
+                    line = file_handler.virtual_next()
+                    if i == 0:
+                        # Find location of the start of the basis function name
+                        start_of_basis_fn_name = line.find(line.split()[3]) - 1
+                    if base == 0 and not beta:  # Just do this the first time 'round
+                        parts = line[:start_of_basis_fn_name].split()
+                        if len(parts) > 1:  # New atom
+                            if i > 0:
+                                constructed_atombasis.append(curr_atombasis)
+                            curr_atombasis = []
+                        curr_atombasis.append(i)
+                if base == 0 and not beta:  # Just do this the first time 'round
+                    constructed_atombasis.append(curr_atombasis)
+            constructed_data = {atombasis.__name__: constructed_atombasis}
+            return constructed_data
+
+        # Natural orbital coefficients (nocoeffs) and occupation numbers (nooccnos),
+        # which are respectively define the eigenvectors and eigenvalues of the
+        # diagonalized one-electron density matrix. These orbitals are formed after
+        # configuration interaction (CI) calculations, but not only. Similarly to mocoeffs,
+        # we can parse and check aonames and atombasis here.
+        #
+        #     Natural Orbital Coefficients:
+        #                           1         2         3         4         5
+        #     Eigenvalues --     2.01580   2.00363   2.00000   2.00000   1.00000
+        #   1 1   O  1S          0.00000  -0.15731  -0.28062   0.97330   0.00000
+        #   2        2S          0.00000   0.75440   0.57746   0.07245   0.00000
+        # ...
+        #
+        def natural_orbital_single_spin_parsing(fh):
+            coeffs = np.zeros((ccdata.nmo, ccdata.nbasis), "d")
+            this_atombasis = []
+            for base in range(0, ccdata.nmo, 5):
+                colmNames = fh.virtual_next()
+                eigenvalues = fh.virtual_next()
+                for i in range(ccdata.nbasis):
+                    line = fh.virtual_next()
+                    # Just do this the first time 'round.
+                    if base == 0:
+                        parts = line[:12].split()
+                        # New atom.
+                        if len(parts) > 1:
+                            if i > 0:
+                                this_atombasis.append(basisonatom)
+                            basisonatom = []
+                        orbital = line[11:20].strip()
+                        basisonatom.append(i)
+                    part = line[21:].replace("D", "E").rstrip()
+                    temp = []
+                    for j in range(0, len(part), 10):
+                        temp.append(float(part[j : j + 10]))
+                # Do the last update of atombasis.
+                if base == 0:
+                    this_atombasis.append(basisonatom)
+            return this_atombasis
+
+        if line[5:33] == "Natural Orbital Coefficients":
+            parsed_atombasis = natural_orbital_single_spin_parsing(file_handler)
+            return {atombasis.__name__: parsed_atombasis}
+
+        if line[5:39] == "Alpha Natural Orbital Coefficients":
+            parsed_atombasis = natural_orbital_single_spin_parsing(file_handler)
+            print(atombasis.__name__)
+            return {atombasis.__name__: parsed_atombasis}
+        if line[5:38] == "Beta Natural Orbital Coefficients":
+            parsed_atombasis = natural_orbital_single_spin_parsing(file_handler)
+            return {atombasis.__name__: parsed_atombasis}
+
+        return None
+
+    @staticmethod
+    def psi4(file_handler, ccdata) -> Optional[dict]:
+        dependency_list = ["nmo", "nbasis"]
+        if getattr(ccdata, "atombasis") == None:
+            line = file_handler.last_line
+            if line.strip() == "-Contraction Scheme:":
+                file_handler.skip_lines(["headers", "d"], virtual=True)
+                line = file_handler.virtual_next()
+                constructed_atombasis = []
+                atombasis_pos = 0
+                while line.strip():
+                    ao_count = 0
+                    shells = line.split("//")[1].split()
+                    for s in shells:
+                        count, basistype = s
+                        multiplier = 3 * (basistype == "p") or 1
+                        ao_count += multiplier * int(count)
+                    if len(constructed_atombasis) > 0:
+                        atombasis_pos = constructed_atombasis[-1][-1] + 1
+                    constructed_atombasis.append(
+                        list(range(atombasis_pos, atombasis_pos + ao_count))
+                    )
+                    line = file_handler.virtual_next()
+                constructed_data = {atombasis.__name__: constructed_atombasis}
+                return constructed_data
+        return None
+
+    @staticmethod
+    def qchem(file_handler, ccdata) -> Optional[dict]:
+        # This block comes from `print_orbitals = true/{int}`. Less
+        # precision than `scf_final_print >= 2` for `mocoeffs`, but
+        # important for `aonames` and `atombasis`.
+        alpha_mo_coefficient_headers = []
+        qchem_re_atomindex = re.compile(r"(\d+)_")
+
+        dependency_list = ["aonames", "atomnos", "nbasis", "natom"]
+        line = file_handler.last_line
+        if any(header in line for header in alpha_mo_coefficient_headers):
+            if base_parser.check_dependencies(dependency_list, ccdata, "atombasis"):
+                constructed_atombasis = []
+                for n in range(ccdata.natom):
+                    constructed_atombasis.append([])
+                # Go back through `aonames` to create `atombasis`.
+                assert len(ccdata.aonames) == ccdata.nbasis
+                for aoindex, aoname in enumerate(ccdata.aonames):
+                    atomindex = int(qchem_re_atomindex.search(aoname).groups()[0]) - 1
+                    constructed_atombasis.atombasis[atomindex].append(aoindex)
+                assert len(self.atombasis) == len(self.atomnos)
+                if not hasattr(ccdata, "atombasis"):
+                    constructed_data = {atombasis.__name__: constructed_atombasis}
+                    return constructed_data
+        return None
+
+    @staticmethod
+    def parse(file_handler, program: str, ccdata) -> Optional[dict]:
+        constructed_data = None
+        if program in atombasis.known_codes:
+            file_handler.virtual_set()
+            program_parser = getattr(atombasis, program)
+            constructed_data = program_parser(file_handler, ccdata)
+            file_handler.virtual_reset()
+        return constructed_data

cclib-2.0a1/cclib/attribute_parsers/atomcharges.py

@@ -0,0 +1,270 @@
+# Copyright (c) 2024, the cclib development team
+#
+# This file is part of cclib (http://cclib.github.io) and is distributed under
+# the terms of the BSD 3-Clause License.
+from typing import Optional
+
+from cclib.attribute_parsers import utils
+from cclib.attribute_parsers.base_parser import base_parser
+
+import numpy as np
+
+
+def orca_parse_charge_section(file_handler, chargestype):
+    """Parse a charge section
+
+    Parameters
+    ----------
+    file_handler :
+      generates lines
+    chargestype : str
+      what type of charge we're dealing with, must be one of
+      'mulliken', 'lowdin', 'chelpg' or 'hirshfeld'
+    """
+    atomcharges = dict()
+    atomspins = dict()
+    line = file_handler.last_line
+    has_spins = "AND SPIN POPULATIONS" in line
+
+    file_handler.skip_lines(["dashes"], virtual=True)
+
+    # depending on chargestype, decide when to stop parsing lines
+    # start, stop - indices for slicing lines and grabbing values
+    # should_stop: when to stop parsing
+    if chargestype == "mulliken":
+        should_stop = lambda x: x.startswith("Sum of atomic charges")
+        start, stop = 8, 20
+    elif chargestype == "lowdin":
+        should_stop = lambda x: not bool(x.strip())
+        start, stop = 8, 20
+    elif chargestype == "chelpg":
+        should_stop = lambda x: x.startswith("---")
+        start, stop = 11, 26
+    elif chargestype == "hirshfeld":
+        should_stop = lambda x: not bool(x.strip())
+        start, stop = 9, 18
+        file_handler.skip_lines(
+            ["d", "b", "Total integrated alpha density", "Total integrated beta density", "header"],
+            virtual=True,
+        )
+    else:
+        raise RuntimeError(f"unknown chargestype: {chargestype}")
+
+    charges = []
+    spins = []
+
+    line = file_handler.virtual_next()
+    while not should_stop(line):
+        # Don't add point charges or embedding potentials.
+        if "Q :" not in line:
+            charges.append(float(line[start:stop]))
+            if has_spins:
+                spins.append(float(line[stop:]))
+        line = file_handler.virtual_next()
+
+    atomcharges[chargestype] = charges
+    if has_spins:
+        atomspins[chargestype] = spins
+    return atomcharges, atomspins
+
+
+def qchem_parse_charge_section(file_handler, chargetype):
+    """Parse the population analysis charge block."""
+    atomcharges = dict()
+    atomspins = dict()
+    charges = []
+    spins = []
+    line = file_handler.last_line
+    file_handler.skip_lines(["blank"], virtual=True)
+    line = file_handler.virtual_next()
+    has_spins = False
+    if "Spin" in line:
+        has_spins = True
+    file_handler.skip_lines(["dashes"], virtual=True)
+    line = file_handler.virtual_next()
+
+    while list(set(line.strip())) != ["-"]:
+        elements = line.split()
+        charge = utils.float(elements[2])
+        charges.append(charge)
+        if has_spins:
+            spin = utils.float(elements[3])
+            spins.append(spin)
+        line = file_handler.virtual_next()
+
+    atomcharges[chargetype] = charges
+    if has_spins:
+        atomspins[chargestype] = spins
+    return atomcharges, atomspins
+
+
+class atomcharges(base_parser):
+    """
+    Docstring? Units?
+    """
+
+    known_codes = ["ORCA", "NBO", "qchem"]
+
+    @staticmethod
+    def ORCA(file_handler, ccdata) -> Optional[dict]:
+        # ccdata is "const" here and we don't need to modify it yet. The driver will set the attr
+        line = file_handler.last_line
+        constructed_charge_data = None
+        constructed_spin_data = None
+
+        # ORCA will print atomic charges along with the spin populations,
+        #   so care must be taken about choosing the proper column.
+        # Population analyses are performed usually only at the end
+        #   of a geometry optimization or other run, so we want to
+        #   leave just the final atom charges.
+        # Here is an example for Mulliken charges:
+        # --------------------------------------------
+        # MULLIKEN ATOMIC CHARGES AND SPIN POPULATIONS
+        # --------------------------------------------
+        #    0 H :    0.126447    0.002622
+        #    1 C :   -0.613018   -0.029484
+        #    2 H :    0.189146    0.015452
+        #    3 H :    0.320041    0.037434
+        # ...
+        # Sum of atomic charges         :   -0.0000000
+        # Sum of atomic spin populations:    1.0000000
+        if line[:23] == "MULLIKEN ATOMIC CHARGES":
+            constructed_charge_data, constructed_spin_data = orca_parse_charge_section(
+                file_handler, "mulliken"
+            )
+        # Things are the same for Lowdin populations, except that the sums
+        #   are not printed (there is a blank line at the end).
+        if line[:22] == "LOEWDIN ATOMIC CHARGES":
+            constructed_charge_data, constructed_spin_data = orca_parse_charge_section(
+                file_handler, "lowdin"
+            )
+        # ------------------
+        # HIRSHFELD ANALYSIS
+        # ------------------
+        #
+        # Total integrated alpha density =    142.999988722
+        # Total integrated beta density  =    142.999988722
+        #
+        #   ATOM     CHARGE      SPIN
+        #    0 H    0.157924    0.000000
+        #    1 O   -0.209542    0.000000
+        #    2 C    0.030659    0.000000
+        # ...
+        #   TOTAL  -0.999977    0.000000
+        if line[:18] == "HIRSHFELD ANALYSIS":
+            constructed_charge_data, constructed_spin_data = orca_parse_charge_section(
+                file_handler, "hirshfeld"
+            )
+        # CHELPG Charges
+        # --------------------------------
+        #  0   C   :       0.363939
+        #  1   H   :       0.025695
+        # ...
+        # --------------------------------
+        # Total charge:    -0.000000
+        # --------------------------------
+        if line.startswith("CHELPG Charges"):
+            constructed_charge_data, constructed_spin_data = orca_parse_charge_section(
+                file_handler, "chelpg"
+            )
+        # TODO handle atomspins
+        constructed_data = dict()
+        if constructed_charge_data:
+            if ccdata.atomcharges:
+                constructed_data["atomcharges"] = {**ccdata.atomcharges, **constructed_charge_data}
+            else:
+                constructed_data["atomcharges"] = {**constructed_charge_data}
+        if constructed_spin_data:
+            if ccdata.atomspins:
+                constructed_data["atomspins"] = {**ccdata.atomspins, **constructed_spin_data}
+            else:
+                constructed_data["atomspins"] = {**constructed_spin_data}
+        if constructed_data:
+            return constructed_data
+        return None
+
+    @staticmethod
+    def NBO(file_handler, ccdata) -> Optional[dict]:
+        atomcharges = dict()
+        # ccdata is "const" here and we don't need to modify it yet. The driver will set the attr
+        charges = None
+        line = file_handler.last_line
+        if "  Atom No    Charge" in line:
+            parsed_charges = []
+            line = file_handler.virtual_next()
+            line = file_handler.virtual_next()
+            while "==============" not in line:
+                population_analysis = line.split()
+                atom = population_analysis[0]
+                no = int(population_analysis[1])
+                natural_charge = float(population_analysis[2])
+                core = float(population_analysis[3])
+                valence = float(population_analysis[4])
+                rydberg = float(population_analysis[5])
+                total = float(population_analysis[6])
+                parsed_charges.append(natural_charge)
+                line = file_handler.virtual_next()
+            atomcharges["nbo"] = parsed_charges
+        constructed_data = dict()
+        if atomcharges != dict():
+            if ccdata.atomcharges:
+                constructed_data["atomcharges"] = {**ccdata.atomcharges, **atomcharges}
+            else:
+                constructed_data["atomcharges"] = {**atomcharges}
+            return constructed_data
+        return None
+
+    @staticmethod
+    def qchem(file_handler, ccdata) -> Optional[dict]:
+        line = file_handler.last_line
+        constructed_charge_data = None
+        constructed_spin_data = None
+        constructed_data = dict()
+        if "Ground-State Mulliken Net Atomic Charges" in line:
+            constructed_charge_data, constructed_spin_data = qchem_parse_charge_section(
+                inputfile, "mulliken"
+            )
+        if "Hirshfeld Atomic Charges" in line:
+            constructed_charge_data, constructed_spin_data = qchem_parse_charge_section(
+                inputfile, "hirshfeld"
+            )
+        if "Charge Model 5" in line:
+            constructed_charge_data, constructed_spin_data = qchem_parse_charge_section(
+                inputfile, "cm5"
+            )
+        if "Ground-State ChElPG Net Atomic Charges" in line:
+            constructed_charge_data, constructed_spin_data = qchem_parse_charge_section(
+                inputfile, "chelpg"
+            )
+        if "Merz-Kollman ESP Net Atomic Charges" in line:
+            constructed_charge_data, constructed_spin_data = qchem_parse_charge_section(
+                inputfile, "esp"
+            )
+        if "Merz-Kollman RESP Net Atomic Charges" in line:
+            constructed_charge_data, constructed_spin_data = qchem_parse_charge_section(
+                inputfile, "resp"
+            )
+        constructed_data = dict()
+        if constructed_charge_data:
+            if ccdata.atomcharges:
+                constructed_data["atomcharges"] = {**ccdata.atomcharges, **constructed_charge_data}
+            else:
+                constructed_data["atomcharges"] = {**constructed_charge_data}
+        if constructed_spin_data:
+            if ccdata.atomspins:
+                constructed_data["atomspins"] = {**ccdata.atomspins, **constructed_spin_data}
+            else:
+                constructed_data["atomspins"] = {**constructed_spin_data}
+        if constructed_data:
+            return constructed_data
+        return None
+
+    @staticmethod
+    def parse(file_handler, program: str, ccdata) -> Optional[dict]:
+        constructed_data = None
+        if program in atomcharges.known_codes:
+            file_handler.virtual_set()
+            program_parser = getattr(atomcharges, program)
+            constructed_data = program_parser(file_handler, ccdata)
+            file_handler.virtual_reset()
+        return constructed_data