experiments.bb_viper_interleaves module

Providing the “Broadband VIPER (Interleaves)” experiment. In this experiment, a broad IR pump pulse is used to excite the sample into the first vibrational state. A second UV/VIS pump pulse is used to further excite the sample into an electronically excited state. An IR probe pulse is used to scan the samples’ response. The IR delay stage is used to move to different delays of the IR pump pulse, the UV/VIS stage is used to move to different delays of the UV/VIS pump pulse. The broadband pulse contains all the pump frequencies generated by the OPA at once (in contrast to the Fabry Perot which only pumps at a single distinct frequency). For this experiment, the UV/VIS and IR chopper must be running. The IR pump pulse must temporally come before the UV/VIS pump pulse. Therefore the stages need to be set accordingly. To reduce IR pump light scattering on the detector, the IR delay stage is used to phase cycle the pump pulse. This is called “interleaves” and can be achieved because the delay stage can move distances that are fractions of the pump wavelength. This effectively only changes the phase of the pump light incident on the sample while the effect of the slightly altered delay is negligible.

VIPER stands for Vibrationally Promoted Electronic Resonance. Frequency domain VIPER experiments use 2 choppers. One chopper chops the IR Pump, the second one chops the UV/VIS Pump. The IR pump excites the molecules to a higher vibrational state. The UV/VIS pump pulse then excites the molecules from that higher vibrational state to an excited electronic state that is also vibrationally excited. An IR probe pulse is used to measure the changes induced in the molecule.

VIPER measurements typically contain 4 different types of signals. These are listed according to their chopper states:

  • (IR off, UV off): Background

  • (IR off, UV on): TRIR + Background

  • (IR on, UV off): IR pump/IR probe + Background

  • (IR on, UV on): VIPER + TRIR + IR pump/IR probe + Background

TRIR stands for transient IR signal.

Note

Delay Files:

If more than one delay file is required for an experiment (e.g. VIPER) the weights of all files are multiplied to yield a resulting weight. Generally, the delay files have to increase monotonously. For VIPER experiments the UV/VIS delay file does not have to increase monotonously. The IR delay file has to. For VIPER the delays files need to have a user given offset (time delay between the pump pulses). This is due to the fact that the IR pump pulse should temporally “arrive” before the UV/VIS pump pulse such that the VIPER signal is maximal. This time delay can be found by conducting a broadband VIPER experiment where the UV/VIS Stage is “scanned” while the IR delay remains static and then observing for which relative delay between the stages the VIPER signal is maximal. We observed that it can happen that the stages have to be set in the opposite way (as if the UV/VIS pump pulse arrives before the IR pump pulse. For examples stage positions such as IR delay stage 20,500 fs UV/VIS delay stage 20,000 fs might yield a good VIPER signal). This is can be attributed to the imprecision in determining the t zero position for each of the stages separately.

Chopper:

It is necessary to adjust the chopper phases. The light pulse travels through a different point of the chopper blade than the reference of the chopper itself. This results in a phase shift between the laser and the position on the chopper where the light passes through. To adjust for that it is necessary to carefully set the phase in such a way that the pulse or part of it is not cut of by the chopper blade. (Also make sure that the diameter of the pulse physically fits through the holes in the chopper blade.) It is also necessary to make sure that a HIGH signal is sent to the ADC when the laser pulse was able to pass through the chopper and a LOW signal is sent to the ADC when when the chopper blade was blocking the light. This adjustment is done via external electronics. For this a circuit that delays the TTL output of the chopper is used. For some kind of choppers additional electronics are required to make the chopper run at the desired frequency (frequency divider). For this experiment the IR Chopper typically runs at 1/4 and the UV/VIS Chopper on 1/2 of the laser frequency.

Step by Step Algorithm:

Acquisition:

  1. Preallocate dictionary (data container) which will contain data and information about scan index, delay index etc.

  2. Start moving the micrometer screw continuously

  3. Calculate the interleave positions

  4. Calculate the resulting weight from the UV/VIS and IR delay weights

  5. Set the number of samples to acquire to according to this weight

  6. Close UV/VIS Shutter

  7. Move IR and UV/VIS stage simultaneously to next respective delay

  8. Open UV/VIS Shutter

  9. Move to the interleaves (the 0th interleave is the actual delay)

  10. Read data for from the ADC

  11. Place data into dictionary and hand it over to primary processing

