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

digichem/parse/censo.py

@@ -0,0 +1,135 @@
+import hashlib
+import json
+import datetime
+import periodictable
+from uuid import uuid4
+import types
+
+from digichem.parse.base import Parser_abc
+import digichem.log
+from digichem.input.digichem_input import si_from_file
+
+
+class Censo_parser(Parser_abc):
+    """
+    Top level class for parsing output from censo data.
+    """
+
+    def __init__(self, mol_name, program, **kwargs):
+        self.program = program
+        self.mol_name = mol_name
+        super().__init__(**kwargs)
+
+    def _parse(self):
+        """
+        Extract results from our output files.
+        """
+        self.data = types.SimpleNamespace()
+
+        # Censo calculations are normally made up of four distinct phases (prescreening, screening, optimisation, and refinement).
+        calculations = []
+        methods = []
+        functional = []
+        basis_set = []
+        engines = []
+
+        if self.program.calculation.properties['prescreening']['calc']:
+            calculations.append("Screening")
+            methods.append(self.program.calculation.properties['prescreening']['gfn'])
+            methods.append("DFT")
+            engines.append(self.program.calculation.properties['prescreening']['engine'])
+            functional.append(self.program.calculation.properties['prescreening']['functional'])
+            basis_set.append(self.program.calculation.properties['prescreening']['basis_set'])
+        
+        if self.program.calculation.properties['screening']['calc']:
+            calculations.append("Screening")
+            methods.append(self.program.calculation.properties['screening']['gfn'])
+            methods.append("DFT")
+            engines.append(self.program.calculation.properties['screening']['engine'])
+            functional.append(self.program.calculation.properties['screening']['functional'])
+            basis_set.append(self.program.calculation.properties['screening']['basis_set'])
+        
+        if self.program.calculation.properties['optimisation']['calc']:
+            calculations.append("Optimisation")
+            methods.append(self.program.calculation.properties['optimisation']['gfn'])
+            methods.append("DFT")
+            engines.append(self.program.calculation.properties['optimisation']['engine'])
+            functional.append(self.program.calculation.properties['optimisation']['functional'])
+            basis_set.append(self.program.calculation.properties['optimisation']['basis_set'])
+        
+        if self.program.calculation.properties['refinement']['calc']:
+            calculations.append("Single Point")
+            methods.append(self.program.calculation.properties['refinement']['gfn'])
+            methods.append("DFT")
+            engines.append(self.program.calculation.properties['refinement']['engine'])
+            functional.append(self.program.calculation.properties['refinement']['functional'])
+            basis_set.append(self.program.calculation.properties['refinement']['basis_set'])
+
+        engines = ["CENSO"] + list(set(engines))
+
+        # Metadata we can get entirely from our passed in program object.
+        self.data.metadata = {
+            "name": self.mol_name,
+            "jobId": self.program.calculation.job_id,
+            "wall_time": [self.program.duration],
+            "cpu_time": [self.program.duration * self.program.calculation.performance['num_cpu']],
+            "date": datetime.datetime.now(datetime.timezone.utc).timestamp(),
+            "package": "/".join(engines),
+            #"package_version": None,
+            "calculations": calculations,
+            "success": not self.program.error,
+            "methods": methods,
+            "functional": "/".join(functional),
+            "basis_set": "/".join(basis_set),
+            "charge": self.program.calculation.charge,
+            "multiplicity": self.program.calculation.multiplicity,
+            "optimisation_converged": not self.program.error,
+            #"temperature": None,
+            #"pressure": None,
+            "orbital_spin_type": "restricted" if self.program.calculation.multiplicity == 1 else "unrestricted",
+            "solvent_name": str(self.program.calculation.solution['solvent']) if self.program.calculation.solution['calc'] else None,
+            "solvent_model": self.program.calculation.solution['model'] if self.program.calculation.solution['calc'] else None,
+            "num_cpu": self.program.calculation.performance['num_cpu'],
+            #"memory_used": None,
+            "memory_available": self.program.calculation.performance['memory'],
+        }
+
+        try:
+            coord_file = self.program.next_coords
+        
+        except Exception:
+            coord_file = None
+        
+        if coord_file:
+            main_si = si_from_file(coord_file, gen3D = False, charge = self.program.calculation.charge, multiplicity = self.program.calculation.multiplicity)
+            
+            self.data.atomnos = []
+            self.data.atomcoords = [[]]
+            
+            for atom in main_si.atoms:
+                self.data.atomnos.append(periodictable.elements.symbol(atom['atom']).number)
+                self.data.atomcoords[0].append(
+                    [
+                        atom['x'],
+                        atom['y'],
+                        atom['z']
+                    ]
+                )
+    
+    def post_parse(self):
+        """
+        Perform any required operations after line-by-line parsing.
+        """ 
+        super().post_parse()
+
+        try:
+            # Try to generate a checksum from metadata.
+            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.
+            digichem.log.get_logger().error("Unable to generate hash ID from calculation metadata, using random ID instead", exc_info = True)
+            # TODO: Think of a better way to do this.
+            self.data._id = hashlib.sha1(uuid4().hex.encode('utf-8')).hexdigest()
+        
+            

