134 Adds hyper spectral imaging to qt3scan

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qt3utils"
-version = "1.0.3.dev1"
+version = "1.1.0.dev1"
 
 description = "A package for performing experiments in the QT3 lab at UW."
 readme = "README.md"
@@ -53,6 +53,7 @@ dependencies = [
     "nipiezojenapy>=1.0.4",
     "pulseblaster>=1.0.1",
     "PyYAML>=6.0.1",
+    "pythonnet>=3.0.3"
 ]
 
 [project.urls]

src/qt3utils/applications/controllers/nidaqedgecounter.py

@@ -137,6 +137,9 @@ def print_config(self) -> None:
 
 
 class QT3ScanNIDAQEdgeCounterController(QT3ScopeNIDAQEdgeCounterController):
+    """
+    Implements the qt3utils.applications.qt3scan.interface.QT3ScanCounterDAQControllerInterface for a NIDAQ edge counter.
+    """
 
     def __init__(self, logger_level):
         super().__init__(logger_level)
@@ -148,13 +151,5 @@ def clock_rate(self) -> float:
     def sample_counts(self, num_batches: int) -> np.ndarray:
         return self.data_generator.sample_counts(num_batches)
 
-    def sample_count_rate(self, data_counts: np.ndarray) -> np.ndarray:
+    def sample_count_rate(self, data_counts: np.ndarray) -> np.floating:
         return self.data_generator.sample_count_rate(data_counts)
-
-    @property
-    def num_data_samples_per_batch(self) -> int:
-        return self.data_generator.num_data_samples_per_batch
-
-    @num_data_samples_per_batch.setter
-    def num_data_samples_per_batch(self, value: int):
-        self.data_generator.num_data_samples_per_batch = value

src/qt3utils/applications/controllers/princeton_spectrometer.py