Primary Processing:

  1. Preallocate arrays for data, counts, weights, chopper, shot to shot data etc. Here there are 2 states for each chopper. Each chopper has its own axis in the arrays. Additionally an axis is added for the interleaves. Note that the interleaves are not “sorted” into separate states because we already know beforehand which interleave was measured (analogously to how it is done for the delays)

  2. Subtract background from raw data (dark noise)

  3. Linearize response of pixels

  4. Calculate transmission, or more precisely, relative intensity (probe intensity / reference intensity) for each laser shot for each pixel pair

  5. Identify the IR and UV/VIS the chopper states for all laser shots using the corresponding channel(s) in the ADCs’ data for both choppers

  6. Sort the data (transmissions) for each state and calculate statistics

  7. Calculate the s2s (shot to shot) VIPER signal and its statistical information

  8. Average the data by weighting equally

  9. Put this information into data container

  10. Save data (and raw data) including counts, weights and s2s_std if respective checkboxes on GUI were checked

  11. Hand over the data container to secondary processing process

Secondary Processing:

  1. Preallocate arrays for VIPER signal and phase cycled VIPER signal

  2. Phase cycle the interleaves in the transmission space (here it is done the way that we think is the correct way to phase cycle)

  3. Calculate absorption (-log10) of phase cycled transmissions

  4. Calculate absorption (-log10) of non phase cycled transmission for all states

  5. Calculate all difference signals (without phase cycling to display the current interleave):

    • (IR off, UV off): Background

    • (IR off, UV on): TRIR + Background

    • (IR on, UV off): IR pump/IR probe + Background

    • (IR on, UV on): VIPER + TRIR + IR pump/IR probe + Background

    subtract them in the proper way to obtain:

    • TRIR: (IR off, UV on) - (IR off, UV off)

    • Pseudo TRIR: (IR on, UV on) - (IR on, UV off)

    • IR Pump: (IR on, UV off) - (IR off, UV off)

    • Pseudo IR Pump:(IR on, UV on) - (IR off, UV on)

    • VIPER signal: (IR on, UV on) - (IR on, UV off) - (IR off, UV on) + (IR off, UV off)

  6. Calculate the average intensities and standard deviation of the intensities for each pixel

  7. Put this information into data container and hand it over to Pyqtplotting thread

  8. Calculate the numbers which are displayed in the “statistics box” on the GUI

Pyqt Plotting:

  1. Remove old plots

  2. Setup the plot that displays:

    • Phase cycled VIPER signal and interleaves for current delay

    • Time-signal 2D heatmap (single scan and scan averaged)

    • Intensities and their standard deviation (multiplied by 5)

    • Standard deviation of shot to shot VIPER signal

    • The additional four signals for the current interleave

  3. Plot the plots for the first time

  4. Update plots

Saving:

Note that in the programming data dimension only the IR delays are necessary, because we always move both stages at the same time.

programming data dimension:
[(2 ([0] is current average scan, [1] is last single scan), n_probe_pixels, n_delays, n_interleaves, n_ir_chopper_states, n_vis_chopper_states)]

saving dimension:
[(n_probe_pixels, n_interleaves, n_ir_chopper_states, n_vis_chopper_states)]

raw data dimension:
[(n_channels, samples_to_acquire)]

Folder Structure

In scans/dXXX the first file of 4 contains the data in the saving dimensions. The counts file contains the number of times a given state was observed. This should be used as weights when averaging equally weighted. The weights file contains the inverse variances of a given state for all pixels, etc. The dimensions of these files are as the saving dimension suggests. These files can be used to average in different ways to obtain the complete resulting spectrum. Check the actual code of the corresponding experiment to understand how to calculate the desired end result (VIPER spectrum). The s2s_std file contains the standard deviation of the shot to shot VIPER spectrum (this was used in the old software as weights to average different scans. However, this method of averaging has ambiguity and it has been proven difficult to reason why it should work when averaging transmissions. It is saved so that the option to revert to this averaging method exists). Note that the dimensionality of the s2s_std file is not as “saving dimension” suggests since it results from difference spectra. This means that except for the probe pixel dimension every other dimension collapses.

The data in /averaged_data is averaged equally weighted (using counts). Likewise to the scan data the difference spectrum still needs to be calculated from the transmissions for every state. Because the array contains the transmissions averaged with counts it is only intended to be used as a first indicator for the measurement.

The /figure folder is currently empty. It is possible to implement plotting of figures which are saved here while the experiment is running. This is however not implemented yet.

