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

digichem/result/metadata.py

@@ -46,10 +46,10 @@ class Solvent(Result_object):
     @classmethod
     def from_parser(self, parser):
         """
-        Construct a Metadata object from an output file parser.
+        Construct a Solvent object from an output file parser.
         
         :param parser: Output data parser.
-        :return: A populated Metadata object.
+        :return: A populated Solvent object.
         """
         return self(
             name = parser.data.metadata.get('solvent_name', None),
@@ -78,7 +78,7 @@ class Solvent(Result_object):
         else:
             return "Unknown"
         
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         return {
             "model": self.model,
             "name": self.name,
@@ -142,6 +142,7 @@ class Metadata(Result_object):
     
     def __init__(
             self,
+            jobId = None,
             name = None,
             user = None,
             log_files = None,
@@ -177,6 +178,7 @@ class Metadata(Result_object):
         """
         Constructor for result Metadata objects.
         
+        :param jobId: If this result was generated from a digichem calculation, the relevant jobID.
         :param name: Optional name of this calculation result.
         :param user: The username of the user who parsed this result.
         :param log_files: An optional list of text-based calculation log files from which this result was parsed.
@@ -203,6 +205,7 @@ class Metadata(Result_object):
         :param memory_available: The maximum amount of memory available to this calculation (the amount requested by the user).
         :param memory_used: The maximum amount of memory used by the calculation (the amount requested by the user).
         """
+        self.jobId = jobId
         self.num_calculations = 1
         self.name = name
         self.user = user
@@ -453,6 +456,7 @@ class Metadata(Result_object):
             
             # TODO: This doesn't seem to make sense; the parser already contains a metadata object...
             return self(
+                jobId = parser.data.metadata.get('jobId', None),
                 name = parser.data.metadata.get('name', None),
                 user = parser.data.metadata.get('user', None),
                 log_files = parser.data.metadata.get('log_files', None),
@@ -485,7 +489,7 @@ class Metadata(Result_object):
             # There is no metadata available, give up.
             raise Result_unavailable_error("Metadata", "no metadata is available")
         
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
@@ -497,6 +501,7 @@ class Metadata(Result_object):
         }
         
         attrs = [
+            "jobId",
             "history",
             "charge",
             "multiplicity",
@@ -538,7 +543,7 @@ class Metadata(Result_object):
             "value": self.pressure,
             "units": "atm"
         }
-        attr_dict["solvent"] = self.solvent.dump(digichem_options)
+        attr_dict["solvent"] = self.solvent.dump(digichem_options, all)
         
         attr_dict['num_cpu'] = self.num_cpu
         for attr_name in ("memory_used", "memory_available"):
@@ -554,7 +559,7 @@ class Metadata(Result_object):
                     "units": None
                 }
         
-        attr_dict['performance'] = self.performance.dump(digichem_options) if self.performance else None
+        attr_dict['performance'] = self.performance.dump(digichem_options, all) if self.performance else None
 
         return attr_dict
     
@@ -679,8 +684,9 @@ class Performance(Result_object):
         memory_available = [],
         memory_available_percent = [],
         cpu_used = [],
-        output_space = [],
-        scratch_space = [],
+        output_available = [],
+        scratch_used = [],
+        scratch_available = [],
         memory_allocated = None,
         cpu_allocated = None,
     ):
@@ -690,11 +696,22 @@ class Performance(Result_object):
         self.memory_available = memory_available
         self.memory_available_percent = memory_available_percent
         self.cpu_used = cpu_used
-        self.output_space = output_space
-        self.scratch_space = scratch_space
+        self.output_available = output_available
+        self.scratch_used = scratch_used
+        self.scratch_available = scratch_available
 
         self.memory_allocated = memory_allocated if memory_allocated is not None else self.max_mem
         self.cpu_allocated = cpu_allocated if cpu_allocated is not None else math.ceil(max(cpu_used) / 100)
+
+    @property
+    def output_space(self):
+        warnings.warn("output_space is deprecated, use output_available instead", DeprecationWarning)
+        return self.output_available
+
+    @property
+    def scratch_space(self):
+        warnings.warn("scratch_space is deprecated, use scratch_available instead", DeprecationWarning)
+        return self.scratch_available
     
 
     @classmethod
@@ -706,16 +723,17 @@ class Performance(Result_object):
         :return: A populated Performance object.
         """
         return self(
-            duration = parser.data.metadata['performance'][:, 0].tolist(),
-            memory_used = parser.data.metadata['performance'][:, 1].tolist(),
+            duration = parser.data.metadata['performance']['duration'].tolist(),
+            memory_used = parser.data.metadata['performance']['memory_used'].tolist(),
             memory_allocated = Memory(parser.data.metadata['memory_available']) if "memory_available" in parser.data.metadata else None,
-            memory_used_percent = parser.data.metadata['performance'][:, 2].tolist(),
-            memory_available = parser.data.metadata['performance'][:, 3].tolist(),
-            memory_available_percent = parser.data.metadata['performance'][:, 4].tolist(),
-            cpu_used = parser.data.metadata['performance'][:, 5].tolist(),
+            memory_used_percent = parser.data.metadata['performance']['memory_used_percent'].tolist(),
+            memory_available = parser.data.metadata['performance']['memory_available'].tolist(),
+            memory_available_percent = parser.data.metadata['performance']['memory_available_percent'].tolist(),
+            cpu_used = parser.data.metadata['performance']['cpu_used'].tolist(),
             cpu_allocated = parser.data.metadata.get('num_cpu', None),
-            output_space = parser.data.metadata['performance'][:, 6].tolist(),
-            scratch_space = parser.data.metadata['performance'][:, 7].tolist()
+            output_available = parser.data.metadata['performance']['output_available'].tolist(),
+            scratch_used = parser.data.metadata['performance']['scratch_used'].tolist() if 'scratch_used' in parser.data.metadata['performance'] else [0] * len(parser.data.metadata['performance']['duration']),
+            scratch_available = parser.data.metadata['performance']['scratch_available'].tolist()
         )
     
     @property
@@ -788,8 +806,9 @@ class Performance(Result_object):
         memory_available_percent = [0.0] * len(data['values'])
         cpu_used = [0.0] * len(data['values'])
         cpu_allocated = data['cpu_allocated']
-        output_space = [0.0] * len(data['values'])
-        scratch_space = [0.0] * len(data['values'])
+        output_available = [0.0] * len(data['values'])
+        scratch_used = [0.0] * len(data['values'])
+        scratch_available = [0.0] * len(data['values'])
 
         for i, value in enumerate(data['values']):
             duration[i] = value['duration']['value']
@@ -798,8 +817,10 @@ class Performance(Result_object):
             memory_available[i] = value['memory_available']['value']
             memory_available_percent[i] = value['memory_available_percent']['value']
             cpu_used[i] = value['cpu_used']['value']
-            output_space[i] = value['output_space']['value']
-            scratch_space[i] = value['scratch_space']['value']
+            output_available[i] = value['output_space']['value']
+            if 'scratch_used' in value:
+                scratch_used[i] = value['scratch_used']['value']
+            scratch_available[i] = value['scratch_space']['value']
         
         return self(
             duration = duration,
@@ -810,12 +831,13 @@ class Performance(Result_object):
             memory_available_percent = memory_available_percent,
             cpu_used = cpu_used,
             cpu_allocated = cpu_allocated,
-            output_space = output_space,
-            scratch_space = scratch_space
+            output_available = output_available,
+            scratch_used = scratch_used,
+            scratch_available = scratch_available
         )
 
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
@@ -871,6 +893,10 @@ class Performance(Result_object):
                         "units": "bytes",
                         "value": self.output_space[i]
                     },
+                    'scratch_used': {
+                        "units": "bytes",
+                        "value": self.scratch_used[i]
+                    },
                     'scratch_space': {
                         "units": "bytes",
                         "value": self.scratch_space[i]

digichem/result/nmr.py

@@ -22,7 +22,7 @@ class NMR_spectrometer(Result_object):
     A class for generating NMR spectra on-demand.
     """
     
-    def __init__(self, nmr_results, frequency = 300, fwhm = 0.001, resolution = 0.001, cutoff = 0.01, coupling_filter = 0.1, pre_merge = 0.01, post_merge = None, isotope_options = None):
+    def __init__(self, nmr_results, frequency = 300, fwhm = 0.001, resolution = 0.001, cutoff = 0.01, y_filter = 1e-6, coupling_filter = 0.1, pre_merge = 0.01, post_merge = None, isotope_options = None):
         """
         Constructor for NMR_spectrometer.
         
@@ -39,6 +39,7 @@ class NMR_spectrometer(Result_object):
         self.fwhm = fwhm
         self.gaussian_resolution = resolution
         self.gaussian_cutoff = cutoff
+        self.y_filter = y_filter
         self.coupling_filter = coupling_filter
         self._isotope_options = isotope_options if isotope_options is not None else {}
         
@@ -48,6 +49,7 @@ class NMR_spectrometer(Result_object):
             "pre_merge": self.pre_merge,
             "post_merge": self.post_merge,
             "fwhm": self.fwhm,
+            "y_filter": self.y_filter,
             "gaussian_resolution": self.gaussian_resolution,
             "coupling_filter": self.coupling_filter,
             "gaussian_cutoff": self.gaussian_cutoff,
@@ -66,6 +68,7 @@ class NMR_spectrometer(Result_object):
             fwhm = options['nmr']['fwhm'],
             resolution = options['nmr']['gaussian_resolution'],
             cutoff = options['nmr']['gaussian_cutoff'],
+            y_filter = options['nmr']['y_filter'],
             coupling_filter = options['nmr']['coupling_filter'],
             pre_merge = options['nmr']['pre_merge'],
             post_merge = options['nmr']['post_merge'],
@@ -160,6 +163,9 @@ class NMR_spectrometer(Result_object):
         
         return False
     
+    def __iter__(self):
+        return iter(self.available.keys())
+    
     def __getitem__(self, item):
         """
         Generate a spectrum for a given shortcode.
@@ -170,7 +176,7 @@ class NMR_spectrometer(Result_object):
         # match the interface.
         return lambda digichem_options: self.spectrum(*self.parse_shortcode(item))
     
-    def generate_for_dump(self):
+    def _get_dump_(self):
         """
         Method used to get a dictionary used to generate on-demand values for dumping.
         
@@ -180,7 +186,7 @@ class NMR_spectrometer(Result_object):
         """
         return self
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         # Return a list of possible spectra we can generate.
         return {
             "codes": list(self.available.keys()),
@@ -208,7 +214,7 @@ class NMR_spectrometer(Result_object):
         
         # The total spectrum takes all simulated peaks.
         # These are grouped by atom_group, flatten this list before passing to spectroscopy.
-        graph = Combined_graph.from_nmr(grouped_peaks, isotope_options['fwhm'], isotope_options['gaussian_resolution'], isotope_options['gaussian_cutoff'])
+        graph = Combined_graph.from_nmr(grouped_peaks, isotope_options['fwhm'], isotope_options['gaussian_resolution'], isotope_options['gaussian_cutoff'], filter = isotope_options['y_filter'])
         
         return graph
     
@@ -489,6 +495,8 @@ class NMR_list(Result_container):
         self.options = options
         self.groups = self.group()
         self.spectrometer = NMR_spectrometer.from_options(self.groups, options = options)
+        # This is used as part of the dump mechanic.
+        self.spectrum = self.spectrometer
     
     @classmethod
     def from_parser(self, parser):
@@ -599,14 +607,15 @@ class NMR_list(Result_container):
         
         return nmr_object_groups
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Dump this list of NMR results to a list of primitive types.
         """
         grouping = self.groups
         dump_dict = {
-            "values": super().dump(digichem_options),
-            "groups": {group_id.label: group.dump(digichem_options) for group_id, group in grouping.items()},
+            "values": super()._dump_(digichem_options, all),
+            "groups": {group_id.label: group.dump(digichem_options, all) for group_id, group in grouping.items()},
+            "spectrum": self.spectrometer.dump(digichem_options, all)
         }
         return dump_dict
     
@@ -620,17 +629,17 @@ class NMR_list(Result_container):
         """
         return self(NMR.list_from_dump(data['values'], result_set, options), atoms = result_set.atoms, options = options)
     
-    def generate_for_dump(self):
-        """
-        Method used to get a dictionary used to generate on-demand values for dumping.
+    # def _get_dump_(self):
+    #     """
+    #     Method used to get a dictionary used to generate on-demand values for dumping.
          
-        This functionality is useful for hiding expense properties from the normal dump process, while still exposing them when specifically requested.
+    #     This functionality is useful for hiding expense properties from the normal dump process, while still exposing them when specifically requested.
          
-        Each key in the returned dict is the name of a dumpable item, each value is a function to call with digichem_options as its only param.
-        """
-        return {
-            "spectrum": lambda digichem_options: self.spectrometer
-        }
+    #     Each key in the returned dict is the name of a dumpable item, each value is a function to call with digichem_options as its only param.
+    #     """
+    #     return {
+    #         "spectrum": lambda digichem_options: self.spectrometer
+    #     }
 
 
 class NMR_group(Result_object, Floatable_mixin):
@@ -649,7 +658,7 @@ class NMR_group(Result_object, Floatable_mixin):
     def __float__(self):
         return float(self.shielding)
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
@@ -661,7 +670,7 @@ class NMR_group(Result_object, Floatable_mixin):
                 "value": self.shielding
             },
             #"couplings": [{"groups": [group.label for group in coupling['groups']], "isotopes": list(coupling["isotopes"]), "total": coupling["total"]} for coupling in self.couplings],
-            "couplings": [coupling.dump(digichem_options) for coupling in self.couplings]
+            "couplings": [coupling.dump(digichem_options, all) for coupling in self.couplings]
         }
         
 class NMR_group_spin_coupling(Result_object):
