digichem-core 6.0.0rc1__py3-none-any.whl

digichem/result/tdm.py

@@ -0,0 +1,267 @@
+import itertools
+
+from digichem.exception.base import Result_unavailable_error
+from digichem.result.dipole_moment import Electric_dipole_moment_mixin, Dipole_moment_ABC, Magnetic_dipole_moment_mixin
+from digichem.result.base import Result_object
+
+
+class Transition_dipole_moment_ABC(Dipole_moment_ABC):
+    """
+    ABC for electric and magnetic transition dipole moments.
+    """
+    
+    def __init__(self, state_level, *args, **kwargs):
+        """
+        Electric_transition_dipole_moment constructor.
+        
+        :param state: The excited state level this dipole transitions to.
+        """
+        super().__init__(*args, **kwargs)
+        
+        # An int describing the excited state we belong to. This is always available.
+        self.state_level = state_level
+        
+        # The excited state object that we belong to. This may be None. We can't set this here because then both the Excited_state and Transition_dipole_moment constructors would depend on each other.
+        self.excited_state = None
+        
+        # Save a name describing which dipole we are (permanent vs transition etc).
+        self.dipole_type = "transition"
+        
+    @classmethod
+    def from_dump(self, data, result_set, options):
+        """
+        Get a list of instances of this class from its dumped representation.
+        
+        :param data: The data to parse.
+        :param result_set: The partially constructed result set which is being populated.
+        """
+        return self(
+            data['state_level'],
+            (data['origin']['x']['value'], data['origin']['y']['value'], data['origin']['z']['value']),
+            (data['vector']['x']['value'], data['vector']['y']['value'], data['vector']['z']['value']),
+            atoms = result_set.atoms
+            )
+        
+    def dump(self, digichem_options):
+        """
+        Get a representation of this result object in primitive format.
+        """
+        data = {'state_level': self.state_level}
+        data.update(super().dump(digichem_options))
+        return data
+    
+    @property
+    def name(self):
+        """
+        Name that describes this dipole moment.
+        """
+        return "{} TDM".format(self.excited_state.state_symbol)
+    
+    def set_excited_state(self, excited_state):
+        """
+        Set the excited state object that we belong to.
+        """
+        # Not sure what we should do if the given excited_state has a different level to what we expect.
+        if excited_state.level != self.state_level:
+            pass
+        self.excited_state = excited_state
+        
+        
+class Electric_transition_dipole_moment(Transition_dipole_moment_ABC, Electric_dipole_moment_mixin):
+    """
+    Class that represents an electric transition dipole moment.
+    """
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.electromagnetic_type = "electric"
+        
+    @classmethod
+    def list_from_parser(self, parser):
+        """
+        Get a list of TDMs from an output file parser.
+        
+        :param parser: An output file parser.
+        :return: A list of TDM objects. An empty list will be returned if no TDM data is available.
+        """
+        try:
+            return [
+                self(state_level = index +1,
+                origin_coords = (0,0,0),
+                vector_coords = (parser.au_to_debye(tdm[0]), parser.au_to_debye(tdm[1]), parser.au_to_debye(tdm[2])),
+                atoms = parser.results.atoms) for index, tdm in enumerate(parser.data.etdips)]
+        except AttributeError:
+            return []
+
+
+class Magnetic_transition_dipole_moment(Transition_dipole_moment_ABC, Magnetic_dipole_moment_mixin):
+    """
+    Class that represents a magnetic transition dipole moment.
+    
+    Unlike electric dipole moments, the units here are in a.u. (0.5 bohr magnetons).
+    """
+        
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.electromagnetic_type = "magnetic"
+    
+    @classmethod
+    def list_from_parser(self, parser):
+        """
+        Get a list of TDMs from an output file parser.
+        
+        :param parser: An output file parser.
+        :return: A list of TDM objects. An empty list will be returned if no TDM data is available.
+        """
+        try:
+            return [
+                self(state_level = index +1,
+                origin_coords = (0,0,0),
+                vector_coords = tdm,
+                atoms = parser.results.atoms) for index, tdm in enumerate(parser.data.etmagdips)]
+        except AttributeError:
+            return []
+
+
+class Transition_dipole_moment(Result_object):
+    """
+    A compound class that represents both the electric and magnetic components of a transition dipole moment.
+    
+    This class can also be used in most places where an electric TDM is expected, as it will pass references to TEDM attributes to the actual TEDM class.
+    If the object has only a TMDM and no TEDM, references will instead be passed to the TMDM.
+    """
+    
+    def __init__(self, electric = None, magnetic = None):
+        """
+        Constructor for TDM.
+        
+        Either or both of the substituent TDM can be None.
+        """
+        self.electric = electric
+        self.magnetic = magnetic
+        self.electromagnetic_type = "electromagnetic"
+    
+    def set_excited_state(self, excited_state):
+        """
+        Set the excited state object that we belong to.
+        """
+        if self.electric is not None:
+            self.electric.set_excited_state(excited_state)
+        
+        if self.magnetic is not None:
+            self.magnetic.set_excited_state(excited_state)
+        
+    @classmethod
+    def from_parser(self, parser):
+        return self.list_from_parser(parser)
+    
+    @classmethod
+    def list_from_parser(self, parser):
+        """
+        Get a list of Transition_dipole_moment from an output file parser.
+        
+        :param parser: An output file parser.
+        :return: A list of Transition_dipole_moment objects. An empty list will be returned if no TDM data is available.
+        """
+        electric = Electric_transition_dipole_moment.list_from_parser(parser)
+        magnetic = Magnetic_transition_dipole_moment.list_from_parser(parser)
+        
+        return [self(electric_part, magnetic_part) for electric_part, magnetic_part in itertools.zip_longest(electric, magnetic)]
+        
+    def __getattr__(self, name):
+        # This check prevents infinite recursion when pickling, and is probably a sensible check anyway...
+        if name != "electric" and name != "magnetic":
+            try:
+                if self.electric is not None:
+                    return getattr(self.electric, name)
+                else:
+                    return getattr(self.magnetic, name)
+            except AttributeError as e:
+                raise AttributeError(name) from e
+        else:
+            raise AttributeError(name)
+        
+    @classmethod
+    def list_from_dump(self, data, result_set, options):
+        """
+        Get a list of instances of this class from its dumped representation.
+        
+        :param data: The data to parse.
+        :param result_set: The partially constructed result set which is being populated.
+        """
+        # This constructor for tdms is a bit odd in that it does not work anything like the other from_dump() methods.
+        # In the dumped format, tdms are not stored as their own list (but rather as a sub dict of the relevant excited state),
+        # but in order to avoid recursive imports, a list of tdms does need to be created when excited states are loaded again.
+        # This being the case, 'data' here is actually a list of excited states, not tdms...
+        return [self.from_dump(excited_state['tdm'], result_set, options) for excited_state in data]
+        
+    @classmethod
+    def from_dump(self, data, result_set, options):
+        """
+        Get a list of instances of this class from its dumped representation.
+        
+        :param data: The data to parse.
+        :param result_set: The partially constructed result set which is being populated.
+        """
+        if data is None:
+            return None
+    
+        # Build the individual parts.
+        if data['electric'] is not None:
+            electric = Electric_transition_dipole_moment.from_dump(data['electric'], result_set, options)
+        
+        else:
+            electric = None
+        
+        if data['magnetic'] is not None:
+            magnetic = Magnetic_transition_dipole_moment.from_dump(data['magnetic'], result_set, options)
+        
+        else:
+            magnetic = None
+        
+        return self(electric = electric, magnetic = magnetic)
+        
+    def dump(self, digichem_options):
+        """
+        Get a representation of this result object in primitive format.
+        """
+        return {
+            "electric": self.electric.dump(digichem_options) if self.electric is not None else None,
+            "magnetic": self.magnetic.dump(digichem_options) if self.magnetic is not None else None,
+            "angle": {
+                "value": float(self.angle().angle) if self.electric is not None and self.magnetic is not None else None,
+                "units": self.angle().units if self.electric is not None and self.magnetic is not None else None,
+            },
+            "cos_angle": float(self.cos_angle()) if self.electric is not None and self.magnetic is not None else None,
+            "dissymmetry_factor": float(self.g_value) if self.safe_get('g_value') is not None else None
+        }
+            
+    
+    def angle(self, cgs = True):
+        """
+        Return the angle between the electric and magnetic components of this transition dipole moment.
+        """
+        return self.electric.angle(self.magnetic, cgs)
+    
+    def cos_angle(self, cgs = True):
+        """
+        Return the cos of the angle between the electric and magnetic components of this transition dipole moment.
+        """
+        return self.electric.cos_angle(self.magnetic, cgs)
+    
+    @property
+    def g_value(self):
+        """
+        Return the 'g value'; the dissymmerty factor of this transition dipole moment.
+        
+        This calculation is based on J. Phys. Chem. Lett. 2021, 12, 1, 686–695.
+        """
+        try:
+            return (4 * self.electric.gaussian_cgs * self.magnetic.gaussian_cgs * self.cos_angle(True)) / (self.electric.gaussian_cgs **2 + self.magnetic.gaussian_cgs **2)
+        
+        except (FloatingPointError, ZeroDivisionError):
+            return 0
+        
+        except AttributeError:
+            raise Result_unavailable_error("g_value", "transition electric or transition magnetic dipole moment is not available") from None
+