The /hardware config folder holds every file which contains hardware configuration parameters. This folder is a compressed copy of the hardware configuration folder in the software’s directory. Here it is possible to look up the ADC configuration to obtain what channel was connected to which hardware element (e.g. chopper - ai78). It is also possible to obtain the R-2R values, the FPAS configuration, the linearization parameters, etc.

The /raw data folder is in the experiments directory only if the “save raw data” checkbox on the GUI was checked. It contains the raw (unedited… as raw as it can get) data. Basically, the voltages which the ADC measured for each channel. The dimensions are as “raw data dimensions” suggests.

The background.npy file is a copy of the most recently collected dark noise background of the MCT detector array. It corrects for dark noise. If no new background was collected before the experiment was started the code will use the latest available background and display a warning in the log.

setupinfo.txt is a ReadMe file that contains the most relevant experimental parameters at first glance. Additionally, the user can decide to write a comment in the readme editor of the GUI. The content of this is written to the notes.txt file.

probe_wn_axis.npy contains the wavenumber axis which is generated by the spectrometer triax.py class.

delays.npy contains the delays including weights.

username/
├── date1_experimentname1_000/
│   ├── averaged_data
│   │   ├──  d000_date1_experimentname1_000.npy
│   │   ├──  ...
│   │   └──  d999_date1_experimentname1_000.npy
│   ├── figures
│   ├── hardware config
│   ├── raw data
│   │   ├──  delay000
│   │   │   ├──  s000000_d000_intl000_date1_experimentname1_000_raw.npy
│   │   │   ├──  s000000_d000_intl001_date1_experimentname1_000_raw.npy
│   │   │   ├──  ...
│   │   │   └──  s000099_d000_intl016_date1_experimentname1_000_raw.npy
│   │   ├──  ...
│   │   └──  delay999
│   ├── scans
│   │   ├──  delay000
│   │   │   ├──  s000000_d000_date1_experimentname1_000.npy
│   │   │   ├──  s000000_d000_counts_date1_experimentname1_000.npy
│   │   │   ├──  s000000_d000_s2s_std_date1_experimentname1_000.npy
│   │   │   ├──  s000000_d000_weights_date1_experimentname1_000.npy
│   │   │   ├──  ...
│   │   │   └──  s000099_d000_date1_experimentname1_000.npy
│   │   ├──  ...
│   │   └──  delay999
│   ├── probe_wn_axis_date1_experimentname1_000.npy
│   ├── delays_date1_experimentname1_000.npy
│   ├── setupinfo_date1_experimentname1_000.txt
│   ├── notes_date1_experimentname1_000.txt
│   └── background_date1_experimentname1_000.npy
├── date1_experimentname1_001/
├── date2_experimentname1_000/
└── date2_experimentname2_000/
class Acquisition(vis_delays: numpy.ndarray, ir_delays: numpy.ndarray, interleaves: int, adc: analog_digital_converter.AnalogDigitalConverter, vis_delay_stage: pi_control.PiStage, ir_delay_stage: pi_control.PiStage, spectrometer: triax.Triax, mu_screw: newport_control.NewportControl, vis_shutter: shutter.Shutter, acq_queue: multiprocessing.context.BaseContext.Queue)[source]

Bases: threading.Thread

Acquisition class (python multithreaded). This is where the actual experiment is conducted.

This class is used to control the hardware devices required for the experiment. The sole purpose of it is to collect the data according to the parameters specified for the experiment by moving the delay stages, opening and closing shutters etc.

A dictionary which will contain data and other information (scan index etc.) is instantiated here. The acquisition class passes the collected information (raw data, scan index etc.) to the primary processing class.

Note

No data processing beyond what is required to conduct the experiment should be implemented in this class. The rationale behind this is to minimize down time/ maximize laser time. Data processing costs computation time and will, generally speaking, slow down the measurement process because the computer is busy while the rest of the hardware is idle. If implemented correctly the data processing could be carried out while the data acquisition is waiting for all data to become available. But even in this scenario the problem that the data processing takes longer than the acquisition time can occur and is thus best avoided through parallelisation.

The reason why this class is a child of the threading module instead of the multiprocessing module is that to use multiprocessing all objects passed to the function must be picklable. This is not the case for some of the objects interfacing with the hardware (e.g. ADC). In an ideal scenario the acquisition too, would run in its own process seperated from the GUI thread but this would only be possible with major restructuring of the software.

