digichem-core 6.10.3__py3-none-any.whl → 7.0.0__py3-none-any.whl

digichem/__init__.py

@@ -20,7 +20,7 @@ from digichem.datas import get_resource
 # development = prerelease is not None
 # # The full version number of this package.
 # __version__ = "{}.{}.{}{}".format(major_version, minor_version, revision, "-pre.{}".format(prerelease) if development else "")
-__version__ = "6.10.3"
+__version__ = "7.0.0"
 _v_parts = __version__.split("-")[0].split(".")
 major_version = int(_v_parts[0])
 minor_version = int(_v_parts[1])
@@ -39,7 +39,7 @@ __author__ = [
 ]
 
 # Program date (when we were last updated). This is changed automatically.
-_last_updated_string = "09/06/2025"
+_last_updated_string = "30/09/2025"
 last_updated = datetime.strptime(_last_updated_string, "%d/%m/%Y")
 
 # The sys attribute 'frozen' is our flag, '_MEIPASS' is the dir location.

digichem/config/base.py

@@ -35,6 +35,11 @@ class Digichem_options(Configurable):
         cubegen = Option(help = "Gaussian's cubegen utility https://gaussian.com/cubegen/", default = "cubegen"),
         cubegen_parallel = Option(help = "What type of parallelism to use with cubegen, multithreaded runs a single instance of cubegen across multiple CPUs, pool runs multiple instances of cubegen", choices = [None, "multithreaded", "pool"], default = "pool")
     )
+
+    parse = Options(
+        help = "Options for controlling parsing of config files",
+        profiling_rows = Option(help = "The maximum number of rows to parse from the calculation profile file (if available); if more rows than this are available then the data will be downsampled to at most this number of data points", type = int, default = 1000)
+    )
     
     skeletal_image = Options(
         help = "Options for controlling the rendering of 2D skeletal images.",
@@ -172,6 +177,7 @@ To disable the maximum width, set to null.""", type = int, default = 1200
 Set to 0 for no cutoff (all peaks shown), which may results in the graph being extended well beyond the drawn peaks (because many peaks are too small to see).
 This option has no effect when using manual x limits.""", type = float, default = 0.01
         ),
+        y_filter = Option(help = "The minimum y value to simulate using the Gaussian function (y values below this are discarded)", type = float, default = 1e-6),
         x_padding = Option(help = "The amount (in nm) to extend the x axis past the highest/lowest energy peak.", type = int, default = 40),
         fwhm = Option(help = "The full-width at half-maximum; changes how wide the drawn peaks are. Note that the choice of peak width is essentially arbitrary; only the peak height is given by calculation. Units are eV.", type = float, default = 0.4),
         gaussian_cutoff = Option(help = "The minimum y value to plot using the Gaussian function (controls how close to the x axis we draw the gaussian) as a fraction of the max peak height.", type = float, default = 0.001),
@@ -202,10 +208,11 @@ Absorption graphs will grow/shrink their width to fit available data, keeping a
 To disable the maximum width, set to null.""", type = int, default = 1200
         ),
         peak_cutoff = Option(help =\
-"""The minimum oscillator strength that a peak must have to be shown in the graph, as a fraction ofthe highest peak.
+"""The minimum oscillator strength that a peak must have to be shown in the graph, as a fraction of the highest peak.
 Set to 0 for no cutoff (all peaks shown), which may results in the graph being extended well beyond the drawn peaks (because many peaks are too small to see).
 This option has no effect when using manual x limits.""", type = float, default = 0.01
         ),
+        y_filter = Option(help = "The minimum y value to simulate using the Gaussian function (y values below this are discarded)", type = float, default = 1e-6),
         x_padding = Option(help = "The amount (in nm) to extend the x axis past the highest/lowest energy peak.", type = int, default = 40),
         fwhm = Option(help = "The full-width at half-maximum; changes how wide the drawn peaks are. Note that the choice of peak width is essentially arbitrary; only the peak height is given by calculation. Units are eV.", type = float, default = 0.4),
         gaussian_cutoff = Option(help = "The minimum y value to plot using the Gaussian function (controls how close to the x axis we draw the gaussian) as a fraction of the max peak height.", type = float, default = 0.001),
@@ -235,6 +242,7 @@ Possible options are:
 """The maximum image width in pixels.
 IR spectra will grow/shrink their width to fit available data, keeping a constant scale (constant pixels to nm ratio) but only up to this maximum.
 To disable the maximum width, set to null.""", type = int, default = 1500),
