digichem-core 7.0.4__tar.gz → 7.2.0__tar.gz

{digichem_core-7.0.4 → digichem_core-7.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digichem-core
-Version: 7.0.4
+Version: 7.2.0
 Summary: Open-source library for Digichem core components
 Project-URL: Homepage, https://github.com/Digichem-Project/digichem-core
 Project-URL: Documentation, https://doc.digi-chem.co.uk
@@ -52,7 +52,7 @@ Welcome to Digichem: the computational chemistry management suite!
 This is Digichem-core, the open-source library for Digichem. If you are looking to build your own computational workflows using the tools that Digichem has to offer, then you have come to the right place.
 
  - Alternatively, if you are looking for the full Digichem program, try [Build-boy](https://github.com/Digichem-Project/build-boy)
- - If you'd like more information on the Digichem project, check out the [website](https://www.digi-chem.co.uk)
+ - If you'd like more information on the Digichem project, check out the [website](https://digi-chem.co.uk)
 
 ## Documentation
 

{digichem_core-7.0.4 → digichem_core-7.2.0}/README.md

@@ -7,7 +7,7 @@ Welcome to Digichem: the computational chemistry management suite!
 This is Digichem-core, the open-source library for Digichem. If you are looking to build your own computational workflows using the tools that Digichem has to offer, then you have come to the right place.
 
  - Alternatively, if you are looking for the full Digichem program, try [Build-boy](https://github.com/Digichem-Project/build-boy)
- - If you'd like more information on the Digichem project, check out the [website](https://www.digi-chem.co.uk)
+ - If you'd like more information on the Digichem project, check out the [website](https://digi-chem.co.uk)
 
 ## Documentation
 

{digichem_core-7.0.4 → digichem_core-7.2.0}/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.2.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 = "18/12/2025"
 last_updated = datetime.strptime(_last_updated_string, "%d/%m/%Y")
 
 # The sys attribute 'frozen' is our flag, '_MEIPASS' is the dir location.

{digichem_core-7.0.4 → digichem_core-7.2.0}/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_core-7.0.4 → digichem_core-7.2.0}/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_core-7.0.4 → digichem_core-7.2.0}/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_core-7.0.4 → digichem_core-7.2.0}/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_core-7.0.4 → digichem_core-7.2.0}/digichem/parse/base.py

@@ -32,7 +32,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, **kwargs):
         """
         Top level constructor for calculation parsers.
         """
@@ -44,6 +44,9 @@ class Parser_abc():
 
         # Config options.
         self.options = options
+
+        # Manually provided overrides.
+        self.metadata_defaults = metadata_defaults if metadata_defaults is not None else {}
         
         # Parse (if we haven't already).
         try:
@@ -102,6 +105,11 @@ 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
             
     def process_all(self):
         """
@@ -181,7 +189,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.
         
@@ -194,7 +202,7 @@ class File_parser_abc(Parser_abc):
         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_core-7.0.4 → digichem_core-7.2.0}/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, options, **auxiliary_files):
+    def __init__(self, *log_files, options, metadata_defaults = None, **auxiliary_files):
         """
         Top level constructor for calculation parsers.
         
@@ -36,7 +36,7 @@ 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, options = options)
+        super().__init__(*log_files, options = options, metadata_defaults = metadata_defaults)
         
     @classmethod
     def from_logs(self, *log_files, hints = None, options, **kwargs):

{digichem_core-7.0.4 → digichem_core-7.2.0}/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", options, **auxiliary_files):
+    def __init__(self, *log_files, rwfdump = "rwfdump", options, metadata_defaults = None, **auxiliary_files):
         self.rwfdump = rwfdump