Parameters

  • vis_delays (ndarray) –

    Array containing the delays in fs for the UV/VIS stage in the 0th column and their corresponding weights in the 1st column. I.e.: loaded from a delay file which can be generated via the delay file editor. These delays need to be temporally offset relative to the IR delays.

    • shape: 2D

    • E.g.: (number of delays, 2)

  • ir_delays (ndarray) –

    Array containing the delays in fs for the IR stage in the 0th column and their corresponding weights in the 1st column. I.e.: loaded from a delay file which can be generated via the delay file editor. These delays need to be temporally offset relative to the IR delays.

    • shape: 2D

    • E.g.: (number of delays, 2)

  • interleaves (int) – Number of interleaves that should be scanned. Number should be even and a power of 2. An interleave is a small step of the delay stage (in addition to the normal delay) used for phase cycling and removing scattering.

  • adc (ADC) – Analog to digital converter hardware object which is used to communicate with and read data from the ADC.

  • vis_delay_stage (PiStage) – PiStage hardware control object which provides the interface to the UV/VIS delay stage.

  • ir_delay_stage (PiStage) – PiStage hardware control object which provides the interface to the IR delay stage.

  • spectrometer (Spectrometer) – Spectrometer/Triax hardware class which grants functionality to control the triax spectrometer. Needed to obtain e.g. wavenumber axis etc.

  • mu_screw (MuScrew) – NewportControl object that can be used to move the micrometer screw.

  • vis_shutter (Shutter) – Shutter object that can be used to open and close the UV/VIS (pump) shutter.

  • acq_queue (Queue) – Multiprocessing queue object that the acquisition thread uses to pass data to the primary processing process.

run()[source]

Method representing the thread’s activity.

You may override this method in a subclass. The standard run() method invokes the callable object passed to the object’s constructor as the target argument, if any, with sequential and keyword arguments taken from the args and kwargs arguments, respectively.

shutdown()[source]
class BbViperInterleaves(widget_pyqtgraph, vis_delays: numpy.ndarray, ir_delays: numpy.ndarray, interleaves: int, adc: analog_digital_converter.AnalogDigitalConverter, vis_delay_stage: pi_control.PiStage, ir_delay_stage: pi_control.PiStage, prl: data_processing.PixelResponseLinearization, vis_chopper_info: dict, ir_chopper_info: dict, background_handler: save_data.Background, spectrometer: triax.Triax, mu_screw: newport_control.NewportControl, vis_shutter: shutter.Shutter, info_queue: multiprocessing.context.BaseContext.Queue, saver: Optional[save_data.SaveData] = None)[source]

Bases: object

Parameters

  • widget_pyqtgraph (QWidget) – WidgetPyqtgraph object on which the plots are going to be displayed. Has methods for plot manipulation (i.e. removal of plots, autoscale).

  • vis_delays (ndarray) –

    Array containing the delays in fs for the UV/VIS stage in the 0th column and their corresponding weights in the 1st column. I.e.: loaded from a delay file which can be generated via the delay file editor. These delays need to be temporally offset relative to the IR delays.

    • shape: 2D

    • E.g.: (number of delays, 2)

  • ir_delays (ndarray) –

    Array containing the delays in fs for the IR stage in the 0th column and their corresponding weights in the 1st column. I.e.: loaded from a delay file which can be generated via the delay file editor. These delays need to be temporally offset relative to the IR delays.

    • shape: 2D

    • E.g.: (number of delays, 2)

  • interleaves (int) – Number of interleaves that should be scanned. Number should be even and a power of 2. An interleave is a small step of the delay stage (in addition to the normal delay) used for phase cycling and removing scattering.

  • adc (ADC) – Analog to digital converter hardware object which is used to communicate with and read data from the ADC.

  • vis_delay_stage (PiStage) – PiStage hardware control object which provides the interface to the UV/VIS delay stage.

  • ir_delay_stage (PiStage) – PiStage hardware control object which provides the interface to the IR delay stage.

  • prl (PRL) – Pixel response linearization object which grants the functionality to linearize raw data according to the linearization parameters specified in the corresponding pixel_linearization_fit_parameters.json file (for each lab).

  • vis_chopper_info (dict) – Contains the information that is necessary to identify the different chopper states of the chopper that chops the UV/VIS pump pulse. It contains the keys “high voltage level” and “name”. “high voltage level” is the voltage read by the ADC when the chopper reference output is high. It is needed as a reference for the digitization function that is used. The “name” key is required to determine to which channel of the adc the chopper is connected and its value needs to match the corresponding key in index_dict.

  • ir_chopper_info (dict) – Contains the information that is necessary to identify the different chopper states of the chopper that chops the IR pump pulse. It contains the keys “high voltage level” and “name”. “high voltage level” is the voltage read by the ADC when the chopper reference output is high. It is needed as a reference for the digitization function that is used. The “name” key is required to determine to which channel of the adc the chopper is connected and its value needs to match the corresponding key in index_dict.

  • background_handler (Background) – Instance of Background class which can access the most recently collected background. This background is later subtracted from the raw data as dark noise correction.

  • spectrometer (Spectrometer) – Spectrometer/Triax hardware class which grants functionality to control the triax spectrometer. Needed to obtain e.g. wavenumber axis etc.

  • mu_screw (MuScrew) – NewportControl object that can be used to move the micrometer screw.

  • vis_shutter (Shutter) – Shutter object that can be used to open and close the UV/VIS (pump) shutter.

  • info_queue (Queue) – Multiprocessing queue object which is used to transfer/hand over information to lineEdits on GUI. Contains (if applicable) scan index, delay index, interleave index, values for statistics groupBox etc.

  • saver (SaveData) – Object that manages saving of data (including counts, weights, probe wavenumber axis etc.) into their respective directories. If None is passed, no data is going to be saved. If the raw data checkbox was checked on the GUI the savers raw data attribute is set to True and the raw data is saved automatically. Defaults to None.