+        y_filter = Option(help = "The minimum y value to simulate using the Gaussian function (y values below this are discarded)", type = float, default = 1e-6),
         gaussian_cutoff = Option(help = "The minimum y value to plot using the Gaussian function (controls how close to the x axis we draw the gaussian) as a fraction of the max peak height.", type = float, default = 0.001),
         gaussian_resolution = Option(help = "The spacing between x values to plot using the Gaussian function, in eV. Values that are too large will result in 'curves' made up of a series of straight edges.", type = float, default = 1.0)
     )
@@ -243,6 +251,7 @@ To disable the maximum width, set to null.""", type = int, default = 1500),
         enable_rendering = Option(help = "Set to False to disable image rendering.", type = bool, default = True),
         coupling_filter = Option(help = "Discard J coupling that is below this threshold (in Hz)", type = float, default = 1),
         fwhm = Option(help = "The full-width at half-maximum; changes how wide the drawn peaks are. Note that the choice of peak width is essentially arbitrary; only the peak height is given by calculation. Units are ppm.", type = float, default = 0.01),
+        y_filter = Option(help = "The minimum y value to simulate using the Gaussian function (y values below this are discarded)", type = float, default = 1e-6),
         gaussian_cutoff = Option(help = "The minimum y value to plot using the Gaussian function (controls how close to the x axis we draw the gaussian) as a fraction of the max peak height.", type = float, default = 0.001),
         gaussian_resolution = Option(help = "The spacing between x values to plot using the Gaussian function, in ppm. Values that are too large will result in 'curves' made up of a series of straight edges.", type = float, default = 0.001),
         frequency = Option(help = "The frequency to run the simulated spectrometer at. Larger values will result in narrower coupling. Units are MHz", type = float, default = 100),

digichem/config/util.py

@@ -40,8 +40,9 @@ def get_config(
         :param sources: An iterable of file locations to read from.
         :return: A Digichem_options object (a fancy dict).
         """
+        global _options
         if clear_cache:
-            globals()['_options'] = None
+            _options = None
 
         if _options is not None and extra_config_files is None and extra_config_strings is None:
             # Config has already been loaded (and we have nothing new to add).
