pychemstation 0.4.7.dev1__py3-none-any.whl → 0.4.7.dev2__py3-none-any.whl

hein-analytical-control/devices/OceanOptics/IR/ir_spectrum.py

@@ -1,191 +0,0 @@
-"""
-.. module:: ir_spectrum
-    :synopsis: Module for representing an IR spectrum
-    :platforms: Unix, Windows
-
-.. moduleauthor:: Graham Keenan (Cronin Lab 2020)
-
-.. note:: Edit as needed, this is a skeletal implementation that can be improved
-"""
-
-import json
-import time
-import numpy as np
-import matplotlib.pyplot as plt
-
-
-def _write_json(data: dict, filename: str):
-    """Write data out to a JSON file
-
-    Args:
-        data (dict): Data to write
-        filename (str): Path to save JSON file
-    """
-
-    with open(filename, "w") as f_d:
-        json.dump(data, f_d, indent=4)
-
-
-def _load_json(filename: str) -> dict:
-    """Loads a JSON file from disk
-
-    Args:
-        filename (str): Name of the file to load
-
-    Returns:
-        dict: JSON data
-    """
-
-    with open(filename) as f_d:
-        return json.load(f_d)
-
-
-def _ensure_serializable(data: dict) -> dict:
-    """Ensures the output data is serializable
-
-    Args:
-        data (Dict): Data to check
-
-    Returns:
-        Dict: Serializable data
-    """
-
-    for k, v in data.items():
-        if isinstance(v, np.ndarray):
-            data[k] = v.tolist()
-        elif isinstance(v, dict):
-            data[k] = _ensure_serializable(v)
-    return data
-
-
-def trim_data(self, data: list, lower_range: int, upper_range: int) -> np.ndarray:
-    """Trims data within a certain range
-    Returns valid indexes that can be used to trim X and Y data
-
-    Args:
-        data (list): Data to trim within the range
-        lower_range (int): Lower end of the range (Minimum value)
-        upper_range (int): Upper end of the range (Maximum value)
-
-    Returns:
-        np.ndarray: Indexes to use for trimming data
-    """
-
-    above_ind = np.array(data) > lower_range
-    below_ind = np.array(data) < upper_range
-
-    return np.logical_and(above_ind, below_ind)
-
-
-class IRSpectrum:
-    """Class representing an IR spectrum.
-    Spectrum can be a reference spectrum or a measured spectrum
-
-    Args:
-        wavelengths (list): Wavelengths of the spectrum
-        intensities (list): Intensities of the spectrum
-        ref (dict, optional): Reference spectrum if available
-    """
-
-    def __init__(self, wavelengths: list, intensities: list, ref: dict = {}):
-        self.wavelengths = wavelengths
-        self.intensities = intensities
-        self.reference = ref
-        self.wavenumbers = []
-        self.transmittance = []
-
-        if self.reference:
-            self.convert_intensities_to_transmittance()
-            self.convert_wavelength_to_wavenumber()
-
-    @classmethod
-    def load_spectrum(cls, filepath: str):
-        """Class method for loading spectrum data from a file
-
-        Args:
-            filepath (str): Path to  spectrum data
-
-        Returns:
-            IRSpectrum: IRSpectrum with spectral data from file
-        """
-
-        data = _load_json(filepath)
-        return cls(data["wavelength"], data["intensities"], ref=data["reference"])
-
-    def convert_intensities_to_transmittance(self):
-        """Converts intensities to transmittance"""
-
-        self.transmittance = list(
-            reversed(
-                [
-                    (s / r) * 100
-                    for (s, r) in zip(self.intensities, self.reference["intensities"])
-                ]
-            )
-        )
-
-    def convert_wavelength_to_wavenumber(self):
-        """Converts Wavelengths to Wavenumbers"""
-
-        self.wavenumbers = list(reversed([(10**7) / nm for nm in self.wavelengths]))
-
-    def plot_spectrum(
-        self, display: bool = False, savepath: str = "", limits: tuple = ()
-    ):
-        """Plots the spectral data
-
-        Args:
-            display (bool, optional): Display the spectrum on screen. Defaults to False.
-            savepath (str, optional): Path to save the spectrum graph to disk. Defaults to "".
-        """
-
-        # Clear any previous plots/data
-        plt.clf()
-        plt.cla()
-
-        # TODO::GAK -- Implement limit checks
-
-        # Already have a reference set, measured spectrum
-        if self.reference:
-            plt.xlabel("Wavenumber (cm-1)")
-            plt.ylabel("Transmittance (%)")
-            plt.title("IR Spectrum")
-            plt.plot(self.wavenumbers, self.transmittance, color="black", linewidth=0.5)
-
-        # No reference set, reference spectrum
-        else:
-            plt.xlabel("Wavelength (nm)")
-            plt.ylabel("Intensities")
-            plt.title("Reference IR Spectrum")
-            plt.plot(self.wavelengths, self.intensities, color="black", linewidth=0.5)
-
-        # Set limits after plotting
-        plt.gca().set_ylim(bottom=0)
-
-        # Save plot to disk
-        if savepath:
-            plt.savefig(savepath)
-
-        # Display the plot on screen
-        if display:
-            plt.show()
-
-    def dump_spectrum(self, filename: str):
-        """Dump spectral data out to disk
-
-        Args:
-            filename (str): Path to save file (JSON)
-        """
-
-        out = {
-            "wavenumbers": self.wavenumbers,
-            "transmittance": self.transmittance,
-            "wavelength": self.wavelengths,
-            "intensities": self.intensities,
-            "reference": self.reference,
-            "timestamp": time.strftime("%d_%m_%Y_%H:%M:%S"),
-        }
-
-        out = _ensure_serializable(out)
-
-        _write_json(out, filename)