start()[source]
class PrimaryProcessing(acq_queue: multiprocessing.context.BaseContext.Queue, processing_queue: multiprocessing.context.BaseContext.Queue, vis_delays: numpy.ndarray, ir_delays: numpy.ndarray, interleaves: int, pixel_idx: numpy.ndarray, probe_pixel_idx: numpy.ndarray, reference_pixel_idx: numpy.ndarray, index_dict: dict, prl: data_processing.PixelResponseLinearization, ir_chopper_info: dict, vis_chopper_info: dict, background_handler: save_data.Background, saver: Optional[save_data.SaveData] = None)[source]

Bases: multiprocessing.context.Process

Primary processing class (python multiprocess). This class’ purpose is to process the raw data to a state where it can be saved onto the hard drive as npy (binary) files.

This step generally includes linearization, normalisation, sorting and averaging. Besides the actual data additional information that is required for post processing purposes is calculated and saved. I.e. counts and weights. The last step of primary processing should always be to pass the data to secondary processing and save it to the hard disk.

Note

The actual signal(s) are generally not intended to be calculated here. Signals and other information that is supposed to be displayed on the GUI should be calculated in secondary processing. The main reason for this is minimizing the risk of an error leading to a crash of the software which then in turn ruins the measurement. The more code that has to run the more likely a crash becomes. Others reasons mostly imply open questions regarding averaging. Generally, shot to shot normalized intensities that are sorted and averaged by their state are saved (m2 method). From this - for a simple experiment at least - the signal can be easily calculated while offering different choices of averaging in post processing. For more complex experiments e.g. VIPER or time domain experiments the argument of saving sorted transmissions instead of signals is even more compelling. In VIPER experiments more than one signal of interest is present in the different states. Saving each signal separately would actually increase the amount of data that has to be saved. For time domain experiments we want to save the data in the time domain for post processing reasons like zeropadding and apodization.

The goal of primary processing is to make the data as compact as possible while keeping as much information and flexibility as possible. Even if the processes later on crash, the data is secured and can be analysed in post processing.