@@ -63,7 +64,7 @@ def get_config(
                 #  config.merge(Config_file_parser(source).load(True))
             
             # No need to validate here, we're going to do it later anyway.
-            globals()['_options'] = cls(validate_now = False, **config)
+            _options = cls(validate_now = False, **config)
         
         if extra_config_files is None:
             extra_config_files = []

digichem/file/prattle.py

@@ -37,7 +37,7 @@ class Openprattle_converter():
         :param executable: Path or command name to the oprattle executable.
         """
         self.input_file = input_file
-        self.input_file_buffer = input_file_buffer
+        self.input_file_buffer = input_file_buffer if input_file is None else input_file.read()
         self.input_file_path = input_file_path
         self.input_file_type = input_file_type
         self.executable = executable
@@ -128,7 +128,7 @@ class Openprattle_converter():
         ]
         
         # Add the input path if we're reading from file.
-        if self.input_file is None:
+        if self.input_file_buffer is None:
             sig.append(str(self.input_file_path))
             
         # Now add the input and output switches.
@@ -152,7 +152,11 @@ class Openprattle_converter():
             sig.extend(['-O', output_file])
         
         # Give our input_file as stdin if we're not reading from file.
-        inputs = self.input_file        
+        inputs = self.input_file_buffer
+
+        # Encode strings.
+        if isinstance(inputs, str):
+            inputs = inputs.encode()
         
         # GO.
         done_process = subprocess.run(
@@ -160,18 +164,16 @@ class Openprattle_converter():
             input = inputs,
             stdout = subprocess.PIPE,
             stderr = subprocess.PIPE,
-            # TODO: Using universal newlines is probably not safe here; some formats are binary (.cdx etc...)
-            universal_newlines = True,
         )
 
         # This can throw exceptions.
-        self.handle_logging(done_process.stderr)
+        self.handle_logging(done_process.stderr.decode())
 
         if done_process.returncode != 0:
             raise Digichem_exception("prattle subprocess returned code {}".format(done_process.returncode))
         
         # Return our output.
-        return done_process.stdout if output_file is None else None
+        return done_process.stdout.decode() if output_file is None else None
     
     def handle_logging(self, raw_output):
         """

digichem/image/spectroscopy.py

@@ -256,8 +256,15 @@ class Absorption_emission_graph_maker(Spectroscopy_graph_maker):
         """    
         return self(
             output,
-            Absorption_emission_graph.from_excited_states(excited_states, options[self.options_name]['fwhm'], options[self.options_name]['gaussian_resolution'], options[self.options_name]['gaussian_cutoff'], use_jacobian = options[self.options_name]['use_jacobian'], adjust_zero = adjust_zero),
-            **{key: value for key, value in options[self.options_name].items() if key not in ["gaussian_cutoff", "gaussian_resolution", "fwhm", "use_jacobian"]},
+            Absorption_emission_graph.from_excited_states(
+                excited_states,
+                options[self.options_name]['fwhm'],
+                options[self.options_name]['gaussian_resolution'],
+                options[self.options_name]['gaussian_cutoff'],
+                use_jacobian = options[self.options_name]['use_jacobian'],
+                filter = options[self.options_name]['y_filter'],
+                adjust_zero = adjust_zero),
+            **{key: value for key, value in options[self.options_name].items() if key not in ["gaussian_cutoff", "gaussian_resolution", "fwhm", "use_jacobian", "y_filter"]},
             **kwargs
         )
     
@@ -332,8 +339,14 @@ class Frequency_graph_maker(Spectroscopy_graph_maker):
         """        
         return self(
             output,
-            graph = Spectroscopy_graph.from_vibrations(vibrations, options['IR_spectrum']['fwhm'], options['IR_spectrum']['gaussian_resolution'], options['IR_spectrum']['gaussian_cutoff']),
-            **{key: value for key, value in options['IR_spectrum'].items() if key not in ["gaussian_cutoff", "gaussian_resolution", "fwhm"]},
+            graph = Spectroscopy_graph.from_vibrations(
+                vibrations,
+                options['IR_spectrum']['fwhm'],
+                options['IR_spectrum']['gaussian_resolution'],
+                options['IR_spectrum']['gaussian_cutoff'],
+                filter = options['IR_spectrum']['y_filter']
+            ),
+            **{key: value for key, value in options['IR_spectrum'].items() if key not in ["gaussian_cutoff", "gaussian_resolution", "fwhm", "y_filter"]},
             **kwargs
         )
 

digichem/input/__init__.py

@@ -1,3 +1,3 @@
 from .base import Input_file
 from .gaussian import Gaussian_input_parser
-from .digichem_input import Digichem_coords_ABC, Digichem_coords, si_from_yaml, si_from_file
+from .digichem_input import Digichem_coords_ABC, Digichem_coords, si_from_yaml, si_from_file, si_from_data

digichem/input/digichem_input.py

@@ -211,7 +211,7 @@ class Digichem_coords_ABC(Input_file, Molecule_mixin):
             # Convert.
             charge = self.charge if self.charge is not None else None
             multiplicity = self.multiplicity if self.multiplicity is not None else None
-            return Openprattle_converter(input_file = self.xyz, input_file_path = self.implicit_name, input_file_type = "xyz").convert(file_type, file, charge = charge, multiplicity = multiplicity)
+            return Openprattle_converter(input_file_buffer = self.xyz, input_file_path = self.implicit_name, input_file_type = "xyz").convert(file_type, file, charge = charge, multiplicity = multiplicity)
 
     @classmethod
     def input_formats(self):
@@ -416,6 +416,38 @@ def si_from_yaml(yaml_dict, file_name = None, **kwargs):
     return cls.from_yaml(yaml_dict, file_name, **kwargs)
 
 
+def si_from_data(data, file_type, *, gen3D = None, file_name = None, **kwargs):
+    """
+    """
+    if file_type in ["com", "gau", "gjc", "gjf"]:
+        # Gaussian input format.
+        return Digichem_coords.from_com(data, file_name = file_name, **kwargs)
+
+    elif file_type == "si":
+        # Digichem input format.
+        return si_from_yaml(yaml.safe_load(data), file_name = file_name, **kwargs)
+        
+    elif file_type == "pickle":
+        # A digichem resume file.
+        # The resume file (should be) a pickled destination object.
+        try:
+            destination = dill.loads(data)
+        
+        except Exception as e:
+            raise Digichem_exception("Failed to parse digichem resume file") from e
+        
+        return destination.program.calculation.input_coords
+    
+    else:
+        # Generic input format, use obabel.
+        
+        # We convert all formats to gaussian input formats (because this format contains charge and multiplicity, which we can extract).
+        com_file = Openprattle_converter(input_file_buffer = data, input_file_type = file_type).convert("com", gen3D = gen3D)
+    
+        # Continue with other constructors.
+        return Digichem_coords.from_com(com_file, file_name = file_name, **kwargs)
+
+
 def si_from_file(file_name, file_type = None, *, gen3D = None, **kwargs):
         """
         Create a Digichem_coords object from a file in arbitrary format.
@@ -436,32 +468,10 @@ def si_from_file(file_name, file_type = None, *, gen3D = None, **kwargs):
                 auto_file_type = True
                 file_type = Openprattle_converter.type_from_file_name(file_name, allow_none = True)
                     
-            # Certain formats we support natively; others we convert to an intermediate format.
-            if file_type in ["com", "gau", "gjc", "gjf"]:
-                # Gaussian input format.
-                with open(file_name, "rt") as com_file:
-                    return Digichem_coords.from_com(com_file.read(), file_name = file_name, **kwargs)
-    
-            elif file_type == "si":
-                # Digichem input format.
-                with open(file_name, "rt") as si_file:
-                    return si_from_yaml(yaml.safe_load(si_file.read()), file_name = file_name, **kwargs)
-                
-            elif file_type == "pickle":
-                # A digichem resume file.
-                # The resume file (should be) a pickled destination object.
-                with open(file_name, "rb") as pickle_file:
-                    try:
-                        destination = dill.load(pickle_file)
-                    
-                    except Exception as e:
-                        raise Digichem_exception("Failed to parse digichem resume file") from e
-                    
-                    return destination.program.calculation.input_coords
-                
+            # Certain formats we support natively; others we convert to an intermediate format.                
             # NOTE: Here we assume files without an extension are log files.
             # This works fine for directories, but might change in future.
-            elif file_type in ["dat", "log", "out", "output", None] \
+            if file_type in ["dat", "log", "out", "output", None] \
                 or (auto_file_type and "".join(file_name.suffixes) in open_for_parsing.get_archive_formats()):
                 # Generic log-file (output) format.
                 # Most formats (.log, .dat etc) we can parse with either Obabel or Digichem.
@@ -476,24 +486,19 @@ def si_from_file(file_name, file_type = None, *, gen3D = None, **kwargs):
                 except Exception as e:
                     # No good, see if we can use obabel.
                     try:
-                        com_file = Openprattle_converter.from_file(file_name, file_type).convert("com", gen3D = gen3D)
+                        com_file = Openprattle_converter(file_name, file_type).convert("com", gen3D = gen3D)
                     
                     except Exception:
                         # Also no good, re-raise original exception.
-                        raise
+                        raise e
                     
                     # Worked with fallback, log a message.
                     digichem.log.get_logger().warning(f"Failed to parse calculation output file '{file_name}'; using Obabel fallback mechanism")
                     return Digichem_coords.from_com(com_file, file_name = file_name, **kwargs)
                 
             else:
-                # Generic input format, use obabel.
-                
-                # We convert all formats to gaussian input formats (because this format contains charge and multiplicity, which we can extract).
-                com_file = Openprattle_converter.from_file(file_name, file_type).convert("com", gen3D = gen3D)         
-            
-                # Continue with other constructors.
-                return Digichem_coords.from_com(com_file, file_name = file_name, **kwargs)
+                with open(file_name, "rb" if file_type in ["pickle", "cdx"] else "r") as input_file:
+                    return si_from_data(input_file.read(), file_name = file_name, gen3D = gen3D, file_type = file_type, **kwargs)
             
         except:
             raise ValueError("Could not parse coordinates from '{}'".format(file_name))

digichem/parse/base.py

@@ -32,7 +32,7 @@ custom_parsing_formats = [
 class Parser_abc():
     """ABC for all parsers."""
 
-    def __init__(self, *, raw_data = None, **kwargs):
+    def __init__(self, *, raw_data = None, options, **kwargs):
         """
         Top level constructor for calculation parsers.
         """
@@ -41,6 +41,9 @@ class Parser_abc():
         
         # A result set object that we'll populate with results.
         self.results = None
+
+        # Config options.
+        self.options = options
         
         # Parse (if we haven't already).
         try:
@@ -100,24 +103,23 @@ class Parser_abc():
         # 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()
             
-    def process_all(self, options):
+    def process_all(self):
         """
         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)