digichem/parse/crest.py

@@ -0,0 +1,89 @@
+import hashlib
+import json
+import datetime
+import periodictable
+from uuid import uuid4
+import types
+
+from digichem.parse.base import Parser_abc
+import digichem.log
+from digichem.input.digichem_input import si_from_file
+
+
+
+class Crest_parser(Parser_abc):
+    """
+    Top level class for parsing output from crest data.
+    """
+    
+    def __init__(self, mol_name, program, **kwargs):
+        self.program = program
+        self.mol_name = mol_name
+        super().__init__(**kwargs)
+
+    def _parse(self):
+        """
+        Extract results from our output files.
+        """
+        self.data = types.SimpleNamespace()
+
+        # Metadata we can get entirely from our passed in program object.
+        self.data.metadata = {
+            "name": self.mol_name,
+            "jobId": self.program.calculation.job_id,
+            "wall_time": [self.program.duration],
+            "cpu_time": [self.program.duration * self.program.calculation.performance['num_cpu']],
+            "date": datetime.datetime.now(datetime.timezone.utc).timestamp(),
+            "package": "CREST",
+            #"package_version": None,
+            "calculations": ["Optimisation"],
+            "success": not self.program.error,
+            "methods": [self.program.calculation.method['gfn']['level']],
+            "charge": self.program.calculation.charge,
+            "multiplicity": self.program.calculation.multiplicity,
+            "optimisation_converged": not self.program.error,
+            #"temperature": None,
+            #"pressure": None,
+            # TODO: CREST doesn't actually use orbitals...
+            "orbital_spin_type": "restricted",
+            "solvent_name": str(self.program.calculation.solution['solvent']) if self.program.calculation.solution['calc'] else None,
+            "solvent_model": self.program.calculation.solution['model'] if self.program.calculation.solution['calc'] else None,
+            "num_cpu": self.program.calculation.performance['num_cpu'],
+            #"memory_used": None,
+            "memory_available": self.program.calculation.performance['memory'],
+        }
+
+        # Crest calculations are normally used for conformer searching, so we should expect multiple structures as output.
+        # We'll use the lowest energy conformer as our 'main' structure.
+        main_si = si_from_file(self.program.working_directory / "crest_conformers.xyz", gen3D = False, charge = self.program.calculation.charge, multiplicity = self.program.calculation.multiplicity)
+        
+        self.data.atomnos = []
+        self.data.atomcoords = [[]]
+        
+        for atom in main_si.atoms:
+            self.data.atomnos.append(periodictable.elements.symbol(atom['atom']).number)
+            self.data.atomcoords[0].append(
+                [
+                    atom['x'],
+                    atom['y'],
+                    atom['z']
+                ]
+            )
+    
+    def post_parse(self):
+        """
+        Perform any required operations after line-by-line parsing.
+        """ 
+        super().post_parse()
+
+        try:
+            # Try to generate a checksum from metadata.
+            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.
+            digichem.log.get_logger().error("Unable to generate hash ID from calculation metadata, using random ID instead", exc_info = True)
+            # TODO: Think of a better way to do this.
+            self.data._id = hashlib.sha1(uuid4().hex.encode('utf-8')).hexdigest()
+        
+            

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/parse/pyscf.py

@@ -7,6 +7,7 @@ from cclib.bridge.cclib2pyscf import cclibfrommethods
 from digichem.parse.base import Parser_abc
 import digichem.log
 
+
 class Pyscf_parser(Parser_abc):
     """
     Top level class for parsing output from pyscf data.
@@ -18,11 +19,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 +43,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/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
@@ -310,28 +318,30 @@ class Atom_list(Result_container, Unmergeable_container_mixin, Molecule_mixin):
             return self._smiles
         
         except AttributeError:
-            # Cache miss, go do some work.
+            pass
+        
+        # Cache miss, go do some work.
 
-            from rdkit.Chem import MolToSmiles
-            from rdkit.Chem.rdmolops import RemoveHs
-            
-            # TODO: Find some other way of generating SMILES.
+        from rdkit.Chem import MolToSmiles
+        from rdkit.Chem.rdmolops import RemoveHs
+        
+        # TODO: Find some other way of generating SMILES.
 
-            mol = self.to_rdkit_molecule()
-            try:
-                # TODO: rdkit is unreliable, this method can fail for lots of reasons...
-                mol = RemoveHs(mol)
-            except Exception:
-                pass
-                
-            self._smiles = MolToSmiles(mol)
-            return self._smiles
+        mol = self.to_rdkit_molecule()
+        try:
+            # TODO: rdkit is unreliable, this method can fail for lots of reasons...
+            mol = RemoveHs(mol)
+        except Exception:
+            pass
+            
+        self._smiles = MolToSmiles(mol)
+        return self._smiles
 
-            # # TODO: Handle cases where obabel isn't available
-            # conv = Openprattle_converter.get_cls("xyz")(input_file = self.to_xyz(), input_file_type = "xyz")
-            # # Cache the result in case we need it again.
-            # self._smiles = conv.convert("can").strip()
-            # return self._smiles
+        # # TODO: Handle cases where obabel isn't available
+        # conv = Openprattle_converter.get_cls("xyz")(input_file = self.to_xyz(), input_file_type = "xyz")
+        # # Cache the result in case we need it again.
+        # self._smiles = conv.convert("can").strip()
+        # return self._smiles
         
     @property
     def X_length(self):
@@ -559,9 +569,16 @@ class Atom_list(Result_container, Unmergeable_container_mixin, Molecule_mixin):
             rdDetermineBonds.DetermineBonds(mol, charge = self.charge)
         
         except Exception:
+            #formula_string may also not be implemented...
+            try:
+                formula_string = self.formula_string
+
+            except Exception:
+                formula_string = None
+            
             # This function is not implemented for some atoms (eg, Se).
             digichem.log.get_logger().warning(
-                "Unable to determine bond ordering for molecule; all bonds will be represented as single bonds only".format(self.formula_string)
+                "Unable to determine bond ordering for '{}'; all bonds will be represented as single bonds only".format(formula_string)
                 , exc_info = True
             )
         

digichem/result/metadata.py

@@ -354,6 +354,9 @@ class Metadata(Result_object):
         calculations = []
         if "Single Point" in self.calculations:
             calculations.append("single point energy")
+
+        if "Screening" in self.calculations:
+            calculations.append("conformer screening")
         
         if "Optimisation" in self.calculations:
             calculations.append("optimised structure")

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/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.