@@ -686,7 +695,7 @@ class NMR_group_spin_coupling(Result_object):
         """
         return sum([coupling.isotropic('total') for coupling in self.couplings]) / len(self.couplings)
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
@@ -697,7 +706,7 @@ class NMR_group_spin_coupling(Result_object):
                 "units": "Hz",
                 "value": float(self.total),
             }
-            #"couplings": [coupling.dump(digichem_options) for coupling in self.couplings]
+            #"couplings": [coupling.dump(digichem_options, all) for coupling in self.couplings]
         }
         
     def other(self, atom_group):
@@ -819,14 +828,14 @@ class NMR(Result_object, Floatable_mixin):
         ]
         
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
         return {
             "atom": self.atom.label,
-            "shielding": self.shielding.dump(digichem_options),
-            "couplings": self.couplings.dump(digichem_options)
+            "shielding": self.shielding.dump(digichem_options, all),
+            "couplings": self.couplings.dump(digichem_options, all)
         }
         
 
@@ -867,7 +876,7 @@ class NMR_tensor_ABC(Result_object):
         eigenvalues = self.eigenvalues(tensor)
         return sum(eigenvalues) / len(eigenvalues)
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
@@ -931,7 +940,7 @@ class NMR_shielding(NMR_tensor_ABC):
         
         return shieldings
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
@@ -939,7 +948,7 @@ class NMR_shielding(NMR_tensor_ABC):
             "reference": self.reference,
         }
         
-        dump_dic.update(super().dump(digichem_options))
+        dump_dic.update(super()._dump_(digichem_options, all))
         return dump_dic
     
     @classmethod
@@ -1073,7 +1082,7 @@ class NMR_spin_coupling(NMR_tensor_ABC):
             in data
         ]
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
@@ -1082,5 +1091,5 @@ class NMR_spin_coupling(NMR_tensor_ABC):
             "isotopes": (self.isotopes[0], self.isotopes[1]),
         }
         
-        dump_dic.update(super().dump(digichem_options))
+        dump_dic.update(super()._dump_(digichem_options, all))
         return dump_dic

digichem/result/orbital.py

@@ -238,7 +238,7 @@ class Molecular_orbital_list(Result_container):
         
         return self(cls.list_from_dump(data['values'], result_set, options))
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
@@ -249,7 +249,7 @@ class Molecular_orbital_list(Result_container):
             },
             "num_occupied": len(self.occupied),
             "num_virtual": len(self.virtual),
-            "values": super().dump(digichem_options),
+            "values": super()._dump_(digichem_options, all),
             "spin_type": self.safe_get("spin_type")
         }
 #         # Add HOMO and LUMO
@@ -498,7 +498,7 @@ class Molecular_orbital(Result_object, Floatable_mixin):
     # The index used to access data from cclib (which always has two lists, one for alpha one for beta).
     ccdata_index = 0
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """

digichem/result/result.py

@@ -221,7 +221,7 @@ class Result_set(Result_object):
             # No S1 available.
             return None
         
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         "Dump the data contained in this result set, serialising it to a hierarchy of dicts that can be saved in various formats."
         # Start with our DB ID if we have one.
         dump_dic = {}
@@ -229,19 +229,19 @@ class Result_set(Result_object):
             dump_dic['_id'] = self._id
             
         dump_dic.update({
-            "metadata": self.metadata.dump(digichem_options),
-            "ground_state": self.ground_state.dump(digichem_options) if self.ground_state is not None else None,
-            "energies": self.energies.dump(digichem_options),
-            "atoms": self.atoms.dump(digichem_options),
-            "raw_atoms": self.raw_atoms.dump(digichem_options),
-            "orbitals": self.orbitals.dump(digichem_options),
-            "beta_orbitals": self.beta_orbitals.dump(digichem_options),
-            "pdm": self.pdm.dump(digichem_options) if self.pdm is not None else None,
-            "excited_states": self.excited_states.dump(digichem_options),
-            "soc": self.soc.dump(digichem_options),
-            "vibrations": self.vibrations.dump(digichem_options),
-            "nmr": self.nmr.dump(digichem_options),
-            "emission": self.emission.dump(digichem_options)
+            "metadata": self.metadata.dump(digichem_options, all),
+            "ground_state": self.ground_state.dump(digichem_options, all) if self.ground_state is not None else None,
+            "energies": self.energies.dump(digichem_options, all),
+            "atoms": self.atoms.dump(digichem_options, all),
+            "raw_atoms": self.raw_atoms.dump(digichem_options, all),
+            "orbitals": self.orbitals.dump(digichem_options, all),
+            "beta_orbitals": self.beta_orbitals.dump(digichem_options, all),
+            "pdm": self.pdm.dump(digichem_options, all) if self.pdm is not None else None,
+            "excited_states": self.excited_states.dump(digichem_options, all),
+            "soc": self.soc.dump(digichem_options, all),
+            "vibrations": self.vibrations.dump(digichem_options, all),
+            "nmr": self.nmr.dump(digichem_options, all),
+            "emission": self.emission.dump(digichem_options, all)
         })
         
         return dump_dic