+        self.process()
         return [self.results]
     
-    def process(self, options):
+    def process(self):
         """
         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,
@@ -125,7 +127,7 @@ class Parser_abc():
             aux = self.data._aux if hasattr(self.data, '_aux') else None
             )
         
-        alignment_class = Alignment.from_class_handle(options['alignment']) if options['alignment'] is not None else Minimal
+        alignment_class = Alignment.from_class_handle(self.options['alignment']) if self.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)

digichem/parse/cclib.py

@@ -22,7 +22,7 @@ class Cclib_parser(File_parser_abc):
     # A dictionary of recognised auxiliary file types.
     INPUT_FILE_TYPES = {}
     
-    def __init__(self, *log_files, **auxiliary_files):
+    def __init__(self, *log_files, options, **auxiliary_files):
         """
         Top level constructor for calculation parsers.
         
@@ -36,10 +36,10 @@ class Cclib_parser(File_parser_abc):
         # Also have a look for a profile.csv file that we can us for performance metrics.
         self.profile_file = Path(log_files[0].parent, "../Logs/profile.csv")
         
-        super().__init__(*log_files)
+        super().__init__(*log_files, options = options)
         
     @classmethod
-    def from_logs(self, *log_files, hints = None, **kwargs):
+    def from_logs(self, *log_files, hints = None, options, **kwargs):
         """
         Intelligent constructor that will attempt to guess the location of files from a given log file(s).
         
@@ -56,7 +56,7 @@ class Cclib_parser(File_parser_abc):
         # 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)
+        return self(*log_files, options = options, **auxiliary_files)
     
     @classmethod
     def find_auxiliary_files(self, hint, basename):
@@ -127,7 +127,11 @@ class Cclib_parser(File_parser_abc):
             self.parse_profile_file()
         
         except Exception:
-            digichem.log.get_logger().warning("Could not parse profile.csv file; profiling data will be unavailable", exc_info=True)
+            if self.profile_file.exists():
+                digichem.log.get_logger().warning("Could not parse profile.csv file; profiling data will be unavailable", exc_info=True)
+            
+            else:
+                pass
 
     def parse_profile_file(self):
         """