hein-analytical-control/devices/OceanOptics/Raman/raman_control.py

@@ -1,46 +0,0 @@
-"""Module for interfacing with OceanOptics Raman spectrometer
-
-.. moduleauthor:: Artem Leonov, Graham Keenan
-"""
-import time
-import logging
-
-from ..oceanoptics import OceanOpticsSpectrometer
-from .raman_spectrum import RamanSpectrum
-
-
-class OceanOpticsRaman(OceanOpticsSpectrometer):
-    """Operational class for interfacing with the OceanOptics Raman spectrometer
-
-    Inherits:
-        OceanOpticsSpectrometer: Base Spectrometer class
-    """
-
-    def __init__(self, name=None, path=None):
-        super().__init__("RAMAN", name)
-        self.last_spectrum = None
-        self.spectrum = RamanSpectrum(path)
-        self.start_time = time.time()
-        self.logger = logging.getLogger("oceanoptics.spectrometer.raman")
-
-    def get_spectrum(self):
-        """Obtains spectrum and performs basic processing"""
-
-        spec = self.scan()
-        timestamp = round((time.time() - self.start_time), 2)
-        self.logger.debug("Spectrum obtained at %s", timestamp)
-        self.spectrum.load_spectrum(spec, timestamp, reference=False)
-        # self.last_spectrum = self.spectrum.default_process()
-        # return np.array(
-        #     [
-        #         self.last_spectrum['wavelengths'],
-        #         self.last_spectrum['intensities']
-        #     ]
-        # )
-
-    def obtain_reference_spectrum(self):
-        """Obtains the reference spectrum for further use"""
-
-        spec = self.scan()
-        self.start_time = time.time()
-        self.spectrum.load_spectrum(spec, 0, reference=True)

hein-analytical-control/devices/OceanOptics/Raman/raman_spectrum.py