digichem/result/soc.py

@@ -104,7 +104,7 @@ class Spin_orbit_coupling(Result_object, Floatable_mixin):
         self.zero = zero
         self.negative_one = negative_one
         
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
@@ -235,11 +235,11 @@ class Total_spin_orbit_coupling(Spin_orbit_coupling):
         """
         return "<{}|Hso|{}> (cm-1): {:10.5f}".format(self.singlet_state.state_symbol, self.triplet_state.state_symbol, self.root_sum_square)
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
-        dump_dic = super().dump(digichem_options)
+        dump_dic = super()._dump_(digichem_options, all)
         # Remove elements.
         del(dump_dic['soc'])
         return dump_dic

digichem/result/spectroscopy.py

@@ -112,7 +112,7 @@ class Spectroscopy_graph(Spectroscopy_graph_abc):
     For generating pictures of these graphs, see digichem.image.spectroscopy
     """
     
-    def __init__(self, coordinates, fwhm, resolution = 1, cutoff = 0.01, adjust_zero = False):
+    def __init__(self, coordinates, fwhm, resolution = 1, cutoff = 0.01, filter = 1e-6, adjust_zero = False):
         """
         Constructor for Spectroscopy_graph objects
         
@@ -137,6 +137,7 @@ class Spectroscopy_graph(Spectroscopy_graph_abc):
         self.fwhm = fwhm
         self.resolution = resolution
         self.cutoff = cutoff
+        self.filter = filter
         
         # Caches
         self._gaussians = []
@@ -187,7 +188,7 @@ class Spectroscopy_graph(Spectroscopy_graph_abc):
         # Next, determine the limits in which we'll plot.
         limits = self.gaussian_limits()
         
-        # Apply rounding to nearest resolution step cover up floating-point errors.
+        # Apply rounding to nearest resolution step to cover up floating-point errors.
         points = [self.resolution *round(point / self.resolution) for point in numpy.linspace(*limits)]
         
         # Plot and return.
@@ -202,7 +203,7 @@ class Spectroscopy_graph(Spectroscopy_graph_abc):
             )
         )
         gaussians = [
-            [(x, self.gaussian(a, b, c, x)) for x in points]
+            [(x, y) for x in points if (y  := self.gaussian(a, b, c, x)) >= self.filter]
             for b, a in self.base_coordinates
         ]
         
@@ -232,7 +233,7 @@ class Spectroscopy_graph(Spectroscopy_graph_abc):
         # Plot and return.
         digichem.log.get_logger().debug("Plotting cumulative gaussian peaks from {:0.2f} to {:0.2f} with a step size of {} ({} total points) for {} peaks ({} total iterations)".format(limits[0], limits[1], self.resolution, limits[2], len(self.base_coordinates), len(self.base_coordinates) * limits[2]))
         gaussian = [
-            (x, sum((self.gaussian(a, b, c, x) for b, a in self.base_coordinates))) for x in points
+            (x, y) for x in points if ( y := sum((self.gaussian(a, b, c, x) for b, a in self.base_coordinates))) > self.filter
         ]
         
         return gaussian

digichem/result/tdm.py

@@ -42,12 +42,12 @@ class Transition_dipole_moment_ABC(Dipole_moment_ABC):
             atoms = result_set.atoms
             )
         
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
         data = {'state_level': self.state_level}
-        data.update(super().dump(digichem_options))
+        data.update(super()._dump_(digichem_options, all))
         return data
     
     @property
@@ -221,13 +221,13 @@ class Transition_dipole_moment(Result_object):
         
         return self(electric = electric, magnetic = magnetic)
         
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """
         return {
-            "electric": self.electric.dump(digichem_options) if self.electric is not None else None,
-            "magnetic": self.magnetic.dump(digichem_options) if self.magnetic is not None else None,
+            "electric": self.electric.dump(digichem_options, all) if self.electric is not None else None,
+            "magnetic": self.magnetic.dump(digichem_options, all) if self.magnetic is not None else None,
             "angle": {
                 "value": float(self.angle().angle) if self.electric is not None and self.magnetic is not None else None,
                 "units": self.angle().units if self.electric is not None and self.magnetic is not None else None,

digichem/result/vibration.py

@@ -43,7 +43,7 @@ class Vibrations_list(Result_container, Unmergeable_container_mixin):
         """
         return self(Vibration.list_from_parser(parser))
     
-    def generate_for_dump(self):
+    def _get_dump_(self):
         """
         Method used to get a dictionary used to generate on-demand values for dumping.
         
@@ -51,7 +51,9 @@ class Vibrations_list(Result_container, Unmergeable_container_mixin):
         
         Each key in the returned dict is the name of a dumpable item, each value is a function to call with digichem_options as its only param.
         """
-        return {"spectrum": self.generate_spectrum}
+        return {
+            "spectrum": self.generate_spectrum,
+        }
     
     def generate_spectrum(self, digichem_options):
         """
@@ -65,7 +67,14 @@ class Vibrations_list(Result_container, Unmergeable_container_mixin):
         from digichem.result.spectroscopy import Spectroscopy_graph
         
         
-        spectrum = Spectroscopy_graph.from_vibrations(self, digichem_options['IR_spectrum']['fwhm'], digichem_options['IR_spectrum']['gaussian_resolution'], digichem_options['IR_spectrum']['gaussian_cutoff'])
+        spectrum = Spectroscopy_graph.from_vibrations(
+            self,
+            fwhm = digichem_options['IR_spectrum']['fwhm'],
+            resolution = digichem_options['IR_spectrum']['gaussian_resolution'],
+            cutoff = digichem_options['IR_spectrum']['gaussian_cutoff'],
+            filter = digichem_options['IR_spectrum']['y_filter'],
+        )
+        
         
         try:
             spectrum_data = spectrum.plot_cumulative_gaussian()
@@ -82,11 +91,11 @@ class Vibrations_list(Result_container, Unmergeable_container_mixin):
             "peaks": spectrum_peaks
         }
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         dump_dict = {
             "num_vibrations": len(self),
             "num_negative": len(self.negative),
-            "values": super().dump(digichem_options),
+            "values": super()._dump_(digichem_options, all),
         }
         return dump_dict
 
@@ -126,7 +135,7 @@ class Vibration(Result_object, Floatable_mixin):
         """
         return float(self.frequency)
     
-    def dump(self, digichem_options):
+    def _dump_(self, digichem_options, all):
         """
         Get a representation of this result object in primitive format.
         """

digichem/test/conftest.py

@@ -1,4 +1,9 @@
 import numpy
+import os
+from pathlib import Path
 
 # Set numpy errors (not sure why this isn't the default...)
 numpy.seterr(invalid = 'raise', divide = 'raise')
+
+# Expand path to include mocks.
+os.environ["PATH"] = str(Path(__file__).parent / "mock") + os.pathsep + os.environ["PATH"]