@@ -146,7 +150,7 @@ class Cclib_parser(File_parser_abc):
         if lines < 2:
             return
 
-        max_lines  = 1000
+        max_lines  = self.options.parse['profiling_rows']
         factor = math.ceil(lines / max_lines)
         
         with open(self.profile_file) as profile_file:

digichem/parse/dump.py

@@ -25,19 +25,19 @@ class Dump_multi_parser_abc(File_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):
+    def __init__(self, input_file, *other_log_files, raw_data = None, options , **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)
+        super().__init__(input_file, raw_data = raw_data, options = options)
         self.all_results = []
         
     @classmethod
-    def from_data(self, input_file, data):
-        return self(input_file, raw_data = data)
+    def from_data(self, input_file, data, options):
+        return self(input_file, raw_data = data, options = options)
             
     @property
     def results(self):
@@ -63,26 +63,24 @@ class Dump_multi_parser_abc(File_parser_abc):
     def get_sub_parser(self):
         raise NotImplementedError("Implement in subclass")
             
-    def process_all(self, options):
+    def process_all(self):
         """
         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]
+        self.all_results = [self.get_sub_parser()(self.log_file_path, raw_data = data, options = self.options).process() for data in self.data]
         
         return self.all_results
     
-    def process(self, options):
+    def process(self):
         """
         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)
+        self.process_all()
         return self.results
     
     
@@ -127,65 +125,63 @@ class Dump_parser_abc(File_parser_abc):
     ABC for parsers that read dumped data.
     """
     
-    def __init__(self, input_file, *other_log_files, raw_data = None, **auxiliary_files):
+    def __init__(self, input_file, *other_log_files, raw_data = None, options, **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)
+        super().__init__(input_file, raw_data = raw_data, options = options)
         
     @classmethod
-    def from_data(self, input_file, data):
-        return self(input_file, raw_data = data)
+    def from_data(self, input_file, data, options):
+        return self(input_file, raw_data = data, options = options)
     
-    def process_all(self, options):
+    def process_all(self):
         """
         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)
+        self.process()
         return [self.results]
             