@@ -1,148 +0,0 @@
-"""
-Module for handling Raman spectroscopic data
-
-.. moduleauthor:: Artem Leonov, Graham Keenan
-"""
-import logging
-import os
-
-import numpy as np
-from scipy import signal
-
-from ....analysis import AbstractSpectrum
-from ....analysis.utils import interpolate_to_index
-
-LASER_POWER = 785
-
-MIN_X = 780
-MAX_X = 1006
-
-
-def _convert_wavelength_to_wavenumber(data):
-    """Converts x from spectrometer to Raman shift in wavenumbers
-
-    Arguments:
-        data (iterable): Wavelength data to convert
-
-    Returns:
-        (:obj: np.array): Wavenumbers data
-    """
-
-    wavenumbers = [(10**7 / LASER_POWER) - (10**7 / wv) for wv in data]
-
-    return np.array(wavenumbers)
-
-
-class RamanSpectrum(AbstractSpectrum):
-    """Defines methods for Raman spectroscopic data handling
-
-    Args:
-        path(str, optional): Valid path to save the spectral data.
-            If not provided, uses .//raman_data
-    """
-
-    AXIS_MAPPING = {
-        "x": "wavelength",
-        "y": "intensities",
-    }
-
-    INTERNAL_PROPERTIES = {
-        "reference",
-        "original",
-        "baseline",
-    }
-
-    def __init__(self, path=None, autosaving=True):
-
-        if path is not None:
-            path = os.path.join(".", "raman_data")
-
-        self.logger = logging.getLogger("oceanoptics.spectrometer.raman.spectrum")
-
-        super().__init__(path, autosaving)
-
-    def find_peaks_iteratively(self, limit=10, steps=100):
-        """Finds all peaks iteratively moving the threshold
-
-        Args:
-            limit (int): Max number of peaks found at each iteration to stop
-                after.
-            steps (int): Max number of iterations.
-        """
-
-        gradient = np.linspace(self.y.max(), self.y.min(), steps)
-        pl = [
-            0,
-        ]  # peaks length
-
-        # Looking for peaks and decreasing height
-        for i, n in enumerate(gradient):
-            peaks, _ = signal.find_peaks(self.y, height=n)
-            pl.append(len(peaks))
-            diff = pl[-1] - pl[-2]
-            if diff > limit:
-                self.logger.debug(
-                    "Stopped at iteration %s, with height %s, \
-diff - %s",
-                    i + 1,
-                    n,
-                    diff,
-                )
-                break
-
-        # Final peaks at previous iteration
-        peaks, _ = signal.find_peaks(self.y, height=gradient[i - 1])
-
-        # Updating widths
-        pw = signal.peak_widths(self.y, peaks, rel_height=0.95)
-        peak_xs = self.x.copy()[peaks][:, np.newaxis]
-        peak_ys = self.y.copy()[peaks][:, np.newaxis]
-        peaks_ids = np.around(peak_xs)
-        peaks_left_ids = interpolate_to_index(self.x, pw[2])[:, np.newaxis]
-        peaks_right_ids = interpolate_to_index(self.x, pw[3])[:, np.newaxis]
-
-        # Packing for peak array
-        self.peaks = np.hstack(
-            (
-                peaks_ids,
-                peak_xs,
-                peak_ys,
-                peaks_left_ids,
-                peaks_right_ids,
-            )
-        )
-
-        return peaks_ids
-
-    def load_spectrum(self, spectrum, timestamp, reference=False):
-        """Loads the spectral data
-
-        Args:
-            spectrum (tuple): Tuple containing spectrum x and y as numpy arrays.
-                Example: (array(x), array(y))
-            timestamp (float): time.time() for the measured spectra
-            reference (bool, optional): True if the supplied spectra should be
-                stored as a reference (background)
-        """
-
-        super().load_spectrum(spectrum[0], spectrum[1], timestamp)
-        self.original = spectrum[1]
-        if reference:
-            self.reference = spectrum[1]
-
-    def subtract_reference(self):
-        """Subtracts reference spectrum and updates the current one"""
-
-        if self.reference is None:
-            raise ValueError("Please upload the reference first")
-
-        self.y -= self.reference
-
-    def default_processing(self):
-        """Dummy method for quick processing. Returns spectral data!"""
-
-        self.correct_baseline()
-        self.smooth_spectrum()
-        self.find_peaks_iteratively()
-
-        return self.x, self.y, self.timestamp

hein-analytical-control/devices/OceanOptics/UV/QEPro2192.py

