digichem-core 7.0.4__py3-none-any.whl → 7.3.0__py3-none-any.whl

digichem/__init__.py

@@ -11,16 +11,7 @@ from digichem.datas import get_resource
 ####################
 
 
-# # Version information.
-# major_version = 6
-# minor_version = 0
-# revision = 0
-# prerelease = 1
-# # Whether this is a development version.
-# 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__ = "7.0.4"
+__version__ = "7.3.0"
 _v_parts = __version__.split("-")[0].split(".")
 major_version = int(_v_parts[0])
 minor_version = int(_v_parts[1])
@@ -39,7 +30,7 @@ __author__ = [
 ]
 
 # Program date (when we were last updated). This is changed automatically.
-_last_updated_string = "18/11/2025"
+_last_updated_string = "02/02/2026"
 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

@@ -249,7 +249,7 @@ To disable the maximum width, set to null.""", type = int, default = 1500),
     
     nmr = Options(help = "Options for controlling simulated NMR spectra",
         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),
+        coupling_filter = Option(help = "Discard J coupling that is below this threshold (in Hz)", type = float, default = 0.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),
@@ -271,7 +271,7 @@ To disable the maximum width, set to null.""", type = int, default = 1500),
         isotopes = Option(help = "Isotope specific options. Each key should consist of a tuple of (proton_number, isotope).", type = Nested_dict_type, default = Nested_dict_type({
             # Resonance frequencies calculated at 9.3947 T.
             # 1H, increase fidelity to see more detail.
-            "1H": {"frequency": 400, "fwhm": 0.005, "gaussian_resolution": 0.0005, "coupling_filter": 0.001, "pre_merge": 0.0005},
+            "1H": {"frequency": 400, "fwhm": 0.0015, "gaussian_resolution": 0.0001, "coupling_filter": 0.001, "pre_merge": 0.0005},
             # 11B.
             "11B": {"frequency": 128.3},
             # 13C.

digichem/datas.py

@@ -1,8 +1,12 @@
 import atexit
 from contextlib import ExitStack
 
-# TODO: Can switch to non-backport importlib.resources once >= 3.9
-import importlib_resources
+try:
+    import importlib.resources
+    importlib_resources = importlib.resources
+
+except ImportError:
+    import importlib_resources
 
 def get_resource(name):
     """

digichem/image/render.py

@@ -68,7 +68,8 @@ class Render_maker(File_converter, Cropable_mixin):
         self.target_resolution = resolution
         self.also_make_png = also_make_png
         self.isovalue = isovalue
-        self.num_cpu = num_cpu
+        # TODO: Should we not guess the number of CPUs required?
+        self.num_cpu = num_cpu if num_cpu is not None else num_cpu
         
         # TODO: These.
         self.primary_colour = "red"

digichem/image/spectroscopy.py

@@ -435,7 +435,7 @@ class NMR_graph_maker_abc(Spectroscopy_graph_maker):
             label = r"$\mathdefault{{{{{}}}_{{{}}}}}$ ({})".format(atom_group.element, atom_group.index, mult_string)
             #label += "\n" + r"$\int$ = {}{}".format(len(atom_group.atoms), atom_group.element.symbol)
             #label += "\n{:.2f} ppm".format(x_coord) + r", $\int$ = {}{}".format(len(atom_group.atoms), atom_group.element.symbol)
-            label += "\n{:.2f} ppm".format(x_coord) + r", {}{}".format(len(atom_group.atoms), atom_group.element.symbol)
+            label += "\n{:.2f} ppm".format(x_coord) + r", ∫ = {}{}".format(len(atom_group.atoms), atom_group.element.symbol)
         
         else:
             label = r"$\mathdefault{{{{{}}}_{{{}}}}}$".format(atom_group.element, atom_group.index)
@@ -572,9 +572,13 @@ class NMR_graph_maker(NMR_graph_maker_abc):
         # We always want to make sure that zero is shown however.
         #
         # NMR is also typically shown on a reversed scale.
+
+        # First, work out how wide our graph will be.
+        min_x = min(min(visible_x_values), 0)
+        max_x = max(max(visible_x_values), 0)
               
         x_padding = (
-            max(visible_x_values) - min(visible_x_values)
+            max_x - min_x
         ) * self.x_padding_percent
         
         # If we have no negative shifts, set zero as the end of one scale.
@@ -634,7 +638,7 @@ class NMR_graph_zoom_maker(NMR_graph_maker_abc):
         self.focus = focus
         
         self.x_padding = None
-        self.x_padding_percent = 1.0
+        self.x_padding_percent = 0.5
         
         self.target_width = 3.5
         
@@ -668,10 +672,11 @@ class NMR_graph_zoom_maker(NMR_graph_maker_abc):
         
         # We need to get a list of all peaks that are above our cutoff point.
         # First determine our highest point.
-        highest_point = max(self.transpose(graph.coordinates)[1])
+        coords = graph.plot_cumulative_gaussian()
+        highest_point = max(self.transpose(coords)[1])
         
         # Now filter by a fraction of that amount.
-        visible_x_values = [x for x, y in graph.plot_cumulative_gaussian() if y >= (highest_point * self.peak_cutoff)]
+        visible_x_values = [x for x, y in coords if y >= (highest_point * self.peak_cutoff)]
         
         x_padding = (
             max(visible_x_values) -min(visible_x_values)
@@ -721,9 +726,11 @@ class NMR_graph_zoom_maker(NMR_graph_maker_abc):
         
         
         highest_point = max(spectrum[1])
+
+        height = highest_point * 1.3
         
         # Clamp to 0 -> pos.
-        self.axes.set_ylim(0, highest_point * 1.3)
+        self.axes.set_ylim(0 - height * 0.025, height)
         
     def plot_lines(self):
         """
@@ -796,8 +803,8 @@ class NMR_graph_zoom_maker(NMR_graph_maker_abc):
         if len(couplings) > 0 and mult[0]["number"] != 1:
             # Only show couplings for peaks we can actually distinguish.
             for (coupling_group, coupling_isotope), coupling in list(couplings.items())[:len(mult)]:
-            #for (coupling_group, coupling_isotope), coupling in [isotope_coupling for atom_dict in couplings.values() for isotope_coupling in atom_dict.items()][:len(mult)]:
-                label += "\n" + r"J = {:.2f} Hz ($\mathdefault{{^{{{}}}{}_{{{}}}}}$, {}{})".format(
+                label += "\n" + r"$\mathdefault{{^{{{}}}}}$J = {:.2f} Hz ($\mathdefault{{^{{{}}}{}_{{{}}}}}$, {}{})".format(
+                    coupling.distance if coupling.distance is not None else "",
                     coupling.total,
                     coupling_isotope,
                     coupling_group.element,

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, si_from_data
+from .digichem_input import Digichem_coords_ABC, Digichem_coords, si_from_yaml, si_from_file, si_from_data, si_iter_from_xyz

digichem/input/digichem_input.py

@@ -502,4 +502,36 @@ def si_from_file(file_name, file_type = None, *, gen3D = None, **kwargs):
             
         except:
             raise ValueError("Could not parse coordinates from '{}'".format(file_name))
-    
+    
+
+def si_iter_from_xyz(file_name, **kwargs):
+    """
+    Return a generator that yields Digichem_coords objects from the molecules in an xyz file.
+    
+    :param file_name: The XYZ file to read from. If the file contains multiple structures, they will be read in sequence.
+    """
+    with open(file_name, "rt") as file:
+        # How many lines are we expecting in the current molecule.
+        doc_length = None
+        doc_line_no = 0
+        data = []
+
+        for line in file:
+            if doc_length is None:
+                # New document, how big is it?
+                doc_length = int(line.strip()) +2
+
+            # What line of the document are we on right now?
+            doc_line_no += 1
+            data.append(line)
+
+            # Are we still reading the same document?
+            if doc_line_no >= doc_length:
+                # End of the document, we got a molecule!
+                yield Digichem_coords_v2.from_xyz("".join(data), **kwargs)
+
+                # Time for a new document, reset.
+                doc_length = None
+                doc_line_no = 0
+                data = []
+            

digichem/input/gaussian.py

@@ -130,11 +130,51 @@ class Gaussian_input_parser():
         
         # And anything else.
         self.additional_sections = sections[3:]
+    
+    def geometry_with_iso(self, isotopes = {}):
+        """
+        Get the geometry of this gaussian input file with specific isotopes.
+
+        :param isotopes: Isotope information. Each key should be an atomic index, or an element symbol, and each value the corresponding isotope (as an integer).
+        """
+        lines = []
+        for index, line in enumerate(self.geometry.split("\n")):
+            split_line = line.split()
+            atom = split_line[0]
+            if "(" in atom and ")" in atom:
+                atom = atom[atom.find("("):]
+
+            iso = None
+            if index in isotopes:
+                iso = isotopes[index]
+            
+            elif atom in isotopes:
+                iso = isotopes[atom]
+            
+            if iso is not None:
+                atom = "{}(iso={})".format(atom, iso)
+            
+
+            lines.append("    ".join(
+                [atom, *split_line[1:]]
+            ))
+        
+        return "\n".join(lines)
+
         
     @property
     def xyz(self):
         """
         Get the geometry of this gaussian input file in XYZ format.
         """
-        return "{}\n\n{}".format(len(self.geometry.split("\n")), self.geometry)
+        lines = []
+        for line in self.geometry.split("\n"):
+            split_line = line.split()
+            atom = split_line[0]
+            if "(" in atom and ")" in atom:
+                atom = atom[atom.find("("):]
+            lines.append("    ".join(
+                [atom, *split_line[1:]]
+            ))
+        return "{}\n\n{}".format(len(self.geometry.split("\n")), "\n".join(lines))
 

digichem/misc/base.py

@@ -1,4 +1,5 @@
 from itertools import chain, combinations
+import math
 
 def powerset(iterable):
     "powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"
@@ -26,6 +27,17 @@ def regular_range(median, number, spacing):
             peaks.append(median - magnitude * spacing)
         
     return sorted(peaks)
+
+def round_sig(number, sig_figs):
+    """Round a number to a given number of significant figures."""
+    try:
+        return round(number, sig_figs-int(math.floor(math.log10(abs(number))))-1)
+
+    except ValueError:
+        if number == 0:
+            return 0
+        else:
+            raise
     
 
 def dict_list_index(dictionary, item):

digichem/misc/io.py

@@ -322,12 +322,17 @@ class Safe_path():
         # Close our file.
         self.close()
 
-def dir_size(target):
+def dir_size(target, apparent = False):
     """
     Calculate the total used file space of a directory and all contents.
     """
     bytes = 0
-    for path in itertools.chain(Path(target).rglob("*"), [Path(target)]):
-        bytes += path.stat().st_size
+    for path in itertools.chain(Path(target).glob('**/*'), [Path(target)]):
+        stat = path.stat()
+        if not apparent and hasattr(stat, "st_blocks"):
+            bytes += stat.st_blocks * 512
+        
+        else:
+            bytes += stat.st_size
     
     return bytes

digichem/parse/base.py

@@ -2,6 +2,10 @@
 from pathlib import Path
 import pwd
 import os
+import csv
+import numpy
+import math
+from scipy import signal
 
 from digichem.exception.base import Digichem_exception
 from digichem.result.orbital import Molecular_orbital_list,\
@@ -19,6 +23,7 @@ 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
+import digichem.log
 
 
 # NOTE: This is a repeat of the list in util to avoid circular import nonsense.
@@ -32,7 +37,7 @@ custom_parsing_formats = [
 class Parser_abc():
     """ABC for all parsers."""
 
-    def __init__(self, *, raw_data = None, options, **kwargs):
+    def __init__(self, *, raw_data = None, options, metadata_defaults = None, profile_file = None, **kwargs):
         """
         Top level constructor for calculation parsers.
         """
@@ -44,6 +49,12 @@ class Parser_abc():
 
         # Config options.
         self.options = options
+
+        # Manually provided overrides.
+        self.metadata_defaults = metadata_defaults if metadata_defaults is not None else {}
+        
+        # Save the profiling file.
+        self.profile_file = profile_file
         
         # Parse (if we haven't already).
         try:
@@ -102,6 +113,126 @@ class Parser_abc():
         # 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()
+
+        # Add any user supplied defaults.
+        metadata = self.metadata_defaults.copy()
+        metadata.update(self.data.metadata)
+        self.data.metadata = metadata
+
+        # Add profiling data.
+        try:
+            self.parse_profile_file()
+        
+        except Exception:
+            if self.profile_file and 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):
+        """
+        """
+        # Real calculations can end up with millions of rows, which is far too much data to handle.
+        # We will need to downsample if we have too many data points.
+        # First work out how many rows there are.
+        try:
+            with open(self.profile_file, "rb") as profile_file:
+                lines = sum(1 for _ in profile_file) -1 # Remove 1 line for the header.
+        
+        except FileNotFoundError:
+            # This is ok
+            return
+
+        if lines < 2:
+            return
+
+        max_lines  = self.options.parse['profiling_rows']
+        factor = math.ceil(lines / max_lines)
+        
+        with open(self.profile_file) as profile_file:
+            reader = csv.reader(profile_file)
+
+            # Get the header.
+            headers = next(reader)
+
+            # Check headers match.
+            if (headers[0] == "Duration / s" and 
+               headers[1] == "Memory Used (Real) / bytes" and
+               headers[2] == "Memory Used (Real) / %" and
+               headers[3] == "Memory Available  (Real) / bytes" and
+               headers[4] == "Memory Available (Real) / %" and
+               headers[9] == "CPU Usage / %" and
+               headers[15] == "Output Directory Available / bytes" and
+               headers[17] == "Scratch Directory Used / bytes" and
+               headers[18] == "Scratch Directory Available / bytes"
+            ):
+                column_map = {
+                    "duration": 0,
+                    "memory_used": 1,
+                    "memory_used_percent": 2,
+                    "memory_available": 3,
+                    "memory_available_percent": 4,
+                    "cpu_used": 9,
+                    "output_available": 15,
+                    "scratch_used": 17,
+                    "scratch_available": 18
+                }
+            
+            elif (headers[0] == "Duration / s" and 
+               headers[1] == "Memory Used (Real) / bytes" and
+               headers[2] == "Memory Used (Real) / %" and
+               headers[3] == "Memory Available  (Real) / bytes" and
+               headers[4] == "Memory Available (Real) / %" and
+               headers[9] == "CPU Usage / %" and
+               headers[15] == "Output Directory Available / bytes" and
+               headers[17] == "Scratch Directory Available / bytes"
+            ):
+                column_map = {
+                    "duration": 0,
+                    "memory_used": 1,
+                    "memory_used_percent": 2,
+                    "memory_available": 3,
+                    "memory_available_percent": 4,
+                    "cpu_used": 9,
+                    "output_available": 15,
+                    "scratch_available": 17
+                }
+            
+            else:
+                raise Digichem_exception("wrong headers found in profile.csv file")
+            
+            # Then the body.
+            # TODO: Reading the entire file is not ideal...
+            data = numpy.genfromtxt(
+                profile_file,
+                delimiter=',',
+                # TODO: use something better.
+                filling_values = "0"
+            )
+
+        # We'll keep:
+        # - duration
+        # - memory used
+        # - memory used %
+        # - memory available
+        # - memory available %
+        # - cpu used
+        # - output space
+        # - scratch space
+        new_data = numpy.zeros((math.ceil(lines / factor), len(column_map)))
+
+        # Now decimate.
+        for i, k in enumerate(column_map.values()):
+            if factor > 1:
+                new_data[:, i] = signal.decimate(data[:, k], factor)
+            else:
+                new_data[:, i] = data[:, k]
+        
+        
+        self.data.metadata['performance'] = {
+            key: new_data[:, index] for index, key in enumerate(column_map)
+        }
             
     def process_all(self):
         """
@@ -181,7 +312,7 @@ class Parser_abc():
 class File_parser_abc(Parser_abc):
     """ABC for all parsers."""
     
-    def __init__(self, *log_files, raw_data = None, **kwargs):
+    def __init__(self, *log_files, raw_data = None, metadata_defaults = None, **kwargs):
         """
         Top level constructor for calculation parsers.
         
@@ -189,12 +320,12 @@ class File_parser_abc(Parser_abc):
         """
         # 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?")
         
-        super().__init__(raw_data=raw_data, **kwargs)
+        super().__init__(raw_data=raw_data, metadata_defaults = metadata_defaults, **kwargs)
 
     @classmethod
     def from_logs(self, *log_files, **kwargs):

digichem/parse/cclib.py

@@ -1,9 +1,5 @@
 from pathlib import Path
 import itertools
-import csv
-import numpy
-import math
-from scipy import signal
 
 import digichem.log
 from digichem.parse.base import File_parser_abc
@@ -22,7 +18,7 @@ class Cclib_parser(File_parser_abc):
     # A dictionary of recognised auxiliary file types.
     INPUT_FILE_TYPES = {}
     
-    def __init__(self, *log_files, options, **auxiliary_files):
+    def __init__(self, *log_files, options, metadata_defaults = None, **auxiliary_files):
         """
         Top level constructor for calculation parsers.
         
@@ -31,12 +27,8 @@ class Cclib_parser(File_parser_abc):
         """
         # 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}
-
-        # TODO: Does this belong here?
-        # 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, options = options)
+        super().__init__(*log_files, options = options, metadata_defaults = metadata_defaults, profile_file = Path(log_files[0].parent, "../Logs/profile.csv"))
         
     @classmethod
     def from_logs(self, *log_files, hints = None, options, **kwargs):
@@ -132,111 +124,6 @@ class Cclib_parser(File_parser_abc):
             
             else:
                 pass
-
-    def parse_profile_file(self):
-        """
-        """
-        # Real calculations can end up with millions of rows, which is far too much data to handle.
-        # We will need to downsample if we have too many data points.
-        # First work out how many rows there are.
-        try:
-            with open(self.profile_file, "rb") as profile_file:
-                lines = sum(1 for _ in profile_file) -1 # Remove 1 line for the header.
-        
-        except FileNotFoundError:
-            # This is ok
-            return
-
-        if lines < 2:
-            return
-
-        max_lines  = self.options.parse['profiling_rows']
-        factor = math.ceil(lines / max_lines)
-        
-        with open(self.profile_file) as profile_file:
-            reader = csv.reader(profile_file)
-
-            # Get the header.
-            headers = next(reader)
-
-            # Check headers match.
-            if (headers[0] == "Duration / s" and 
-               headers[1] == "Memory Used (Real) / bytes" and
-               headers[2] == "Memory Used (Real) / %" and
-               headers[3] == "Memory Available  (Real) / bytes" and
-               headers[4] == "Memory Available (Real) / %" and
-               headers[9] == "CPU Usage / %" and
-               headers[15] == "Output Directory Available / bytes" and
-               headers[17] == "Scratch Directory Used / bytes" and
-               headers[18] == "Scratch Directory Available / bytes"
-            ):
-                column_map = {
-                    "duration": 0,
-                    "memory_used": 1,
-                    "memory_used_percent": 2,
-                    "memory_available": 3,
-                    "memory_available_percent": 4,
-                    "cpu_used": 9,
-                    "output_available": 15,
-                    "scratch_used": 17,
-                    "scratch_available": 18
-                }
-            
-            elif (headers[0] == "Duration / s" and 
-               headers[1] == "Memory Used (Real) / bytes" and
-               headers[2] == "Memory Used (Real) / %" and
-               headers[3] == "Memory Available  (Real) / bytes" and
-               headers[4] == "Memory Available (Real) / %" and
-               headers[9] == "CPU Usage / %" and
-               headers[15] == "Output Directory Available / bytes" and
-               headers[17] == "Scratch Directory Available / bytes"
-            ):
-                column_map = {
-                    "duration": 0,
-                    "memory_used": 1,
-                    "memory_used_percent": 2,
-                    "memory_available": 3,
-                    "memory_available_percent": 4,
-                    "cpu_used": 9,
-                    "output_available": 15,
-                    "scratch_available": 17
-                }
-            
-            else:
-                raise Digichem_exception("wrong headers found in profile.csv file")
-            
-            # Then the body.
-            # TODO: Reading the entire file is not ideal...
-            data = numpy.genfromtxt(
-                profile_file,
-                delimiter=',',
-                # TODO: use something better.
-                filling_values = "0"
-            )
-
-        # We'll keep:
-        # - duration
-        # - memory used
-        # - memory used %
-        # - memory available
-        # - memory available %
-        # - cpu used
-        # - output space
-        # - scratch space
-        new_data = numpy.zeros((math.ceil(lines / factor), len(column_map)))
-
-        # Now decimate.
-        for i, k in enumerate(column_map.values()):
-            if factor > 1:
-                new_data[:, i] = signal.decimate(data[:, k], factor)
-            else:
-                new_data[:, i] = data[:, k]
-        
-        
-        self.data.metadata['performance'] = {
-            key: new_data[:, index] for index, key in enumerate(column_map)
-        }
-        
         
     def parse_output_line(self, log_file, line):
         """