pychemstation 0.4.7.dev1__py3-none-any.whl

hein-analytical-control/devices/OceanOptics/oceanoptics.py

@@ -0,0 +1,115 @@
+"""Base module for interfacing with OceanOptics Spectrometers
+
+.. moduleauthor:: Artem Leonov, Graham Keenan
+"""
+import time
+import logging
+import numpy as np
+import seabreeze
+from seabreeze.pyseabreeze import SeaBreezeDevice
+
+seabreeze.use("cseabreeze")
+import seabreeze.spectrometers as sb
+
+# Spectrometer Types:
+SPECS = {"UV": "2192", "RAMAN": "QE-PRO", "IR": "NIRQUEST"}
+
+
+class UnsupportedSpectrometer(Exception):
+    """Exception for unsupported spectrometer types"""
+
+
+class NoSpectrometerDetected(Exception):
+    """Exception for when no spectrometer is detected"""
+
+
+def _get_spectrometer(spec_type: str) -> SeaBreezeDevice:
+    """Gets the Spectrometer from Seabreeze that matches given type
+
+    Arguments:
+        spec_type {str} -- Type of spectrometer to look for
+
+    Raises:
+        UnsupportedSpectrometer -- If the spec_type is not present
+
+    Returns:
+        str -- Name of the spectrometer
+    """
+
+    devices = sb.list_devices()
+
+    if not devices:
+        raise NoSpectrometerDetected("Are the spectrometers plugged in?")
+    if spec_type in SPECS.keys():
+        for dev in devices:
+            if SPECS[spec_type] in str(dev):
+                return dev
+    raise UnsupportedSpectrometer("Spectrometer {} unsupported!".format(spec_type))
+
+
+class OceanOpticsSpectrometer:
+    """Base class for interfacing with OceanOptics Spectrometers"""
+
+    def __init__(self, spec_type, name=None):
+        """
+        Args:
+            spec_type (str): The type of spectrometer, e.g. 'IR', 'raman', etc.
+            name (str, optional): Device name for easier access
+        """
+        self.integration_time = 0.01  # in seconds
+        self.__spec = _get_spectrometer(spec_type)
+        self._spectrometer = sb.Spectrometer(self.__spec)
+        self.name = name
+        self._delay = 0.01
+
+        self.logger = logging.getLogger("oceanoptics.spectrometer")
+        self.logger.setLevel(logging.INFO)
+        # Removing default handlers
+        self.logger.handlers = []
+        ch = logging.StreamHandler()
+        ch.setLevel(logging.INFO)
+        console_formatter = logging.Formatter(
+            "%(asctime)s ; %(module)s ; %(name)s ; %(message)s"
+        )
+        ch.setFormatter(console_formatter)
+        self.logger.addHandler(ch)
+        self.set_integration_time(self.integration_time)
+
+    def set_integration_time(self, integration_time):
+        """Sets the integration time for the spectrometer
+
+        Args:
+            integration_time (float): Desired integration time in seconds!
+        """
+
+        self._spectrometer.open()
+        self.integration_time = integration_time
+        integration_time *= 1000 * 1000  # converting to microseconds
+        self.logger.debug(
+            "Setting the integration time to %s microseconds", integration_time
+        )
+        self._spectrometer.integration_time_micros(integration_time)
+        self._spectrometer.close()
+
+    def scan(self, n=3):
+        """Reads the spectrometer and returns the spectrum
+
+        Args:
+            n (int, opitonal): Number of 'scans'
+
+        Returns:
+            (Tuple): Tuple containing spectrum wavelengths and intensities as numpy arrays
+                Example: (array(wavelengths), array(intensities))
+        """
+
+        i_mean = []
+        self.logger.debug("Scanning")
+        self._spectrometer.open()
+        for i in range(n):
+            wavelengths, intensities = self._spectrometer.spectrum()
+            i_mean.append(intensities)
+            time.sleep(self._delay)
+
+        intensities = np.mean(i_mean, axis=0)
+        self._spectrometer.close()
+        return (wavelengths, intensities)

hein-analytical-control/devices/__init__.py

@@ -0,0 +1,15 @@
+"""
+.. include:: README.md
+"""
+
+# physical instruments
+from .Magritek.Spinsolve.spinsolve import SpinsolveNMR
+from .OceanOptics.Raman.raman_control import OceanOpticsRaman
+from .OceanOptics.UV.QEPro2192 import QEPro2192
+from .OceanOptics.IR.NIRQuest512 import NIRQuest512
+from .Agilent.hplc import HPLCController
+
+# classes for spectra processing
+from .OceanOptics.Raman.raman_spectrum import RamanSpectrum
+from .Magritek.Spinsolve.spectrum import SpinsolveNMRSpectrum
+from .Agilent.chromatogram import AgilentHPLCChromatogram

hein-analytical-control/generated/__init__.py

@@ -0,0 +1,56 @@
+from .pump_method import (
+    Channel1ExtendedSolventType,
+    Channel2ExtendedSolventType,
+    CompressA,
+    CompressB,
+    Definition,
+    PostTime,
+    PumpMethod,
+    SolventComposition,
+    SolventDescription,
+    SolventElement,
+    StopTime,
+    StrokeA,
+    Timetable,
+    TimetableEntry,
+)
+
+from .dad_method import (
+    AnalogOutput1,
+    AnalogOutput2,
+    DadMethod,
+    PostTime,
+    PrepareAutomation,
+    PrepareMode,
+    Signal,
+    Signals,
+    SpectraAcquisition,
+    StopTime,
+)
+
+__all__ = [
+    "Channel1ExtendedSolventType",
+    "Channel2ExtendedSolventType",
+    "CompressA",
+    "CompressB",
+    "Definition",
+    "PostTime",
+    "PumpMethod",
+    "SolventComposition",
+    "SolventDescription",
+    "SolventElement",
+    "StopTime",
+    "StrokeA",
+    "Timetable",
+    "TimetableEntry",
+    "AnalogOutput1",
+    "AnalogOutput2",
+    "DadMethod",
+    "PostTime",
+    "PrepareAutomation",
+    "PrepareMode",
+    "Signal",
+    "Signals",
+    "SpectraAcquisition",
+    "StopTime",
+]