@@ -1,90 +0,0 @@
-"""
-.. module:: QEPro2192
-    :synopsis: Module representing the UV QEPro2192 spectrometer
-    :platforms: Unix, Windows
-
-.. moduleauthor:: Graham Keenan (Cronin Lab 2020)
-
-.. note:: Feel free to edit. This is a skeleton for minimal functionality.
-
-"""
-
-import json
-from pathlib import Path
-from .uv_spectrum import UVSpectrum
-from typing import Optional, Union, Dict
-from ..oceanoptics import OceanOpticsSpectrometer
-
-
-class NoReferenceException(Exception):
-    """Exception for calling spectrum without a reference"""
-
-
-class QEPro2192(OceanOpticsSpectrometer):
-    """Class representing the QEPro2192 spectrometer
-
-    Inherits:
-        OceanOpticsSpectrometer
-    """
-
-    def __init__(self):
-        super().__init__("UV", name="QEPro2192 UV Spectrometer")
-        self.reference = {}
-        self.__ref_called = False
-
-    def load_reference(self, ref: Union[str, Dict]):
-        """Loads a pre-existing reference from disk or from dict.
-
-        Args:
-            ref (Union[str, Dict]): Reference as either a dictionary
-            or JSON filepath
-        """
-
-        # Filepath, load and set
-        if isinstance(ref, str) or isinstance(ref, Path):
-            with open(ref) as fd:
-                self.reference = json.load(fd)
-                self.__ref_called = True
-
-        # Dict, set
-        elif isinstance(ref, dict):
-            self.reference = ref
-            self.__ref_called = True
-
-        # Not supported
-        else:
-            self.logger.warning(f"Reference {ref} is unsupported. Not loading")
-
-    def obtain_reference_spectrum(self) -> UVSpectrum:
-        """Obtain a reference spectrum.
-
-        Returns:
-            UVSpectrum: Reference UV spectrum
-        """
-
-        wavelengths, intensities = self.scan()
-        self.reference["wavelength"] = wavelengths
-        self.reference["intensities"] = intensities
-        self.__ref_called = True
-
-        return UVSpectrum(wavelengths, intensities)
-
-    def obtain_spectrum(self) -> UVSpectrum:
-        """Obtain a UV spectrum of a sample.
-
-        Raises:
-            NoReferenceException: Attempting to measure a sample without
-            a reference
-
-        Returns:
-            UVSpectrum: Sample UV spectrum.
-        """
-
-        if not self.__ref_called:
-            raise NoReferenceException(
-                "Attempting to call a spectrum without a valid reference\
-                spectrum"
-            )
-
-        wavelengths, intensities = self.scan()
-        return UVSpectrum(wavelengths, intensities, ref=self.reference)

hein-analytical-control/devices/OceanOptics/UV/uv_spectrum.py