digichem/result/vibration.py

@@ -0,0 +1,167 @@
+# General imports.
+from itertools import zip_longest
+import warnings
+
+# Digichem imports.
+from digichem.result import Result_container
+from digichem.result import Result_object
+from digichem.result import Floatable_mixin, Unmergeable_container_mixin
+
+# Hidden.
+#from digichem.result.spectroscopy import Spectroscopy_graph
+
+
+class Vibrations_list(Result_container, Unmergeable_container_mixin):
+    """
+    Class for representing a group of molecular vibrations.
+    """
+    
+    MERGE_WARNING = "Attempting to merge lists of vibrations that are not identical; non-equivalent vibrations will be ignored"
+        
+    @property
+    def negative_frequencies(self):
+        """
+        Get a Vibrations_list object of the vibrations in this list that have negative frequencies (they are imaginary).
+        """
+        warnings.warn("negative_frequencies is deprecated, use negative instead")
+        return self.negative
+    
+    @property
+    def negative(self):
+        """
+        Get a Vibrations_list object of the vibrations in this list that have negative frequencies (they are imaginary).
+        """
+        return type(self)([vibration for vibration in self if vibration.frequency < 0])
+    
+    @classmethod
+    def from_parser(self, parser):
+        """
+        Get an Vibrations_list object from an output file parser.
+        
+        :param parser: An output file parser.
+        :return: A Vibrations_list object. The list will be empty if no vibration frequency data is available.
+        """
+        return self(Vibration.list_from_parser(parser))
+    
+    def generate_for_dump(self):
+        """
+        Method used to get a dictionary used to generate on-demand values for dumping.
+        
+        This functionality is useful for hiding expense properties from the normal dump process, while still exposing them when specifically requested.
+        
+        Each key in the returned dict is the name of a dumpable item, each value is a function to call with digichem_options as its only param.
+        """
+        return {"spectrum": self.generate_spectrum}
+    
+    def generate_spectrum(self, digichem_options):
+        """
+        Abstract function that is called to generate an on-demand value for dumping.
+        
+        This functionality is useful for hiding expense properties from the normal dump process, while still exposing them when specifically requested.
+        
+        :param key: The key being requested.
+        :param digichem_options: Digichem options being used to dump.
+        """
+        from digichem.result.spectroscopy import Spectroscopy_graph
+        
+        
+        spectrum = Spectroscopy_graph.from_vibrations(self, digichem_options['IR_spectrum']['fwhm'], digichem_options['IR_spectrum']['gaussian_resolution'], digichem_options['IR_spectrum']['gaussian_cutoff'])
+        
+        try:
+            spectrum_data = spectrum.plot_cumulative_gaussian()
+            
+            spectrum_data = [{"x":{"value": float(x), "units": "c m^-1"}, "y": {"value":float(y), "units": "km mol^-1"}} for x,y in spectrum_data]
+            spectrum_peaks = [{"x":{"value": float(x), "units": "c m^-1"}, "y": {"value":float(y), "units": "km mol^-1"}} for x, y in spectrum.peaks()]
+        
+        except Exception:
+            spectrum_data = []
+            spectrum_peaks = []
+        
+        return {
+            "values": spectrum_data,
+            "peaks": spectrum_peaks
+        }
+    
+    def dump(self, digichem_options):
+        dump_dict = {
+            "num_vibrations": len(self),
+            "num_negative": len(self.negative),
+            "values": super().dump(digichem_options),
+        }
+        return dump_dict
+
+    @classmethod
+    def from_dump(self, data, result_set, options):
+        """
+        Get an instance of this class from its dumped representation.
+        
+        :param data: The data to parse.
+        :param result_set: The partially constructed result set which is being populated.
+        """
+        return self(Vibration.list_from_dump(data['values'], result_set, options))
+
+
+class Vibration(Result_object, Floatable_mixin):
+    """
+    Class for representing vibrational frequencies.
+    """
+    
+    def __init__(self, level, frequency, intensity, symmetry = None):
+        """
+        Vibration object constructor.
+        
+        :param level: The numerical index of the vibration.
+        :param frequency: Frequency of the vibration (cm-1).
+        :param intensity: Intensity of the vibration in IR (km mol-1)
+        :param symmetry: Symmetry term of the vibration (string).
+        """
+        self.level = level
+        self.symmetry = symmetry
+        self.frequency = frequency
+        self.intensity = intensity
+        
+    def __float__(self):
+        """
+        A float representation of this object.
+        """
+        return float(self.frequency)
+    
+    def dump(self, digichem_options):
+        """
+        Get a representation of this result object in primitive format.
+        """
+        return {
+            "index": self.level,
+            "frequency": {
+                "value": float(self.frequency),
+                "units": "c m^-1",
+            },
+            "intensity": {
+                "value": float(self.intensity),
+                "units": "km mol^-1"
+            },
+            "symmetry": self.symmetry
+        }
+        
+    @classmethod
+    def list_from_dump(self, data, result_set, options):
+        """
+        Get a list of instances of this class from its dumped representation.
+        
+        :param data: The data to parse.
+        :param result_set: The partially constructed result set which is being populated.
+        """
+        return [self(vib_dict['index'], vib_dict['frequency']['value'], vib_dict['intensity']['value'], vib_dict['symmetry']) for vib_dict in data]
+        
+    @classmethod
+    def list_from_parser(self, parser):
+        """
+        Create a list of Vibration objects from an output file parser.
+        
+        :param parser: An output file parser.
+        :return: A list of Vibration objects. The list will be empty if no frequency data is available.
+        """
+        try:
+            return [self(index+1, frequency, intensity, symmetry) for index, (symmetry, frequency, intensity) in enumerate(zip_longest(getattr(parser.data, 'vibsyms', []), parser.data.vibfreqs, parser.data.vibirs, fillvalue = None))]
+        except AttributeError:
+            return []