-        super().__init__(*log_files, options = options, **auxiliary_files)
+        super().__init__(*log_files, options = options, metadata_defaults = metadata_defaults, **auxiliary_files)
     
     def parse_metadata(self):
         """

{digichem_core-7.0.4 → digichem_core-7.2.0}/digichem/parse/pyscf.py

@@ -18,11 +18,23 @@ class Pyscf_parser(Parser_abc):
         super().__init__(**kwargs)
 
     def _parse(self):
+        """
+        Extract results from our output files.
+        """
         self.data = cclibfrommethods(**self.methods)
-        
+    
+    def post_parse(self):
+        """
+        Perform any required operations after line-by-line parsing.
+        """ 
+        super().post_parse()
+        # Set some metadata objects.
+        self.data.metadata['name'] = self.mol_name
+        self.data._aux = {'methods': self.methods}
+
         try:
             # Try to generate a checksum from metadata.
-            self.data._id = hashlib.sha1(json.dumps(self.data.metadata, sort_keys = True).encode('utf-8')).hexdigest()
+            self.data._id = hashlib.sha1(json.dumps(self.data.metadata, sort_keys = True, default = str).encode('utf-8')).hexdigest()
 
         except Exception:
             # No luck, something in metadata must be unhashable.
@@ -30,6 +42,4 @@ class Pyscf_parser(Parser_abc):
             # TODO: Think of a better way to do this.
             self.data._id = hashlib.sha1(uuid4().hex.encode('utf-8')).hexdigest()
         
-        self.data.metadata['name'] = self.mol_name
-        self.data._aux = {'methods': self.methods}
             

{digichem_core-7.0.4 → digichem_core-7.2.0}/digichem/result/atom.py

@@ -255,6 +255,14 @@ class Atom_list(Result_container, Unmergeable_container_mixin, Molecule_mixin):
             
         return self._groups
     
+    @property
+    def bond_matrix(self):
+        """
+        Get the bond distance matrix for this molecule, which indicates how many bonds separate each atom in the molecule.
+        """
+        from rdkit import Chem
+        return Chem.rdmolops.GetDistanceMatrix(self.to_rdkit_molecule())
+    
     def find(self, criteria = None, *, label = None, index = None):
         """
         Find an atom that matches a given criteria

{digichem_core-7.0.4 → digichem_core-7.2.0}/digichem/result/nmr.py

@@ -5,6 +5,7 @@ from fractions import Fraction
 import re
 import statistics
 import math
+from configurables.misc import is_int
 
 from digichem.misc.base import regular_range, powerset
 from digichem.exception.base import Result_unavailable_error
@@ -545,6 +546,9 @@ class NMR_list(Result_container):
         # First, decide which atoms are actually equivalent.
         # We can do this by comparing canonical SMILES groupings.
         atom_groups = self.atoms.groups
+
+        # Also get the bond distance matrix for the molecule, so we can work out which couplings are actually equivalent.
+        bond_matrix = self.atoms.bond_matrix
         
         nmr_groups = {}
         # Next, assemble group objects.
@@ -565,12 +569,34 @@ class NMR_list(Result_container):
         # We need to do this after initial group assembly in order to discard self coupling.
         # Get unique couplings (so we don't consider any twice).
         group_couplings = {}
-        unique_couplings = {(coupling.atoms, coupling.isotopes): coupling for group in nmr_groups.values() for coupling in group['couplings']}.values()        
+        unique_couplings = list({(coupling.atoms, coupling.isotopes): coupling for group in nmr_groups.values() for coupling in group['couplings']}.values())
         for coupling in unique_couplings:
             # Find the group numbers that correspond to the two atoms in the coupling.
-            coupling_groups = tuple([atom_group.id for atom_group in atom_groups.values() if atom in atom_group.atoms][0] for atom in coupling.atoms)
-            
-            isotopes = coupling.isotopes
+            coupling_groups = tuple(
+                [atom_group.id for atom_group in atom_groups.values() if atom in atom_group.atoms][0] for atom in coupling.atoms
+            )
+
+            # We need to ensure that coupling_groups is a unique representation of the coupling,
+            # the ordering should be fixed.
+            indices = [
+                int(coupling_groups[0] >= coupling_groups[1]),
+                int(coupling_groups[0] < coupling_groups[1])
+            ]
+            coupling_groups = (
+                coupling_groups[indices[0]],
+                coupling_groups[indices[1]]
+            )
+            isotopes = (
+                coupling.isotopes[indices[0]],
+                coupling.isotopes[indices[1]]
+            )
+
+            # The group key contains the two atom groups, and the distance between them.
+            coupling_groups = (
+                coupling_groups[0],
+                coupling_groups[1],
+                float(bond_matrix[coupling.atoms[0].index -1][coupling.atoms[1].index -1])
+            )
             
             # Append the isotropic coupling constant to the group.
             if coupling_groups not in group_couplings:
@@ -582,12 +608,14 @@ class NMR_list(Result_container):
             group_couplings[coupling_groups][isotopes].append(coupling)
             
         # Average each 'equivalent' coupling.
-        group_couplings = {
+        average_couplings = {
             group_key: {
                 isotope_key: NMR_group_spin_coupling(
-                    groups = [atom_groups[group_sub_key] for group_sub_key in group_key],
+                    # TODO: Add in bond distance.
+                    groups = [atom_groups[group_sub_key] for group_sub_key in group_key[:2]],
                     isotopes = isotope_key,
-                    couplings = isotope_couplings
+                    couplings = isotope_couplings,
+                    distance = group_key[2]
                 ) for isotope_key, isotope_couplings in  isotopes.items()}
             for group_key, isotopes in group_couplings.items()
         }
@@ -599,11 +627,11 @@ class NMR_list(Result_container):
             
             coupling = [
                 isotope_coupling
-                for group_key, group_coupling in group_couplings.items()
+                for group_key, group_coupling in average_couplings.items()
                     for isotope_coupling in group_coupling.values()
-                        if group_id in group_key
+                        if group_id in group_key[:2]
             ]
-            nmr_object_groups[raw_group['group']] = (NMR_group(raw_group['group'], raw_group['shieldings'], coupling))
+            nmr_object_groups[raw_group['group']] = NMR_group(raw_group['group'], raw_group['shieldings'], coupling)
         
         return nmr_object_groups
     
@@ -650,7 +678,10 @@ class NMR_group(Result_object, Floatable_mixin):
     def __init__(self, group, shieldings, couplings):
         self.group = group
         self.shieldings = shieldings
-        self.couplings = couplings
+        self.couplings = sorted(
+            couplings,
+            key = lambda coupling: abs(coupling.total)
+        )
         
         # Calculate average shieldings and couplings.
         self.shielding = float(sum([shielding.isotropic("total") for shielding in shieldings]) / len(shieldings))
@@ -678,15 +709,17 @@ class NMR_group_spin_coupling(Result_object):
     A result object containing the average coupling between two different groups of nuclei.
     """
     
-    def __init__(self, groups, isotopes, couplings):
+    def __init__(self, groups, isotopes, couplings, distance = None):
         """
         :param groups: The two atom groups that this coupling is between.
         :param isotopes: The isotopes of the two groups (the order should match that of groups).
         :param couplings: A list of individual coupling constants between the atoms of these two groups.
+        :param distance: The bond distance between the two atoms.
         """
         self.groups = groups
         self.isotopes = isotopes
         self.couplings = couplings
+        self.distance = int(distance) if distance is not None and is_int(distance) else distance
         
     @property
     def total(self):
@@ -705,6 +738,10 @@ class NMR_group_spin_coupling(Result_object):
             "total": {
                 "units": "Hz",
                 "value": float(self.total),
+            },
+            "distance": {
+                "units": "bonds",
+                "value": self.distance
             }
             #"couplings": [coupling.dump(digichem_options, all) for coupling in self.couplings]
         }
@@ -721,7 +758,19 @@ class NMR_group_spin_coupling(Result_object):
         """
         Calculate the number of atoms one of the atom groups is coupled to.
         """
-        second_index = self.other(atom_group)
+        # second_index = self.other(atom_group)
+
+        # if [group.label for group in self.groups] == ["H9", "H10"] or [group.label for group in self.groups] == ["H10", "H9"]:
+        #     print()
+
+        # atoms = []
+        # for coupling in self.couplings:
+        #     for atom in coupling.atoms:
+        #         if atom not in atom_group.atoms:
+        #             atoms.append(atom)
+        
+        # return len(list(set(atoms)))
+
         return int(len(self.couplings) / len(atom_group.atoms))
         
     def multiplicity(self, atom_group):
@@ -845,11 +894,11 @@ class NMR_tensor_ABC(Result_object):
     tensor_names = ()
     units = ""
     
-    def __init__(self, tensors):
+    def __init__(self, tensors, total_isotropic = None):
         self.tensors = tensors
         
         # This is unused.
-        #self.total_isotropic = total_isotropic
+        self.total_isotropic = total_isotropic
     
     def eigenvalues(self, tensor = "total", real_only = True):
         """
@@ -862,10 +911,10 @@ class NMR_tensor_ABC(Result_object):
         
         except KeyError:
             if tensor not in self.tensor_names:
-                raise ValueError("The tensor '{}' is not recognised") from None
+                raise ValueError("The tensor '{}' is not recognised".format(tensor)) from None
             
             elif tensor not in self.tensors:
-                raise ValueError("The tensor '{}' is not available") from None
+                raise ValueError("The tensor '{}' is not available".format(tensor)) from None
         
     def isotropic(self, tensor = "total"):
         """
@@ -873,8 +922,17 @@ class NMR_tensor_ABC(Result_object):
         
         :param tensor: The name of a tensor to calculate for (see tensor_names). Use 'total' for the total tensor.
         """
-        eigenvalues = self.eigenvalues(tensor)
-        return sum(eigenvalues) / len(eigenvalues)
+        try:
+            eigenvalues = self.eigenvalues(tensor)
+            return sum(eigenvalues) / len(eigenvalues)
+
+        except ValueError:
+            if tensor == "total" and self.total_isotropic is not None:
+                # Use the fallback.
+                return self.total_isotropic
+
+            else:
+                raise
     
     def _dump_(self, digichem_options, all):
         """
@@ -895,12 +953,12 @@ class NMR_shielding(NMR_tensor_ABC):
     tensor_names = ("paramagnetic", "diamagnetic", "total")
     units = "ppm"
     
-    def __init__(self, tensors, reference = None):
+    def __init__(self, tensors, reference = None, total_isotropic = None):
         """
         :param tensors: A dictionary of tensors.
         :param reference: An optional reference isotropic value to correct this shielding by.
         """
-        super().__init__(tensors)
+        super().__init__(tensors, total_isotropic)
         self.reference = reference
         
     def isotropic(self, tensor = "total", correct = True):
@@ -910,8 +968,18 @@ class NMR_shielding(NMR_tensor_ABC):
         :param tensor: The name of a tensor to calculate for (see tensor_names). Use 'total' for the total tensor.
         :param correct: Whether to correct this shielding value by the reference.
         """
-        eigenvalues = self.eigenvalues(tensor)
-        absolute = sum(eigenvalues) / len(eigenvalues)
+        try:
+            eigenvalues = self.eigenvalues(tensor)
+            absolute = sum(eigenvalues) / len(eigenvalues)
+        
+        except ValueError:
+            if tensor == "total" and self.total_isotropic is not None:
+                # Use the fallback.
+                absolute = self.total_isotropic
+            
+            else:
+                raise None
+
         if correct and self.reference is not None:
             return self.reference - absolute
         else:
@@ -932,7 +1000,8 @@ class NMR_shielding(NMR_tensor_ABC):
                 total_isotropic = tensors.pop("isotropic")
                 shieldings[parser.results.atoms[atom_index]] = self(
                     tensors,
-                    reference = parser.options['nmr']['standards'].get(parser.results.atoms[atom_index].element.symbol, None)
+                    reference = parser.options['nmr']['standards'].get(parser.results.atoms[atom_index].element.symbol, None),
+                    total_isotropic = total_isotropic
                 )
         
         except AttributeError:
@@ -1036,13 +1105,13 @@ class NMR_spin_coupling(NMR_tensor_ABC):
     tensor_names = ("paramagnetic", "diamagnetic", "fermi", "spin-dipolar", "spin-dipolar-fermi", "total")
     units = "Hz"
     
-    def __init__(self, atoms, isotopes, tensors):
+    def __init__(self, atoms, isotopes, tensors, total_isotropic = None):
         """
         :param atoms: Tuple of atoms that this coupling is between.
         :param isotopes: Tuple of the specific isotopes of atoms.
         :param tensors: A dictionary of tensors.
         """
-        super().__init__(tensors)
+        super().__init__(tensors, total_isotropic = total_isotropic)
         self.atoms = atoms
         self.isotopes = isotopes
         
@@ -1059,7 +1128,14 @@ class NMR_spin_coupling(NMR_tensor_ABC):
             for atom_tuple, isotopes in parser.data.nmrcouplingtensors.items():
                 for isotope_tuple, tensors in isotopes.items():
                     total_isotropic = tensors.pop("isotropic")
-                    couplings.append(self((parser.results.atoms[atom_tuple[0]], parser.results.atoms[atom_tuple[1]]), isotope_tuple, tensors))
+                    couplings.append(
+                        self(
+                            (parser.results.atoms[atom_tuple[0]], parser.results.atoms[atom_tuple[1]]),
+                            isotope_tuple,
+                            tensors,
+                            total_isotropic = total_isotropic
+                        )
+                    )
         
         except AttributeError:
             return []

{digichem_core-7.0.4 → digichem_core-7.2.0}/digichem/result/spectroscopy.py

@@ -420,7 +420,7 @@ class NMR_graph(Spectroscopy_graph):
     For plotting an entire spectrum, use a Combined_graph of NMR_graph objects.
     """
     
-    def multiplicity(self, atom_group, coupling, satellite_threshold = 0.02):
+    def multiplicity(self, atom_group, coupling, satellite_threshold = 0.05):
         """
         Determine the multiplicity of this peak.
         
@@ -456,7 +456,7 @@ class NMR_graph(Spectroscopy_graph):
         # For atoms in which the majority of the abundance is already accounted for (1H, for example),
         # exclude the residual peak.
         residual_isotope_peaks = set(
-            [atom_group for atom_group, isotopes in coupling.items() if sum((atom_group.element[isotope].abundance for isotope in isotopes.keys())) / 100 > satellite_threshold]
+            [a_group for a_group, isotopes in coupling.items() if sum((a_group.element[isotope].abundance for isotope in isotopes.keys())) / 100 > satellite_threshold]
         )
         
         # We will keep requesting more splitting until we are able to account for all the peaks we can see.

{digichem_core-7.0.4 → digichem_core-7.2.0}/digichem/test/test_input.py

@@ -4,7 +4,7 @@ import pytest
 from pathlib import Path
 
 from digichem.test.util import pyridine_si_v2, pyridine_si_v1, pyridine_cml,\
-    result_files, ethane_xyz, benzene_cdx, cyclopentane_com
+    result_files, ethane_xyz, benzene_cdx, cyclopentane_com, cyclopentane_iso_com
 from digichem.input.digichem_input import si_from_file
 
 @pytest.mark.parametrize("file_path", [
@@ -66,6 +66,7 @@ def test_si_history(file_path, sha):
 
 @pytest.mark.parametrize("file_path, format", [
     (cyclopentane_com, "mol"),
+    (cyclopentane_iso_com, "mol"),
     (ethane_xyz, "cml"),
     (benzene_cdx, "xyz"),
     (result_files['gaussian'][0], "com")

{digichem_core-7.0.4 → digichem_core-7.2.0}/digichem/test/test_result.py

@@ -465,8 +465,8 @@ def test_nmr_h_isotope_options(orca_nmr_result):
     # Check we have the right options set for H.
     options = orca_nmr_result.nmr.spectrometer.isotope_options(1, 1)
     assert options['frequency'] == 400
-    assert options['fwhm'] == 0.005
-    assert options['gaussian_resolution'] == 0.0005
+    assert options['fwhm'] == 0.0015
+    assert options['gaussian_resolution'] == 0.0001
     assert options['coupling_filter'] == 0.001
     assert options['pre_merge'] == 0.0005
 

{digichem_core-7.0.4 → digichem_core-7.2.0}/digichem/test/util.py

@@ -18,6 +18,7 @@ def data_directory():
 benzene_cdx = Path(data_directory(), "Input", "Benzene.cdx")
 pyridine_cml = Path(data_directory(), "Input", "Pyridine.cml")
 cyclopentane_com = Path(data_directory(), "Input", "Cyclopentane.com")
+cyclopentane_iso_com = Path(data_directory(), "Input", "Cyclopentane_iso.com")
 water_xyz = Path(data_directory(), "Input", "Water.xyz")
 ethane_xyz = Path(data_directory(), "Input", "Ethane.xyz")
 pyridine_si_v2 = Path(data_directory(), "Input/Pyridine.v2.si")