hein-analytical-control/generated/dad_method.py

@@ -0,0 +1,367 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class AnalogOutput1:
+    analog_zero: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "AnalogZero",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    analog_att: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "AnalogAtt",
+            "type": "Element",
+            "required": True,
+        },
+    )
+
+
+@dataclass
+class AnalogOutput2:
+    analog_zero: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "AnalogZero",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    analog_att: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "AnalogAtt",
+            "type": "Element",
+            "required": True,
+        },
+    )
+
+
+@dataclass
+class PostTime:
+    post_time_mode: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "PostTimeMode",
+            "type": "Element",
+            "required": True,
+        },
+    )
+
+
+@dataclass
+class PrepareAutomation:
+    do_prep_run_balance: Optional[bool] = field(
+        default=None,
+        metadata={
+            "name": "DoPrepRunBalance",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    do_start_run_balance: Optional[bool] = field(
+        default=None,
+        metadata={
+            "name": "DoStartRunBalance",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    do_post_run_balance: Optional[bool] = field(
+        default=None,
+        metadata={
+            "name": "DoPostRunBalance",
+            "type": "Element",
+            "required": True,
+        },
+    )
+
+
+@dataclass
+class PrepareMode:
+    balance_mode: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "BalanceMode",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    headroom: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "Headroom",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    smpgain: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "SMPGain",
+            "type": "Element",
+            "required": True,
+        },
+    )
+
+
+@dataclass
+class Signal:
+    use_signal: Optional[bool] = field(
+        default=None,
+        metadata={
+            "name": "UseSignal",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    id: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "ID",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    wavelength: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "Wavelength",
+            "type": "Element",
+        },
+    )
+    bandwidth: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "Bandwidth",
+            "type": "Element",
+        },
+    )
+    use_reference: Optional[bool] = field(
+        default=None,
+        metadata={
+            "name": "UseReference",
+            "type": "Element",
+            "required": True,
+        },
+    )
+
+
+@dataclass
+class SpectraAcquisition:
+    spectra_range_from: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "SpectraRangeFrom",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    spectra_range_to: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "SpectraRangeTo",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    spectra_step: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "SpectraStep",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    spectra_acq_mode: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "SpectraAcqMode",
+            "type": "Element",
+            "required": True,
+        },
+    )
+
+
+@dataclass
+class StopTime:
+    stop_time_mode: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "StopTimeMode",
+            "type": "Element",
+            "required": True,
+        },
+    )
+
+
+@dataclass
+class Signals:
+    signal: list[Signal] = field(
+        default_factory=list,
+        metadata={
+            "name": "Signal",
+            "type": "Element",
+            "min_occurs": 1,
+        },
+    )
+
+
+@dataclass
+class DadMethod:
+    module_type: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "ModuleType",
+            "type": "Attribute",
+            "required": True,
+        },
+    )
+    schema_version: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "schemaVersion",
+            "type": "Attribute",
+            "required": True,
+        },
+    )
+    schema_si: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "schemaSI",
+            "type": "Attribute",
+            "required": True,
+        },
+    )
+    module_options: Optional[object] = field(
+        default=None,
+        metadata={
+            "name": "ModuleOptions",
+            "type": "Attribute",
+            "required": True,
+        },
+    )
+    configuration_xml: Optional[str] = field(
+        default=None,
+        metadata={
+            "name": "ConfigurationXml",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    timetable: Optional[object] = field(
+        default=None,
+        metadata={
+            "name": "Timetable",
+            "type": "Element",
+        },
+    )
+    stop_time: Optional[StopTime] = field(
+        default=None,
+        metadata={
+            "name": "StopTime",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    post_time: Optional[PostTime] = field(
+        default=None,
+        metadata={
+            "name": "PostTime",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    delay: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "Delay",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    analog_output1: Optional[AnalogOutput1] = field(
+        default=None,
+        metadata={
+            "name": "AnalogOutput1",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    analog_output2: Optional[AnalogOutput2] = field(
+        default=None,
+        metadata={
+            "name": "AnalogOutput2",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    signals: Optional[Signals] = field(
+        default=None,
+        metadata={
+            "name": "Signals",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    peakwidth: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "Peakwidth",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    slitwidth: Optional[int] = field(
+        default=None,
+        metadata={
+            "name": "Slitwidth",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    uvlamp_required: Optional[bool] = field(
+        default=None,
+        metadata={
+            "name": "UVLampRequired",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    vislamp_required: Optional[bool] = field(
+        default=None,
+        metadata={
+            "name": "VISLampRequired",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    prepare_mode: Optional[PrepareMode] = field(
+        default=None,
+        metadata={
+            "name": "PrepareMode",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    prepare_automation: Optional[PrepareAutomation] = field(
+        default=None,
+        metadata={
+            "name": "PrepareAutomation",
+            "type": "Element",
+            "required": True,
+        },
+    )
+    spectra_acquisition: Optional[SpectraAcquisition] = field(
+        default=None,
+        metadata={
+            "name": "SpectraAcquisition",
+            "type": "Element",
+            "required": True,
+        },
+    )