digichem/test/__init__.py

@@ -0,0 +1,6 @@
+"""Unit tests for digichem"""
+
+from pathlib import Path
+
+import digichem.log
+digichem.log.set_logging_level("DEBUG")

digichem/test/conftest.py

@@ -0,0 +1,4 @@
+import numpy
+
+# Set numpy errors (not sure why this isn't the default...)
+numpy.seterr(invalid = 'raise', divide = 'raise')

digichem/test/test_basis.py

@@ -0,0 +1,71 @@
+"""Tests for handling basis sets from BSE."""
+import pytest
+
+from digichem.basis import BSE_basis_set
+
+def test_basis():
+    """Can we load a simple basis set?"""
+    basis = BSE_basis_set({
+        "STO-3G":"all"
+    })
+    basis.to_format()
+
+def test_ecps():
+    """Can we load a simple basis set eith ecps?"""
+    basis = BSE_basis_set({
+        "LANL2DZ":"all"
+    })
+    assert basis.has_ECPs()
+
+@pytest.mark.parametrize("set", [
+    {"STO-3G":"all"},
+    {"STO-3G":"C"},
+    {"STO-3G":"C,H"},
+    {"STO-3G":"H","def2-SVP":"C"}
+], ids = ["all", "C", "C,H", "mixed"])
+def test_meta(set):
+    """Can we handle basis set metadata correctly?"""
+    basis = BSE_basis_set(set)
+    str(basis)
+
+@pytest.mark.parametrize("filter, number", [
+    ("C", 1),
+    ("C,H", 2),
+    (("C", "H"), 2)
+], ids = ["C", "C,H", list])
+def test_filter(filter, number):
+    """Can we return only parts of a basis set?"""
+    basis = BSE_basis_set({
+        "STO-3G":"all"
+    })
+    output = basis.to_format("gaussian94", filter)
+    assert output.count("****") == number
+
+def test_mixed_basis():
+    """Can we combine multiple basis sets?"""
+    basis = BSE_basis_set({
+        "STO-3G":"H",
+        "def2-SVP" : "C"
+    })
+
+    basis.to_format("gaussian94")
+
+def test_mixed_basis_filter():
+    """Can we combine multiple basis sets?"""
+    basis = BSE_basis_set({
+        "STO-3G":"H",
+        "def2-SVP" : "C"
+    })
+
+    output = basis.to_format("gaussian94", "C,H")
+    assert output.count("****") == 2
+
+def test_wrong_basis():
+    """Check a non-existent basis set is flagged"""
+    basis = BSE_basis_set({
+        "STO-3G":"H",
+        "defs2-SVP" : "C"
+    })
+
+    with pytest.raises(KeyError):
+        basis.to_format("gaussian94")

digichem/test/test_calculate.py

@@ -0,0 +1,30 @@
+"""Tests for calculated results"""
+
+import pytest
+from pathlib import Path
+import shutil
+
+from digichem.test.util import data_directory, digichem_options
+from digichem.parse.util import parse_calculation
+
+
+@pytest.fixture(scope="module")
+def formaldehyde_SOC_result(digichem_options):
+    return parse_calculation(Path(data_directory(), "Formaldehyde/Gaussian 09 Excited States TD-DFT 4 Singlets 4 Triplets B3LYP Gas Phase TZVP.tar.gz"), options = digichem_options)
+
+@pytest.mark.skipif(not shutil.which("rwfdump"), reason="No rwfdump available")
+@pytest.mark.parametrize("result_set, singlet, triplet, SOC", [
+    # These SOC values are taken from the original paper J. Chem. Theory Comput. 2017, 13, 515−524 for PySOC,
+    # the program Silioc uses to calculate SOC. We are limited in terms of accuracy by the number of decimals
+    # (0) that they report...
+        (pytest.lazy_fixture("formaldehyde_SOC_result"), "S(1)", "T(1)", 0.0),
+        (pytest.lazy_fixture("formaldehyde_SOC_result"), "S(1)", "T(2)", 45.0)
+    ])
+def test_soc(result_set, singlet, triplet, SOC):
+    """Test calculation of spin-orbit coupling values."""
+    
+    # Check we have SOC between each singlet state (including the ground) and each triplet state.
+    assert len(result_set.soc) == (result_set.excited_states.num_singlets +1) * result_set.excited_states.num_triplets
+    
+    # Check some SOC values.
+    assert result_set.soc.between(singlet, triplet).wavenumbers == pytest.approx(SOC, abs=1e-0)

digichem/test/test_config.py

@@ -0,0 +1,78 @@
+import pytest
+from pathlib import Path
+import yaml
+import copy
+
+from digichem.test.util import digichem_options, data_directory
+from digichem.config import Auto_type, get_config
+from digichem.config.parse import Config_parser
+
+def test_config_save(digichem_options, tmpdir):
+    """Can we save config options to file?"""
+    # First, check an exception is thrown if we try and save to a non-existent dir:
+    # with pytest.raises(Exception):
+    #     digichem_options.save(Path(tmpdir, "foobar", "conf.yaml"))
+
+    # Now save properly.
+    save_file = Path(tmpdir, "conf.yaml")
+    digichem_options.save(save_file)
+
+    # Open the file and read it back.
+    with open(save_file) as file:
+        data = yaml.safe_load(file)
+
+    # Check the data is the same.
+    assert digichem_options.dump() == data
+
+@pytest.mark.parametrize("var, typeis", [
+    ["1", int],
+    ["1.1", float],
+    ["one", str]
+], ids=["int", "float", "str"])
+def test_autotype(var, typeis):
+    """Does autotype work?"""
+    assert type(Auto_type(var)) is typeis
+
+def test_string_parser():
+    """Can we parse config options from a string."""
+    Config_parser("foo: bar").load() == {"foo": "bar"}
+
+def test_bad_string_parser():
+    """Can we not parse config options from a malformed string."""
+    with pytest.raises(Exception):
+        Config_parser("foo: {bar").load()
+
+def test_del_option(digichem_options):
+    """Can we reset an option to its default by deleting it?"""
+    options = copy.deepcopy(digichem_options)
+    # First, set a value.
+    options.alignment = "FAP"
+
+    # Delete and check.
+    del options.alignment
+    assert options.alignment == "MIN"
+
+def test_config_merge():
+    """Can we set additional options from a string?"""
+    conf = get_config(
+        clear_cache = True,
+        extra_config_strings = ["alignment: FAP"]
+    )
+
+    assert conf.alignment == "FAP"
+    get_config(clear_cache = True)
+
+def test_config_file_merge(tmpdir):
+    """Can we set additional options from another file?"""
+    with open(Path(tmpdir, "conf.yaml"), "w") as conf_file:
+        yaml.dump({'alignment': 'FAP'}, conf_file)
+
+    conf = get_config(
+        clear_cache = True,
+        extra_config_files = [Path(tmpdir, "conf.yaml")]
+    )
+
+    assert conf.alignment == "FAP"
+
+    # Reset the config object.
+    get_config(clear_cache = True)