@@ -0,0 +1,142 @@
+import numpy as np
+import tkinter as tk
+import logging
+from typing import Tuple
+
+import qt3utils.datagenerators.princeton as princeton
+
+
+class QT3ScanPrincetonSpectrometerController:
+    """
+    Implements qt3utils.applications.qt3scan.interface.QT3ScanSpectrometerDAQControllerInterface
+    """
+    def __init__(self, logger_level: int):
+        self.logger = logging.getLogger(__name__)
+        self.logger.setLevel(logger_level)
+
+        self.spectrometer = princeton.SpectrometerDataAcquisition()
+        self.last_config_dict = {}
+
+        self.wave_start = None
+        self.wave_end = None
+        self.last_measured_spectrum = None
+        self.last_wavelength_array = None
+
+    @property
+    def clock_rate(self) -> float:
+        try:
+            _t = self.spectrometer.exposure_time / 1000.0  # Converting from milliseconds to seconds.
+        except Exception as e:
+            self.logger.error(e)
+            _t = 2  # TODO: better default behavior. Should this be -1? 1? or should Spectrometer be changed.
+        return 1.0 / _t
+
+    def start(self) -> None:
+        """
+        Nothing to be done in this method. All acquisition is happening in the "sample_spectrum" method.
+        """
+        self.logger.debug('calling QT3ScanPrincetonSpectrometerController start')
+
+    def stop(self) -> None:
+        """
+        Implementations should do necessary steps to stop acquiring data.
+        """
+        self.spectrometer.stop_scan()
+        self.logger.debug('calling QT3ScanPrincetonSpectrometerController stop')
+
+    def close(self) -> None:
+        self.spectrometer.finalize()
+
+    def sample_spectrum(self) -> Tuple[np.ndarray, np.ndarray]:
+        self.last_measured_spectrum, self.last_wavelength_array = (self.spectrometer.acquire_step_and_glue([self.wave_start, self.wave_end]))
+        #self.logger.debug(f'Length of what you pulled from get_wavelengths is {len(self.spectrometer.get_wavelengths())}')
+        #self.logger.debug(f'Length of measured spectrum is {len(self.last_measured_spectrum)} and length of last wave array is {len(self.last_wavelength_array)}')
+        self.logger.debug(f'acquired spectrum from {self.last_wavelength_array[0]} to {self.last_wavelength_array[-1]} nm')
+        return self.last_measured_spectrum, self.last_wavelength_array
+
+    def configure(self, config_dict: dict) -> None:
+        """
+        This method is used to configure the spectrometer with the provided settings.
+        """
+        self.logger.debug("Calling configure on the Princeton Spectrometer data controller")
+        self.last_config_dict.update(config_dict)
+
+        self.spectrometer.experiment_name = config_dict.get('experiment_name', self.spectrometer.experiment_name)
+        self.spectrometer.exposure_time = config_dict.get('exposure_time', self.spectrometer.exposure_time)
+        self.spectrometer.center_wavelength = config_dict.get('center_wavelength', self.spectrometer.center_wavelength)
+        self.spectrometer.temperature_sensor_setpoint = config_dict.get('temperature_sensor_setpoint', self.spectrometer.temperature_sensor_setpoint)
+        self.spectrometer.grating = config_dict.get('grating', self.spectrometer.grating)
+        self.wave_start = config_dict.get('wave_start', self.wave_start)
+        self.wave_end = config_dict.get('wave_end', self.wave_end)
+
+    def configure_view(self, gui_root: tk.Toplevel) -> None:
+        """
+        This method launches a GUI window to configure the data controller.
+        """
+        config_win = tk.Toplevel(gui_root)
+        config_win.grab_set()
+        config_win.title('Princeton Spectrometer Settings')
+
+        row = 0
+        tk.Label(config_win, text="Experiment Name)").grid(row=row, column=0, padx=10)
+        experiment_name_var = tk.StringVar(value=str(self.spectrometer.experiment_name))
+        tk.Entry(config_win, textvariable=experiment_name_var).grid(row=row, column=1)
+
+        row += 1
+        tk.Label(config_win, text="Exposure Time (ms)").grid(row=row, column=0, padx=10)
+        exposure_time_var = tk.DoubleVar(value=self.spectrometer.exposure_time)
+        tk.Entry(config_win, textvariable=exposure_time_var).grid(row=row, column=1)
+
+        row += 1
+        tk.Label(config_win, text="Center Wavelength (nm)").grid(row=row, column=0, padx=10)
+        center_wavelength_var = tk.DoubleVar(value=self.spectrometer.center_wavelength)
+        tk.Entry(config_win, textvariable=center_wavelength_var).grid(row=row, column=1)
+
+        row += 1
+        tk.Label(config_win, text="Temperature Sensor Setpoint (°C)").grid(row=row, column=0, padx=10)
+        temperature_sensor_setpoint_var = tk.DoubleVar(value=self.spectrometer.temperature_sensor_setpoint)
+        tk.Entry(config_win, textvariable=temperature_sensor_setpoint_var).grid(row=row, column=1)
+
+        row += 1
+        tk.Label(config_win, text="Grating").grid(row=row, column=0, padx=10)
+        grating_options = self.spectrometer.grating_options
+        grating_var = tk.StringVar(value=self.spectrometer.grating)
+        grating_menu = tk.OptionMenu(config_win, grating_var, *grating_options)
+        grating_menu.grid(row=row, column=1)
+
+        row += 1
+        tk.Label(config_win, text="Wavelength Start (nm)").grid(row=row, column=0, padx=10)
+        wave_start_var = tk.DoubleVar(value=self.wave_start)
+        tk.Entry(config_win, textvariable=wave_start_var).grid(row=row, column=1)
+
+        row += 1
+        tk.Label(config_win, text="Wavelength End (nm)").grid(row=row, column=0, padx=10)
+        wave_end_var = tk.DoubleVar(value=self.wave_end)
+        tk.Entry(config_win, textvariable=wave_end_var).grid(row=row, column=1)
+
+        # Pack variables into a dictionary to pass to the _set_from_gui method
+        gui_info = {
+            'experiment_name': experiment_name_var,
+            'exposure_time': exposure_time_var,
+            'center_wavelength': center_wavelength_var,
+            'temperature_sensor_setpoint': temperature_sensor_setpoint_var,
+            'grating': grating_var,
+            'wave_start': wave_start_var,
+            'wave_end': wave_end_var
+        }
+
+        row += 1
+        tk.Button(config_win, text='Set', command=lambda: self._set_from_gui(gui_info)).grid(row=row, column=0)
+        tk.Button(config_win, text='Close', command=config_win.destroy).grid(row=row, column=1)
+
+    def _set_from_gui(self, gui_vars: dict) -> None:
+        """
+        Sets the spectrometer configuration from the GUI.
+        """
+        config_dict = {k:v.get() if v.get() not in ['None', ''] else None for k, v in gui_vars.items()}  # code to handle the edge case where there are "None" value
+        self.logger.info(config_dict)
+        self.configure(config_dict)
+
+    def print_config(self) -> None:
+        print("Princeton Spectrometer config")
+        print(self.last_config_dict)  #NOTE: We dont' use the logger because we want to be sure this is printed to stdout

src/qt3utils/applications/controllers/princeton_spectrometer.yaml

@@ -0,0 +1,25 @@
+QT3Scan:
+  DAQController:
+    import_path : qt3utils.applications.controllers.princeton_spectrometer
+    class_name  : QT3ScanPrincetonSpectrometerController
+    configure :
+      exposure_time : 2000 # This is in ms
+      center_wavelength : 700 # This is in nm
+      temperature_sensor_setpoint : -70 # This is in Celsius
+      grating : "[500nm,300][2][0]" # Varies based on spectrometer type
+      wave_start : 600
+      wave_end : 850
+      experiment_name: "LF_Control"
+
+  PositionController:
+    import_path : qt3utils.applications.controllers.nidaqpiezocontroller
+    class_name  : QT3ScanNIDAQPositionController
+    configure :
+      daq_name : Dev1  # NI DAQ Device Name
+      write_channels : ao0,ao1,ao2  # NI DAQ analog output channels to use for writing position
+      read_channels : ai0,ai1,ai2  # NI DAQ analog input channels to use for reading position
+      scale_microns_per_volt : 8  # conversion factor from volts to microns, can also supply a list [8,8,8] or [6,4.2,5]
+      zero_microns_volt_offset: 0  # the voltage value that defines the position 0,0,0, can also supply a list [0,0,0] or [5,5,5]
+      minimum_allowed_position : 0  # microns
+      maximum_allowed_position : 80  # microns
+      settling_time_in_seconds : 0.001