Parameters

  • acq_queue (Queue) – Multiprocessing queue object that the acquisition thread uses to pass data to the primary processing process.

  • processing_queue (Queue) – Multiprocessing queue object that the primary processing process uses to pass data to the secondary processing process.

  • vis_delays (ndarray) –

    Array containing the delays in fs for the UV/VIS stage in the 0th column and their corresponding weights in the 1st column. I.e.: loaded from a delay file which can be generated via the delay file editor. These delays need to be temporally offset relative to the IR delays.

    • shape: 2D

    • E.g.: (number of delays, 2)

  • ir_delays (ndarray) –

    Array containing the delays in fs for the IR stage in the 0th column and their corresponding weights in the 1st column. I.e.: loaded from a delay file which can be generated via the delay file editor. These delays need to be temporally offset relative to the IR delays.

    • shape: 2D

    • E.g.: (number of delays, 2)

  • interleaves (int) – Number of interleaves that should be scanned. Number should be even and a power of 2. An interleave is a small step of the delay stage (in addition to the normal delay) used for phase cycling and removing scattering.

  • pixel_idx (ndarray) –

    Array that contains the indices of the rows in the ADCs’ data that correspond to pixel input channels. These are specified in the “analog input configuration.json” for each laboratory and can be easily accessed with the attribute “pixel_idx” of the ADC.

    • shape: 1D

    • E.g.: (64) or (128)

  • probe_pixel_idx (ndarray) –

    Array that contains the indices of the rows in the ADCs’ data that correspond to probe pixel input channels. These are specified in the “analog input configuration.json” for each laboratory and can be easily accessed with the attribute “probe_pixel_idx” of the ADC. It is highly relevant that the order the pixels are listed in this array match the order of the array in the reference_pixel_idx argument. This means that if reference pixel 3 is listed first in the other array here probe pixel 3 needs to be listed first as well and so on. Otherwise the intensities on the probe array are not going to be normalized correctly. For the plotting to work correctly the pixels also need to be listed in the order of the wavenumber axis array of the spectrometer.

    • shape: 1D

    • E.g.: (32) or (64)

  • reference_pixel_idx (ndarray) –

    Array that contains the indices of the rows in the ADCs’ data that correspond to reference pixel input channels. These are specified in the “analog input configuration.json” for each laboratory and can be easily accessed with the attribute “reference_pixel_idx” of the ADC. It is highly relevant that the order the pixels are listed in this array match the order of the array in the probe_pixel_idx argument. This means that if probe pixel 10 is listed first in the other array here reference pixel 10 needs to be listed first as well and so on. Otherwise the intensities on the probe array are not going to be normalized correctly. For the plotting to work correctly the pixels also need to be listed in the order of the wavenumber axis array of the spectrometer.

    • shape: 1D

    • E.g.: (32) or (64)

  • index_dict (dict) – Dictionary that maps the names of the input channels to their corresponding row in the ADCs’ data as they are specified in the “analog input configuration.json” for each laboratory. I.e.: It contains the information which entries of the ADCs’ data array belong choppers, wobblers etc. This dictionary can be easily accessed with the attribute “index_dict” of the ADC.

  • prl (PRL) – Pixel response linearization object which grants the functionality to linearize raw data according to the linearization parameters specified in the corresponding pixel_linearization_fit_parameters.json file (for each lab).

  • vis_chopper_info (dict) – Contains the information that is necessary to identify the different chopper states of the chopper that chops the UV/VIS pump pulse. It contains the keys “high voltage level” and “name”. “high voltage level” is the voltage read by the ADC when the chopper reference output is high. It is needed as a reference for the digitization function that is used. The “name” key is required to determine to which channel of the adc the chopper is connected and its value needs to match the corresponding key in index_dict.

  • ir_chopper_info (dict) – Contains the information that is necessary to identify the different chopper states of the chopper that chops the IR pump pulse. It contains the keys “high voltage level” and “name”. “high voltage level” is the voltage read by the ADC when the chopper reference output is high. It is needed as a reference for the digitization function that is used. The “name” key is required to determine to which channel of the adc the chopper is connected and its value needs to match the corresponding key in index_dict.

  • background_handler (Background) – Instance of Background class which can access the most recently collected background. This background is later subtracted from the raw data as dark noise correction.

  • saver (SaveData) – Object that manages saving of data (including counts, weights, probe wavenumber axis etc.) into their respective directories. If None is passed, no data is going to be saved. If the raw data checkbox was checked on the GUI the savers raw data attribute is set to True and the raw data is saved automatically. Defaults to None.

run()[source]

Method to be run in sub-process; can be overridden in sub-class

class PyqtPlotting(widget_pyqtgraph, adc: analog_digital_converter.AnalogDigitalConverter, plot_queue, vis_delays: numpy.ndarray, ir_delays: numpy.ndarray, interleaves: int)[source]

Bases: object

Pyqt Plotting class (Qt multithreaded). This class is necessary for displaying plots on the GUI. PyQtGraph is used as the plotting engine. Generally the plots are set up first (type of plot, layout, title etc.). On the first run, the plots are drawn for the first time. Then the plots are updated every iteration. We update the same plot references every time to make it more efficient.

Parameters

  • widget_pyqtgraph (QWidget) – WidgetPyqtgraph object on which the plots are going to be displayed. Has methods for plot manipulation (i.e. removal of plots, autoscale).

  • adc (ADC) – Analog to digital converter hardware object which is used to communicate with and read data from the ADC.

  • plot_queue (Queue) – Multiprocessing queue object that the secondary processing process uses to pass data to the plot thread.

  • vis_delays (ndarray) –

    Array containing the delays in fs for the UV/VIS stage in the 0th column and their corresponding weights in the 1st column. I.e.: loaded from a delay file which can be generated via the delay file editor. These delays need to be temporally offset relative to the IR delays.

    • shape: 2D

    • E.g.: (number of delays, 2)

  • ir_delays (ndarray) –

    Array containing the delays in fs for the IR stage in the 0th column and their corresponding weights in the 1st column. I.e.: loaded from a delay file which can be generated via the delay file editor. These delays need to be temporally offset relative to the IR delays.

    • shape: 2D

    • E.g.: (number of delays, 2)

  • interleaves (int) – Number of interleaves that should be scanned. Number should be even and a power of 2. An interleave is a small step of the delay stage (in addition to the normal delay) used for phase cycling and removing scattering.

class Signals[source]

Bases: PyQt5.QtCore.QObject

new_data
run()[source]
update_plot(data_container)[source]
class SecondaryProcessing(processing_queue: multiprocessing.context.BaseContext.Queue, plot_queue: multiprocessing.context.BaseContext.Queue, info_queue: multiprocessing.context.BaseContext.Queue, vis_delays: numpy.ndarray, ir_delays: numpy.ndarray, interleaves: int, probe_pixel_idx: numpy.ndarray)[source]

Bases: multiprocessing.context.Process

Secondary processing class (python multiprocess). This class is used to process the data from the primary processing class such that it can be displayed on the GUI within plots and lineEdits. This generally implies (if applicable):

  • calculation of signals

  • calculation of statistics like standard deviation of intensities and shot to shot standard deviation of signal

  • interpolation for 2D / heatmap plots (see comments in code why this is necessary)

  • Fourier transform and phasing for time domain data

This data is handed over to the plotting thread.

Note

The feature of saving figures/plots to the hard drive should be implemented here if it is needed.

Parameters

  • processing_queue (Queue) – Multiprocessing queue object that the primary processing process uses to pass data to the secondary processing process.

  • plot_queue (Queue) – Multiprocessing queue object that the secondary processing process uses to pass data to the plot thread.

  • info_queue (Queue) – Multiprocessing queue object which is used to transfer/hand over information to lineEdits on GUI. Contains (if applicable) scan index, delay index, interleave index, values for statistics groupBox etc.

  • vis_delays (ndarray) –

    Array containing the delays in fs for the UV/VIS stage in the 0th column and their corresponding weights in the 1st column. I.e.: loaded from a delay file which can be generated via the delay file editor. These delays need to be temporally offset relative to the IR delays.

    • shape: 2D

    • E.g.: (number of delays, 2)

  • ir_delays (ndarray) –

    Array containing the delays in fs for the IR stage in the 0th column and their corresponding weights in the 1st column. I.e.: loaded from a delay file which can be generated via the delay file editor. These delays need to be temporally offset relative to the IR delays.

    • shape: 2D

    • E.g.: (number of delays, 2)

  • interleaves (int) – Number of interleaves that should be scanned. Number should be even and a power of 2. An interleave is a small step of the delay stage (in addition to the normal delay) used for phase cycling and removing scattering.

  • probe_pixel_idx (ndarray) –

    Array that contains the indices of the rows in the ADCs’ data that correspond to probe pixel input channels. These are specified in the “analog input configuration.json” for each laboratory and can be easily accessed with the attribute “probe_pixel_idx” of the ADC. It is highly relevant that the order the pixels are listed in this array match the order of the array in the reference_pixel_idx argument. This means that if reference pixel 3 is listed first in the other array here probe pixel 3 needs to be listed first as well and so on. Otherwise the intensities on the probe array are not going to be normalized correctly. For the plotting to work correctly the pixels also need to be listed in the order of the wavenumber axis array of the spectrometer.

    • shape: 1D

    • E.g.: (32) or (64)

run()[source]

Method to be run in sub-process; can be overridden in sub-class