@@ -1,227 +0,0 @@
-"""
-.. module:: uv_spectrum
-    :synopsis: Module representing a UV spectrum
-    :platforms: Unix, Windows
-
-.. moduleauthor:: Graham Keenan (Cronin Lab 2020)
-
-.. note:: Feel free to edit. This is a skeletal implementation.
-
-"""
-
-import time
-import json
-import numpy as np
-import matplotlib.pyplot as plt
-
-
-def _write_json(data: dict, filename: str):
-    """Writes out data to a JSON file
-
-    Args:
-        data (dict): Data to write
-        filename (str): Path to save to
-    """
-
-    with open(filename, "w") as f_d:
-        json.dump(data, f_d, indent=4)
-
-
-def _load_json(filename: str) -> dict:
-    """Load  JSON file from disk
-
-    Args:
-        filename (str): Path to JSON file
-
-    Returns:
-        dict: JSON data
-    """
-
-    with open(filename) as f_d:
-        return json.load(f_d)
-
-
-def _ensure_serializable(data: dict) -> dict:
-    """Ensures the output data is serializable
-
-    Args:
-        data (Dict): Data to check
-
-    Returns:
-        Dict: Serializable data
-    """
-
-    for k, v in data.items():
-        if isinstance(v, np.ndarray):
-            data[k] = v.tolist()
-        elif isinstance(v, dict):
-            data[k] = _ensure_serializable(v)
-    return data
-
-
-def trim_data(data: list, lower_range: int, upper_range: int) -> np.ndarray:
-    """Trims data within a certain range
-    Returns valid indexes that can be used to trim X and Y data
-
-    Args:
-        data (list): Data to trim within the range
-        lower_range (int): Lower end of the range (Minimum value)
-        upper_range (int): Upper end of the range (Maximum value)
-
-    Returns:
-        np.ndarray: Indexes to use for trimming data
-    """
-
-    above_ind = np.array(data) > lower_range
-    below_ind = np.array(data) < upper_range
-
-    return np.logical_and(above_ind, below_ind)
-
-
-class UVSpectrum:
-    """Class representing a UV spectrum.
-    Spectrum can be a reference spectrum or measured spectrum.
-
-    Args:
-        wavelengths (list): Wavelengths of the spectrum
-        intensities (list): Intensities of the spectrum
-        ref (dict): Reference spectrum data (Defaults to {})
-
-    """
-
-    def __init__(self, wavelengths: list, intensities: list, ref: dict = {}):
-        self.wavelengths = np.array(wavelengths)
-        self.intensities = np.array(intensities)
-        self.reference = ref
-        self.absorbances = []
-        self.max_peak = 0
-
-        # If we have a reference, generate absorbances using Beer-Lambert relation
-        if self.reference:
-            self.beer_lambert()
-
-    @classmethod
-    def load_spectrum(cls, filepath: str):
-        """Class method for loading spectrum data from file
-
-        Args:
-            filepath (str): Path to spectrum JSON file
-
-        Returns:
-            UVSpectrum: UVSpectrum instance
-        """
-
-        data = _load_json(filepath)
-        return cls(data["wavelength"], data["intensities"], ref=data["reference"])
-
-    def beer_lambert(self):
-        """Beer-Lambert relation.
-        Converts intensities to absorbances for a UV spectrum
-        """
-
-        for ref, measured in zip(self.reference["intensities"], self.intensities):
-            try:
-                if ref == 0 or measured == 0:
-                    continue
-                self.absorbances.append(np.log10(ref / measured))
-            except Exception:
-                break
-
-        # Set absorbances
-        self.absorbances = np.array(self.absorbances)
-
-        # Find the maximum peak
-        self.max_peak = self.wavelengths[np.argmax(self.absorbances)]
-
-    def plot_spectrum(
-        self,
-        display: bool = False,
-        legend: bool = False,
-        savepath: str = "",
-        limits: tuple = (),
-    ):
-        """Plot spectrum.
-
-        Args:
-            display (bool, optional): Display the spectra on screen. Defaults to False.
-            legend (bool, optional): Display a legend or not for maximum peak. Defaults to False.
-            savepath (str, optional): Path to save the image to. Defaults to "".
-            limits (tuple, optional): Trims data within a certain range. Defaults to ().
-        """
-
-        # Clear any previous plots/data
-        plt.clf()
-        plt.cla()
-
-        # Set X label
-        plt.xlabel("Wavelength (nm)")
-
-        # Trim data within a certain range
-        if limits:
-            trimmed = trim_data(self.wavelengths, *limits)
-            self.wavelengths = self.wavelengths[trimmed]
-            self.intensities = self.intensities[trimmed]
-
-            # Trim absorbances if they're present
-            if len(self.absorbances) > 0:
-                self.absorbances = self.absorbances[trimmed]
-
-        # Display different labels for Measured spectrum
-        # We have a reference spectrum already, means this is a measured sample
-        if self.reference:
-            plt.ylabel("Absorbances")
-            plt.title("UV/Vis Reference Spectrum")
-            plt.plot(self.wavelengths, self.absorbances, color="black", linewidth=0.5)
-
-        # Display different labels for Reference
-        # No reference means this should be a reference
-        else:
-            plt.ylabel("Intensities")
-            plt.title("UV/Vis Spectrum")
-            plt.plot(self.wavelengths, self.intensities, color="black", linewidth=0.5)
-
-        # Display legend
-        if legend:
-            leg_label = f"Maximum Peak: {self.max_peak:.2f}nm"
-            plt.vlines(
-                x=self.max_peak,
-                ymin=0,
-                ymax=max(self.absorbances),
-                color="g",
-                zorder=3,
-                label=leg_label,
-            )
-            leg = plt.legend()
-            for legobj in leg.legendHandles:
-                legobj.set_linewidth(5.0)
-
-        # Set limits after plotting
-        plt.gca().set_ylim(bottom=0)
-
-        # Save if savepath is defined
-        if savepath:
-            plt.savefig(savepath)
-
-        # SHow the spectrum on screen
-        if display:
-            plt.show()
-
-    def dump_spectrum(self, filename: str):
-        """Dump spectrum data to JSON file
-
-        Args:
-            filename (str): Path to save JSON file
-        """
-
-        out = {
-            "wavelength": self.wavelengths,
-            "absorbances": self.absorbances,
-            "intensities": self.intensities,
-            "reference": self.reference,
-            "max_peak": self.max_peak,
-            "timestamp": time.strftime("%d_%m_%Y_%H:%M:%S"),
-        }
-
-        out = _ensure_serializable(out)
-
-        _write_json(out, filename)