-    def process(self, options):
+    def process(self):
         """
         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)
+            metadata = Metadata.from_dump(self.data['metadata'], self.results, self.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)
+        self.results.orbitals = Molecular_orbital_list.from_dump(self.data['orbitals'], self.results, self.options)
+        self.results.beta_orbitals = Molecular_orbital_list.from_dump(self.data['beta_orbitals'], self.results, self.options)
         
-        alignment_class = Alignment.from_class_handle(options['alignment']) if options['alignment'] is not None else Minimal
+        alignment_class = Alignment.from_class_handle(self.options['alignment']) if self.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)
+        self.results.atoms = alignment_class.from_dump(self.data['atoms'], self.results, self.options)
+        self.results.raw_atoms = Atom_list.from_dump(self.data['raw_atoms'], self.results, self.options)
         
         # TEDM and TMDM.
-        self.results.transition_dipole_moments = Transition_dipole_moment.list_from_dump(self.data['excited_states']['values'], self.results, options)
+        self.results.transition_dipole_moments = Transition_dipole_moment.list_from_dump(self.data['excited_states']['values'], self.results, self.options)
         
         # Excited states.
-        self.results.excited_states = Excited_state_list.from_dump(self.data['excited_states'], self.results, options)
+        self.results.excited_states = Excited_state_list.from_dump(self.data['excited_states'], self.results, self.options)
         
         # Energies.
-        self.results.energies = Energies.from_dump(self.data['energies'], self.results, options)
+        self.results.energies = Energies.from_dump(self.data['energies'], self.results, self.options)
         
         # Our ground state.
-        self.results.ground_state = Ground_state.from_dump(self.data['ground_state'], self.results, options)
+        self.results.ground_state = Ground_state.from_dump(self.data['ground_state'], self.results, self.options)
         
         # And a similar list but also including the ground.
         self.results.energy_states = Excited_state_list()
@@ -193,24 +189,24 @@ class Dump_parser_abc(File_parser_abc):
         self.results.energy_states.extend(self.results.excited_states)
         
         # SOC.
-        self.results.soc = SOC_list.from_dump(self.data['soc'], self.results, options)
+        self.results.soc = SOC_list.from_dump(self.data['soc'], self.results, self.options)
         
         # PDM
-        self.results.pdm = Dipole_moment.from_dump(self.data['pdm'], self.results, options)
+        self.results.pdm = Dipole_moment.from_dump(self.data['pdm'], self.results, self.options)
         
         # Frequencies.
-        self.results.vibrations = Vibrations_list.from_dump(self.data['vibrations'], self.results, options)
+        self.results.vibrations = Vibrations_list.from_dump(self.data['vibrations'], self.results, self.options)
         
         # NMR.
         if "nmr" in self.data:
-            self.results.nmr = NMR_list.from_dump(self.data['nmr'], self.results, options)
+            self.results.nmr = NMR_list.from_dump(self.data['nmr'], self.results, self.options)
         
         else:
-            self.results.nmr = NMR_list(atoms = self.results.atoms, options = options)
+            self.results.nmr = NMR_list(atoms = self.results.atoms, options = self.options)
             
         # Finally, try and set emission.
         try:
-            self.results.emission = self.results.emission.from_dump(self.data['emission'], self.results, options)
+            self.results.emission = self.results.emission.from_dump(self.data['emission'], self.results, self.options)
         
         except Exception:
             digichem.log.get_logger().warning("Failed to parse emission data", exc_info = True)

digichem/parse/gaussian.py

@@ -29,9 +29,9 @@ class Gaussian_parser(Cclib_parser):
     CPU_TIME_HEADER = "Job cpu time:"
     CPU_HEADER = "Will use up to"
 
-    def __init__(self, *log_files, rwfdump = "rwfdump", **auxiliary_files):
+    def __init__(self, *log_files, rwfdump = "rwfdump", options, **auxiliary_files):
         self.rwfdump = rwfdump
-        super().__init__(*log_files, **auxiliary_files)
+        super().__init__(*log_files, options = options, **auxiliary_files)
     
     def parse_metadata(self):
         """

digichem/parse/turbomole.py

@@ -98,14 +98,13 @@ class Turbomole_parser(Cclib_parser):
         if len(self.data.metadata['cpu_time']) == 0:
             del(self.data.metadata['cpu_time'])
 
-    def process(self, options):
+    def process(self):
         """
         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.
         """
-        super().process(options)
+        super().process()
         
         # After processing is complete, have a look for excited state density files.
         # These have the general file name: