digichem-core 6.0.0rc1__py3-none-any.whl

digichem/misc/time.py

@@ -0,0 +1,73 @@
+# Miscellaneous functions for handling date and time.
+
+# General imports.
+import math
+
+def latest_datetime(*datetimes):
+    """
+    Return the latest of an iterable of datetimes.
+    
+    :param datetimes:  Datetimes, of which the latest will be returned.
+    :returns: The latest of the given datetimes, or None if no datetimes were given.
+    """
+    try:
+        datetimes = list(datetimes)
+        datetimes.sort()
+        return datetimes[-1]
+    except IndexError:
+        # No datetimes.
+        return None
+
+def total_timedelta(*timedeltas):
+    """
+    Return the sum of multiple timedeltas.
+    
+    :param timedeltas: Timedelta objects to be summed.
+    :returns: A new timedelta object that is the sum of the objects given, or None if no timedeltas were given.
+    """
+    try:
+        return sum(timedeltas[1:], timedeltas[0])
+    except IndexError:
+        return None
+
+
+def date_to_string(datetime_object):
+    """
+    Convert a datetime object to a standard string representation.
+    
+    :param datetime_object: The date and time to convert
+    :return: A string representation of datetime_object.
+    """
+    return datetime_object.strftime("%d/%m/%Y %H:%M:%S")
+
+def timedelta_to_string(timedelta_object):
+    """
+    Convert a timedelta object to a standard string representation.
+    
+    :param timedelta_object: The time difference to convert
+    :return: A string representation of timedelta_object.
+    """
+    hours = math.floor(timedelta_object.seconds / 3600)
+    minutes = math.floor((timedelta_object.seconds - hours * 3600) / 60)
+    # Seconds lacks microsecond accuracy, but we can add it on.
+    seconds = round((timedelta_object.seconds + timedelta_object.microseconds /1000000) - (hours * 3600 + minutes * 60))
+    
+    date_str = ""
+    add = False
+    
+    # Only add each section if not zero.
+    if timedelta_object.days != 0:
+        date_str += "{} d, ".format(timedelta_object.days)
+        add = True
+        
+    if hours != 0 or add:
+        date_str += "{} h, ".format(hours)
+        add = True
+        
+    if minutes != 0 or add:
+        date_str += "{} m, ".format(minutes)
+        add = True
+        
+    date_str += "{} s".format(seconds)
+    
+    return date_str

digichem/parse/__init__.py

@@ -0,0 +1,13 @@
+"""
+Classes for parsing calculation result data.
+
+Most of the heavy lifting is done by cclib, we just extract additional data not currently handed by cclib.
+"""
+
+# These alignment classes are needed to parse correctly.
+from digichem.result.alignment.AAA import Adjusted_average_angle
+from digichem.result.alignment.AA import Average_angle
+from digichem.result.alignment.FAP import Furthest_atom_pair
+from digichem.result.alignment import Minimal
+
+from digichem.parse.util import from_log_files, parse_calculation, parse_and_merge_calculations, parse_multiple_calculations, parse_and_merge_multiple_calculations

digichem/parse/base.py

@@ -0,0 +1,220 @@
+# General imports.
+from pathlib import Path
+import pwd
+import os
+
+from digichem.exception.base import Digichem_exception
+from digichem.result.orbital import Molecular_orbital_list,\
+    Beta_orbital
+from digichem.result.metadata import Metadata
+from digichem.result.result import Result_set
+from digichem.result.atom import Atom_list
+from digichem.result.tdm import Transition_dipole_moment
+from digichem.result.excited_state import Excited_state_list
+from digichem.result.energy import Energies
+from digichem.result.ground_state import Ground_state
+from digichem.result.soc import SOC_list
+from digichem.result.dipole_moment import Dipole_moment
+from digichem.result.vibration import Vibrations_list
+from digichem.result.emission import Relaxed_excited_state
+from digichem.result.nmr import NMR_shielding, NMR_spin_couplings_list, NMR_list
+from digichem.result.alignment.base import Minimal, Alignment
+
+
+# NOTE: This is a repeat of the list in util to avoid circular import nonsense.
+custom_parsing_formats = [
+    "sir",
+    "sij",
+    "yaml",
+    "json"
+]
+
+class Parser_abc():
+    """ABC for all parsers."""
+    
+    def __init__(self, *log_files, raw_data = None, **kwargs):
+        """
+        Top level constructor for calculation parsers.
+        
+        :param log_files: A list of output file to analyse/parse. The first log_file given will be used for naming purposes.
+        """
+        # Set our name.
+        self.log_file_paths = self.sort_log_files([Path(log_file) for log_file in log_files if log_file is not None])
+        
+        # Panic if we have no logs.
+        if len(self.log_file_paths) == 0:
+            raise Digichem_exception("Cannot parse calculation output; no available log files. Are you sure the given path is a log file or directory containing log files?")
+        
+        # An object that we will populate with raw results.
+        self.data = raw_data
+        
+        # A result set object that we'll populate with results.
+        self.results = None
+        
+        # Parse (if we haven't already).
+        try:
+            if self.data is None:
+                self.parse()
+        except Exception:
+            raise Digichem_exception("Error parsing calculation result '{}'".format(self.description))
+
+    @classmethod
+    def from_logs(self, *log_files, **kwargs):
+        """
+        Intelligent constructor that will attempt to guess the location of aux files from a given log file(s).
+        
+        :param log_files: Output file(s) to parse or a directory of output files to parse.
+        """
+        # This default implementation does nothing smart.
+        return self(*log_files, **kwargs)
+    
+    @classmethod
+    def sort_log_files(self, log_files):
+        """
+        Sort a list of log files into a particular order, if required for this parser.
+        """
+        return log_files
+    
+    @property
+    def log_file_path(self):
+        """
+        The main log file.
+        """
+        for log_file in self.log_file_paths:
+            if log_file.suffix.lower() == ".log":
+                return log_file
+            
+        return self.log_file_paths[0]
+            
+    @property
+    def name(self):
+        """
+        Short name to describe this calculation result.
+        """
+        return self.log_file_path.with_suffix("").name
+    
+    @property
+    def description(self):
+        """
+        A name/path that describes the file(s) being parsed, used for error messages etc.
+        """
+        return self.log_file_path
+    
+    def parse(self):
+        """
+        Extract results from our output files.
+        """
+        self._parse()
+    
+        # Make any final adjustments.
+        self.post_parse()
+    
+    def _parse(self):
+        """
+        Extract results from our output files.
+        """
+        raise NotImplementedError("Implement in subclass")
+        
+    @classmethod
+    def get_current_username(self):
+        """
+        Get the username of the currently logged in user.
+        
+        :returns: The username as a string, or None if the username could not be determined.
+        """
+        # Based on https://stackoverflow.com/questions/842059/is-there-a-portable-way-to-get-the-current-username-in-python
+        try:
+            return pwd.getpwuid(os.getuid()).pw_name
+        
+        except Exception as e:
+            return None
+        
+    def post_parse(self):
+        """
+        Perform any required operations after line-by-line parsing.
+        """
+        # Add our name.
+        if self.name is not None:
+            self.data.metadata['name'] = self.name
+            
+        # Add current username.
+        # TODO: It would probably be better if we used the name of the user who owns the output file, rather than the current user...
+        self.data.metadata['user'] = self.get_current_username()
+        
+        # Set our file paths.
+        self.data.metadata['log_files'] = self.log_file_paths
+        self.data.metadata['auxiliary_files'] = self.auxiliary_files
+            
+    def process_all(self, options):
+        """
+        Get all the Result set objects produced by this parser.
+        
+        :param options: A Digichem options nested dictionary containing options to control parsing.
+        :return: A list of the populated result sets.
+        """
+        self.process(options)
+        return [self.results]
+
+    def process(self, options):
+        """
+        Get a Result set object from this parser.
+        
+        :param options: A Digichem options nested dictionary containing options to control parsing.
+        :return: The populated result set.
+        """
+        self.options = options
+        # Get our result set.
+        self.results = Result_set(
+            _id = self.data._id,
+            metadata = Metadata.from_parser(self)
+            )
+        
+        alignment_class = Alignment.from_class_handle(options['alignment']) if options['alignment'] is not None else Minimal
+        
+        # First get our list of MOs (because we need them for excited states too.)
+        self.results.orbitals = Molecular_orbital_list.from_parser(self)
+        self.results.beta_orbitals = Molecular_orbital_list.from_parser(self, cls = Beta_orbital)
+        
+        # Assign total levels.
+        self.results.orbitals.assign_total_level(self.results.beta_orbitals)
+        
+        # Our alignment orientation data.
+        self.results.atoms = alignment_class.from_parser(self)
+        self.results.raw_atoms = Atom_list.from_parser(self)
+        
+        # TEDM and TMDM.
+        self.results.transition_dipole_moments = Transition_dipole_moment.from_parser(self)
+        
+        # Excited states.
+        self.results.excited_states = Excited_state_list.from_parser(self)
+        
+        # Energies.
+        self.results.energies = Energies.from_parser(self)
+        
+        # Our ground state.
+        self.results.ground_state = Ground_state.from_parser(self)
+        
+        # And a similar list but also including the ground.
+        self.results.energy_states = Excited_state_list()
+        self.results.energy_states.append(self.results.ground_state)
+        self.results.energy_states.extend(self.results.excited_states)
+        
+        # SOC.
+        self.results.soc = SOC_list.from_parser(self)
+        
+        # PDM
+        self.results.pdm = Dipole_moment.from_parser(self)
+        
+        # Frequencies.
+        self.results.vibrations = Vibrations_list.from_parser(self)
+        
+        # NMR.
+        self.results.nmr_shieldings = NMR_shielding.dict_from_parser(self)
+        self.results.nmr_couplings = NMR_spin_couplings_list.from_parser(self)
+        self.results.nmr = NMR_list.from_parser(self)
+        
+        # Finally, try and set emission.
+        self.results.emission.vertical, self.results.emission.adiabatic = Relaxed_excited_state.guess_from_results(self.results)
+        
+        # Return the populated result set for convenience.
+        return self.results

digichem/parse/cclib.py

@@ -0,0 +1,138 @@
+from pathlib import Path
+import hashlib
+
+import digichem.log
+from digichem.parse.base import Parser_abc
+
+# Hidden imports.
+#import cclib.io
+
+
+class Cclib_parser(Parser_abc):
+    """
+    ABC for parsers that use cclib to do most of their work for them.
+    """
+    
+    # A dictionary of recognised auxiliary file types.
+    INPUT_FILE_TYPES = {}
+    
+    def __init__(self, *log_files, **auxiliary_files):
+        """
+        Top level constructor for calculation parsers.
+        
+        :param log_files: A list of output file to analyse/parse. The first log_file given will be used for naming purposes.
+        :param auxiliary_files: A dictionary of auxiliary input files related to the calculation.
+        """
+        # Also save our aux files, stripping None.
+        self.auxiliary_files = {name: aux_file for name,aux_file in auxiliary_files.items() if aux_file is not None}
+        
+        super().__init__(*log_files)
+        
+    @classmethod
+    def from_logs(self, *log_files, **kwargs):
+        """
+        Intelligent constructor that will attempt to guess the location of files from a given log file(s).
+        
+        :param given_log_files: Output file(s) to parse or a directory of output files to parse.
+        """
+        # Have a look for aux. files.
+        auxiliary_files = {}
+        
+        for found_log_file in log_files:
+            auxiliary_files.update(self.find_auxiliary_files(found_log_file))
+            
+        # Finally, update our auxiliary_files with kwargs, so any user specified aux files take precedence.
+        auxiliary_files.update(kwargs)
+        
+        return self(*log_files, **auxiliary_files)
+    
+    @classmethod
+    def find_auxiliary_files(self, hint):
+        """
+        Find auxiliary files from a given hint.
+        
+        :param hint: A path to a file to use as a hint to find additional files.
+        :returns: A dictionary of found aux files.
+        """
+        hint = Path(hint)
+        
+        # Now have a look for aux. input files, which are defined by each parser's INPUT_FILE_TYPES
+        auxiliary_files = {}
+        for file_type in self.INPUT_FILE_TYPES:
+            for extension in file_type.extensions:
+                if hint.with_suffix(extension).exists():
+                    auxiliary_files[self.INPUT_FILE_TYPES[file_type]] = hint.with_suffix(extension)
+        
+        return auxiliary_files
+    
+    def _parse(self):
+        """
+        Extract results from our output files.
+        
+        This default implementation will parse the log file with cclib and save the result to self.data.
+        """
+        import cclib.io
+        
+        # We start by using cclib to get most of the data we need.
+        
+        # Output a message (because this is slow).
+        digichem.log.get_logger().info("Parsing calculation result '{}'".format(self.description))
+        
+        # Use cclib to open our log files.
+        # ccread will accept a list of log files to read, but will sometimes choke if the list contains only one entry,
+        # in which case we give it only one file name.
+        # ccread will also choke if we give it pathlib Paths.
+        file_paths = [str(log_file) for log_file in self.log_file_paths]
+        
+        # Get data from cclib.
+        self.data = cclib.io.ccread(file_paths if len(file_paths) > 1 else file_paths[0])
+        
+        # Get a unique ID (checksum) from the given log files.
+        # First, order the list of filenames so we also process in the same order.
+        # We do this because not all parsers define a custom sort.
+        
+        file_paths.sort()
+        hasher = hashlib.sha1()
+        
+        for file_path in file_paths:
+            hasher.update(Path(file_path).read_bytes())
+            
+        self.data._id = hasher.hexdigest()
+        
+        # Do some setup.
+        self.pre_parse()
+        
+        # Do our own parsing (if any).
+        for log_file_path in self.log_file_paths:
+            with open(log_file_path, "rt") as log_file:
+                for line in log_file:
+                    self.parse_output_line(log_file, line)
+        
+    def parse_output_line(self, log_file, line):
+        """
+        Perform custom line-by-line parsing of an output file.
+        
+        This method will be called for each line of each log-file given to the parser (although be aware that some implementations may skip some lines during parsing),
+        and it allows for data not supported by cclib to be extracted. It is program specific.
+        """
+        # Do nothing.
+        
+    def pre_parse(self):
+        """
+        Perform any setup before line-by-line parsing.
+        """
+        # Do nothing.
+        
+    @classmethod
+    def au_to_debye(self, au):
+        """
+        Convert a dipole moment in au to debye.
+        """
+        return au * 2.541746473
+    
+    @classmethod
+    def bohr_to_angstrom(self, bohr_distance):
+        """
+        Convert a length in bohr to angstrom.
+        """
+        return bohr_distance * 0.529177210903

digichem/parse/dump.py

@@ -0,0 +1,253 @@
+"""Parser(s) for reading from dumped digichem results sets"""
+import yaml
+import json
+
+from digichem.parse.base import Parser_abc
+from digichem.result.tdm import Transition_dipole_moment
+from digichem.result.result import Result_set
+from digichem.result.metadata import Metadata
+from digichem.result.orbital import Molecular_orbital_list
+from digichem.result.atom import Atom_list
+from digichem.result.excited_state import Excited_state_list
+from digichem.result.energy import Energies
+from digichem.result.ground_state import Ground_state
+from digichem.result.soc import SOC_list
+from digichem.result.dipole_moment import Dipole_moment
+from digichem.result.vibration import Vibrations_list
+from digichem.result.emission import Relaxed_excited_state
+import digichem.log
+from digichem.result.alignment.base import Alignment, Minimal
+from digichem.result.nmr import NMR_list
+
+
+class Dump_multi_parser_abc(Parser_abc):
+    """
+    ABC for classes that can read multiple result sets from dumped data.
+    """
+    
+    def __init__(self, input_file, *other_log_files, raw_data = None, **auxiliary_files):
+        """
+        Top level constructor for calculation parsers.
+        
+        :param input_file: The path to read from.
+        """
+        # Neither other_log_files nor auxiliary_files are currently used...
+        super().__init__(input_file, raw_data = raw_data)
+        self.all_results = []
+        
+    @classmethod
+    def from_data(self, input_file, data):
+        return self(input_file, raw_data = data)
+            
+    @property
+    def results(self):
+        return self.all_results[0]
+    
+    @results.setter
+    def results(self, value):
+        pass
+    
+    def post_parse(self):
+        """
+        Perform any required operations after line-by-line parsing.
+        """
+        for result in self.data:
+            # Add current username.
+            # TODO: It would probably be better if we used the name of the user who owns the output file, rather than the current user...
+            result['metadata']['user'] = self.get_current_username()
+            
+            # Set our file paths.
+            result['metadata']['log_files'] = self.log_file_paths
+            result['metadata']['auxiliary_files'] = {}
+    
+    def get_sub_parser(self):
+        raise NotImplementedError("Implement in subclass")
+            
+    def process_all(self, options):
+        """
+        Get all the Result set objects produced by this parser.
+        
+        :param options: A Digichem options nested dictionary containing options to control parsing.
+        :return: A list of the populated result sets.
+        """
+        # Unlike most other parsers, our data can actually contain lots of results.
+        self.all_results = [self.get_sub_parser()(self.log_file_path, raw_data = data).process(options) for data in self.data]
+        
+        return self.all_results
+    
+    def process(self, options):
+        """
+        Get a Result set object from this parser.
+        
+        :param options: A Digichem options nested dictionary containing options to control parsing.
+        :return: The populated result set.
+        """
+        self.process_all(options)
+        return self.results
+    
+    
+class Yaml_multi_parser(Dump_multi_parser_abc):
+    """
+    Parser for reading from dumped result sets in yaml format.
+    """
+    
+    def get_sub_parser(self):
+        return Yaml_parser
+    
+    def _parse(self):
+        """
+        Extract results from our output files.
+        """
+        # Read that file.
+        digichem.log.get_logger().info("Parsing calculation result '{}'".format(self.description))
+        with open(self.log_file_path, "rt") as yaml_file:
+            self.data = list(yaml.safe_load_all(yaml_file))
+    
+
+class Json_multi_parser(Dump_multi_parser_abc):
+    """
+    Parser for reading from dumped result sets in JSON format.
+    """
+    
+    def get_sub_parser(self):
+        return Json_parser
+    
+    def _parse(self):
+        """
+        Extract results from our output files.
+        """
+        # Read that file.
+        digichem.log.get_logger().info("Parsing calculation result '{}'".format(self.description))
+        with open(self.log_file_path, "rt") as json_file:
+            self.data = json.load(json_file)
+
+
+class Dump_parser_abc(Parser_abc):
+    """
+    ABC for parsers that read dumped data.
+    """
+    
+    def __init__(self, input_file, *other_log_files, raw_data = None, **auxiliary_files):
+        """
+        Top level constructor for calculation parsers.
+        
+        :param input_file: The path to the input file to read.
+        """
+        # Neither other_log_files nor auxiliary_files are currently used...
+        super().__init__(input_file, raw_data = raw_data)
+        
+    @classmethod
+    def from_data(self, input_file, data):
+        return self(input_file, raw_data = data)
+    
+    def process_all(self, options):
+        """
+        Get all the Result set objects produced by this parser.
+        
+        :param options: A Digichem options nested dictionary containing options to control parsing.
+        :return: A list of the populated result sets.
+        """
+        self.process(options)
+        return [self.results]
+            
+    def process(self, options):
+        """
+        Get a Result set object from this parser.
+        
+        :param options: A Digichem options nested dictionary containing options to control parsing.
+        :return: The populated result set.
+        """
+        
+        # Get our result set.
+        self.results = Result_set(
+            _id = self.data.get("_id"),
+            metadata = Metadata.from_dump(self.data['metadata'], self.results, options)
+        )
+        
+        # First get our list of MOs (because we need them for excited states too.)
+        self.results.orbitals = Molecular_orbital_list.from_dump(self.data['orbitals'], self.results, options)
+        self.results.beta_orbitals = Molecular_orbital_list.from_dump(self.data['beta_orbitals'], self.results, options)
+        
+        alignment_class = Alignment.from_class_handle(options['alignment']) if options['alignment'] is not None else Minimal
+        
+        # Our alignment orientation data.
+        # The constructor for each alignment class automatically performs realignment.
+        self.results.atoms = alignment_class.from_dump(self.data['atoms'], self.results, options)
+        self.results.raw_atoms = Atom_list.from_dump(self.data['raw_atoms'], self.results, options)
+        
+        # TEDM and TMDM.
+        self.results.transition_dipole_moments = Transition_dipole_moment.list_from_dump(self.data['excited_states']['values'], self.results, options)
+        
+        # Excited states.
+        self.results.excited_states = Excited_state_list.from_dump(self.data['excited_states'], self.results, options)
+        
+        # Energies.
+        self.results.energies = Energies.from_dump(self.data['energies'], self.results, options)
+        
+        # Our ground state.
+        self.results.ground_state = Ground_state.from_dump(self.data['ground_state'], self.results, options)
+        
+        # And a similar list but also including the ground.
+        self.results.energy_states = Excited_state_list()
+        self.results.energy_states.append(self.results.ground_state)
+        self.results.energy_states.extend(self.results.excited_states)
+        
+        # SOC.
+        self.results.soc = SOC_list.from_dump(self.data['soc'], self.results, options)
+        
+        # PDM
+        self.results.pdm = Dipole_moment.from_dump(self.data['pdm'], self.results, options)
+        
+        # Frequencies.
+        self.results.vibrations = Vibrations_list.from_dump(self.data['vibrations'], self.results, options)
+        
+        # NMR.
+        if "nmr" in self.data:
+            self.results.nmr = NMR_list.from_dump(self.data['nmr'], self.results, options)
+        
+        else:
+            self.results.nmr = NMR_list(atoms = self.results.atoms, options = options)
+            
+        # Finally, try and set emission.
+        try:
+            self.results.emission = self.results.emission.from_dump(self.data['emission'], self.results, options)
+        
+        except Exception:
+            digichem.log.get_logger().warning("Failed to parse emission data", exc_info = True)
+        
+        # If we don't have explicit emission set, try and guess.
+        #if len(self.results.emission.vertical) == 0 and len(self.results.emission.adiabatic) == 0:
+        #    self.results.emission.vertical, self.results.emission.adiabatic = Relaxed_excited_state.guess_from_results(self.results)
+        
+        # Return the populated result set for convenience.
+        return self.results
+
+
+class Yaml_parser(Dump_parser_abc):
+    """
+    Parser for reading from dumped result sets in yaml format.
+    """
+    
+    def _parse(self):
+        """
+        Extract results from our output files.
+        """
+        # Read that file.
+        digichem.log.get_logger().info("Parsing calculation result '{}'".format(self.description))
+        with open(self.log_file_paths[0], "rt") as yaml_file:
+            self.data = yaml.safe_load(yaml_file)
+            
+
+class Json_parser(Dump_parser_abc):
+    """
+    Parser for reading from TinyDB json files.
+    """
+    
+    def _parse(self):
+        """
+        Extract results from our output files.
+        """
+        raise NotImplementedError("Databases contain many results so it does not make sense to return only one. Try Tinydb_multi_parser instead.")
+                
+        
+