lantz.drivers.andor

company:Andor
description:Scientific cameras.
website:http://www.andor.com/

copyright:2015 by Lantz Authors, see AUTHORS for more details.
license:BSD, see LICENSE for more details.
class lantz.drivers.andor.Andor(*args, **kwargs)[source]

Bases: lantz.foreign.LibraryDriver

close_async(*args, **kwargs)

(Async) Close camera self.AT_H.

command(strcommand)[source]

Run command.

finalize()[source]

Finalize Library. Concluding function.

flush()[source]
getbool(strcommand)[source]

Run command and get Bool return value.

getenumerated(strcommand)[source]

Run command and set Enumerated return value.

getfloat(strcommand)[source]

Run command and get Int return value.

getint(strcommand)[source]

Run command and get Int return value.

initialize()[source]

Initialize Library.

is_implemented(strcommand)[source]

Checks if command is implemented.

is_writable(strcommand)[source]

Checks if command is writable.

open_async(*args, **kwargs)

(Async) Open camera self.AT_H.

queuebuffer(bufptr, value)[source]

Put buffer in queue.

setbool(strcommand, value)[source]

Set command with Bool value parameter.

setenumerated(strcommand, value)[source]

Set command with Enumerated value parameter.

setenumstring(strcommand, item)[source]

Set command with EnumeratedString value parameter.

setfloat(strcommand, value)[source]

Set command with Float value parameter.

setint(strcommand, value)[source]

SetInt function.

waitbuffer(ptr, bufsize)[source]

Wait for next buffer ready.

LIBRARY_NAME = 'atcore.dll'
LIBRARY_NAME_changed
close = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f5212550>>, None)
close_changed
command_changed
finalize_changed
flush_changed
getbool_changed
getenumerated_changed
getfloat_changed
getint_changed
initialize_changed
is_implemented_changed
is_writable_changed
open = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f52124a8>>, None)
open_changed
queuebuffer_changed
setbool_changed
setenumerated_changed
setenumstring_changed
setfloat_changed
setint_changed
waitbuffer_changed
class lantz.drivers.andor.Neo(*args, **kwargs)[source]

Bases: lantz.drivers.andor.andor.Andor

Neo Andor CMOS Camera

initialize()[source]
take_image_async(*args, **kwargs)

(Async) Image acquisition with circular buffer.

clock_rate

Pixel clock rate

Values:{200: ‘200 MHz’, 280: ‘280 MHz’, 100: ‘100 MHz’}
clock_rate_changed
exposure_time

Get exposure time.

exposure_time_changed
fan_peed

Fan speed.

fan_peed_changed
initialize_changed
pixel_encoding

Pixel encoding.

Values:{32: ‘Mono32’, 64: ‘Mono64’}
pixel_encoding_changed
roi

Set region of interest

roi_changed
sensor_size
sensor_size_changed
sensor_temp

Sensor temperature.

sensor_temp_changed
take_image = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f51ef8d0>>, None)
take_image_changed
class lantz.drivers.andor.CCD(*args, **kwargs)[source]

Bases: lantz.foreign.LibraryDriver

QE(wl)[source]

Returns the percentage QE for a particular head model at a user specified wavelength.

abort_acquisition_async(*args, **kwargs)

(Async) This function aborts the current acquisition if one is active

acquired_data(shape)[source]

This function will return the data from the last acquisition. The data are returned as long integers (32-bit signed integers). The “array” must be large enough to hold the complete data set.

acquired_data16(shape)[source]

16-bit version of the GetAcquiredData function. The “array” must be large enough to hold the complete data set.

amp_available(iamp)[source]

This function checks if the hardware and current settings permit the use of the specified amplifier.

amp_descr(index)[source]

This function will return a string with an amplifier description. The amplifier is selected using the index. The SDK has a string associated with each of its amplifiers. The maximum number of characters needed to store the amplifier descriptions is 21. The user has to specify the number of characters they wish to have returned to them from this function.

amp_max_hspeed(index)[source]

This function will return the maximum available horizontal shift speed for the amplifier selected by the index parameter.

bit_depth(ch)[source]

This function will retrieve the size in bits of the dynamic range for any available AD channel.

camera_handle(index)[source]

This function returns the handle for the camera specified by cameraIndex. When multiple Andor cameras are installed the handle of each camera must be retrieved in order to select a camera using the SetCurrentCamera function. The number of cameras can be obtained using the GetAvailableCameras function.

Parameters:index – index of any of the installed cameras. Valid values: 0 to NumberCameras-1 where NumberCameras is the value returned by the GetAvailableCameras function.
cancel_wait_async(*args, **kwargs)

(Async) This function restarts a thread which is sleeping within the WaitForAcquisition function. The sleeping thread will return from WaitForAcquisition with a value not equal to DRV_SUCCESS.

command(strcommand)[source]

Run command.

count_convert_available(mode)[source]

This function checks if the hardware and current settings permit the use of the specified Count Convert mode.

exposure_times(value)[source]
finalize()[source]

Finalize Library. Concluding function.

flush()[source]
free_int_mem_async(*args, **kwargs)

(Async) The FreeInternalMemory function will deallocate any memory used internally to store the previously acquired data. Note that once this function has been called, data from last acquisition cannot be retrived.

getbool(strcommand)[source]

Run command and get Bool return value.

getenumerated(strcommand)[source]

Run command and set Enumerated return value.

getfloat(strcommand)[source]

Run command and get Int return value.

getint(strcommand)[source]

Run command and get Int return value.

images(first, last, shape, validfirst, validlast)[source]

This function will update the data array with the specified series of images from the circular buffer. If the specified series is out of range (i.e. the images have been overwritten or have not yet been acquired) then an error will be returned.

Parameters:
  • first – index of first image in buffer to retrieve.
  • flast – index of last image in buffer to retrieve.
  • farr – pointer to data storage allocated by the user.
  • size – total number of pixels.
  • fvalidfirst – index of the first valid image.
  • fvalidlast – index of the last valid image.
images16(first, last, shape, validfirst, validlast)[source]

16-bit version of the GetImages function.

initialize()[source]

This function will initialize the Andor SDK System. As part of the initialization procedure on some cameras (i.e. Classic, iStar and earlier iXion) the DLL will need access to a DETECTOR.INI which contains information relating to the detector head, number pixels, readout speeds etc. If your system has multiple cameras then see the section Controlling multiple cameras.

is_implemented(strcommand)[source]

Checks if command is implemented.

is_writable(strcommand)[source]

Checks if command is writable.

most_recent_image(shape)[source]

This function will update the data array with the most recently acquired image in any acquisition mode. The data are returned as long integers (32-bit signed integers). The “array” must be exactly the same size as the complete image.

most_recent_image16(shape)[source]

16-bit version of the GetMostRecentImage function.

n_horiz_shift_speeds(channel=0, typ=None)[source]

As your Andor SDK system is capable of operating at more than one horizontal shift speed this function will return the actual number of speeds available.

Parameters:
  • channel – the AD channel.
  • typ – output amplification. 0 electron multiplication. 1 conventional.
oldest_image(shape)[source]

This function will update the data array with the oldest image in the circular buffer. Once the oldest image has been retrieved it no longer is available. The data are returned as long integers (32-bit signed integers). The “array” must be exactly the same size as the full image.

oldest_image16(shape)[source]

16-bit version of the GetOldestImage function.

preamp_available(channel, amp, index, preamp)[source]

This function checks that the AD channel exists, and that the amplifier, speed and gain are available for the AD channel.

preamp_descr(index)[source]

This function will return a string with a pre amp gain description. The pre amp gain is selected using the index. The SDK has a string associated with each of its pre amp gains. The maximum number of characters needed to store the pre amp gain descriptions is 30. The user has to specify the number of characters they wish to have returned to them from this function.

prepare_acquisition_async(*args, **kwargs)

(Async) This function reads the current acquisition setup and allocates and configures any memory that will be used during the acquisition. The function call is not required as it will be called automatically by the StartAcquisition function if it has not already been called externally. However for long kinetic series acquisitions the time to allocate and configure any memory can be quite long which can result in a long delay between calling StartAcquisition and the acquisition actually commencing. For iDus, there is an additional delay caused by the camera being set-up with any new acquisition parameters. Calling PrepareAcquisition first will reduce this delay in the StartAcquisition call.

queuebuffer(bufptr, value)[source]

Put buffer in queue.

readout_flipped(iamp)[source]

On cameras with multiple amplifiers the frame readout may be flipped. This function can be used to determine if this is the case.

save_raw_async(*args, **kwargs)

(Async) This function saves the last acquisition as a raw data file. See self.savetypes for the file type keys.

send_software_trigger_async(*args, **kwargs)

(Async) This function sends an event to the camera to take an acquisition when in Software Trigger mode. Not all cameras have this mode available to them. To check if your camera can operate in this mode check the GetCapabilities function for the Trigger Mode AC_TRIGGERMODE_CONTINUOUS. If this mode is physically possible and other settings are suitable (IsTriggerModeAvailable) and the camera is acquiring then this command will take an acquisition.

NOTES: The settings of the camera must be as follows: - ReadOut mode is full image - RunMode is Run Till Abort - TriggerMode is 10

sensitivity(ad, amp, i, pa)[source]

This function returns the sensitivity for a particular speed.

set_accum_time_async(*args, **kwargs)

(Async) This function will set the accumulation cycle time to the nearest valid value not less than the given value. The actual cycle time used is obtained by GetAcquisitionTimings. Please refer to SECTION 5 – ACQUISITION MODES for further information.

set_dma_parameters(n_max_images, s_per_dma)[source]

In order to facilitate high image readout rates the controller card may wait for multiple images to be acquired before notifying the SDK that new data is available. Without this facility, there is a chance that hardware interrupts may be lost as the operating system does not have enough time to respond to each interrupt. The drawback to this is that you will not get the data for an image until all images for that interrupt have been acquired. There are 3 settings involved in determining how many images will be acquired for each notification (DMA Interrupt) of the controller card and they are as follows:

1. The size of the DMA buffer gives an upper limit on the number of images that can be stored within it and is usually set to the size of one full image when installing the software. This will usually mean that if you acquire full frames there will never be more than one image per DMA.

2. A second setting that is used is the minimum amount of time (SecondsPerDMA) that should expire between interrupts. This can be used to give an indication of the reponsiveness of the operating system to interrupts. Decreasing this value will allow more interrupts per second and should only be done for faster pcs. The default value is 0.03s (30ms), finding the optimal value for your pc can only be done through experimentation.

3. The third setting is an overide to the number of images calculated using the previous settings. If the number of images per dma is calculated to be greater than MaxImagesPerDMA then it will be reduced to MaxImagesPerDMA. This can be used to, for example, ensure that there is never more than 1 image per DMA by setting MaxImagesPerDMA to 1. Setting MaxImagesPerDMA to zero removes this limit. Care should be taken when modifying these parameters as missed interrupts may prevent the acquisition from completing.

set_exposure_time_async(*args, **kwargs)

(Async) This function will set the exposure time to the nearest valid value not less than the given value, in seconds. The actual exposure time used is obtained by GetAcquisitionTimings. Please refer to SECTION 5 – ACQUISITION MODES for further information.

set_image_async(*args, **kwargs)

(Async) This function will set the horizontal and vertical binning to be used when taking a full resolution image.

Parameters:
  • hbin – number of pixels to bin horizontally.
  • vbin – number of pixels to bin vertically.
  • hstart – Start column (inclusive).
  • hend – End column (inclusive).
  • vstart – Start row (inclusive).
  • vend – End row (inclusive).
set_kinetic_cycle_time_async(*args, **kwargs)

(Async) This function will set the kinetic cycle time to the nearest valid value not less than the given value. The actual time used is obtained by GetAcquisitionTimings. . Please refer to SECTION 5 – ACQUISITION MODES for further information. float time: the kinetic cycle time in seconds.

set_n_accum_async(*args, **kwargs)

(Async) This function will set the number of scans accumulated in memory. This will only take effect if the acquisition mode is either Accumulate or Kinetic Series.

set_n_kinetics_async(*args, **kwargs)

(Async) This function will set the number of scans (possibly accumulated scans) to be taken during a single acquisition sequence. This will only take effect if the acquisition mode is Kinetic Series.

set_photon_counting_divs_async(*args, **kwargs)

(Async) This function sets the thresholds for the photon counting option.

set_photon_counting_thres_async(*args, **kwargs)

(Async) This function sets the minimum and maximum threshold in counts (1-65535) for the photon counting option.

set_vert_clock_async(*args, **kwargs)

(Async) If you choose a high readout speed (a low readout time), then you should also consider increasing the amplitude of the Vertical Clock Voltage. There are five levels of amplitude available for you to choose from: - Normal, +1, +2, +3, +4 Exercise caution when increasing the amplitude of the vertical clock voltage, since higher clocking voltages may result in increased clock-induced charge (noise) in your signal. In general, only the very highest vertical clocking speeds are likely to benefit from an increased vertical clock voltage amplitude.

setbool(strcommand, value)[source]

Set command with Bool value parameter.

setenumerated(strcommand, value)[source]

Set command with Enumerated value parameter.

setenumstring(strcommand, item)[source]

Set command with EnumeratedString value parameter.

setfloat(strcommand, value)[source]

Set command with Float value parameter.

setint(strcommand, value)[source]

SetInt function.

shutter_async(*args, **kwargs)

(Async) This function expands the control offered by SetShutter to allow an external shutter and internal shutter to be controlled independently (only available on some cameras – please consult your Camera User Guide). The typ parameter allows the user to control the TTL signal output to an external shutter. The opening and closing times specify the length of time required to open and close the shutter (this information is required for calculating acquisition timings – see SHUTTER TRANSFER TIME). The mode and extmode parameters control the behaviour of the internal and external shutters. To have an external shutter open and close automatically in an experiment, set the mode parameter to “Open” and set the extmode parameter to “Auto”. To have an internal shutter open and close automatically in an experiment, set the extmode parameter to “Open” and set the mode parameter to “Auto”. To not use any shutter in the experiment, set both shutter modes to permanently open.

Parameters:
  • typ – 0 (or 1) Output TTL low (or high) signal to open shutter.
  • mode – Internal shutter: 0 Fully Auto, 1 Permanently Open, 2 Permanently Closed, 4 Open for FVB series, 5 Open for any series.
  • ext_closing – Time shutter takes to close (milliseconds)
  • ext_opening – Time shutter takes to open (milliseconds)
  • ext_mode – External shutter: 0 Fully Auto, 1 Permanently Open, 2 Permanently Closed, 4 Open for FVB series, 5 Open for any series.
start_acquisition_async(*args, **kwargs)

(Async) This function starts an acquisition. The status of the acquisition can be monitored via GetStatus().

trigger_level_async(*args, **kwargs)

(Async) This function sets the trigger voltage which the system will use.

trigger_mode_available(modestr)[source]

This function checks if the hardware and current settings permit the use of the specified trigger mode.

true_exposure_times(n)[source]

This function will return the actual exposure times that the camera will use. There may be differences between requested exposures and the actual exposures. ntimes: Numbers of times requested.

true_horiz_shift_speed(index=0, typ=None, ad=0)[source]

As your Andor system is capable of operating at more than one horizontal shift speed this function will return the actual speeds available. The value returned is in MHz.

GetHSSpeed(int channel, int typ, int index, float* speed)

Parameters:
  • typ – output amplification. 0 electron multiplication/Conventional(clara) 1 conventional/Extended NIR Mode(clara).
  • index – speed required 0 to NumberSpeeds-1 where NumberSpeeds is value returned in first parameter after a call to GetNumberHSSpeeds().
  • ad – the AD channel.
true_preamp(index)[source]

For those systems that provide a number of pre amp gains to apply to the data as it is read out; this function retrieves the amount of gain that is stored for a particular index. The number of gains available can be obtained by calling the GetNumberPreAmpGains function and a specific Gain can be selected using the function SetPreAmpGain.

true_vert_amp(index)[source]

This Function is used to get the value of the Vertical Clock Amplitude found at the index passed in.

Parameters:index – Index of VS amplitude required Valid values 0 to GetNumberVSAmplitudes() - 1
true_vert_shift_speed(index=0)[source]

As your Andor SDK system may be capable of operating at more than one vertical shift speed this function will return the actual speeds available. The value returned is in microseconds.

vert_amp_index(string)[source]

This Function is used to get the index of the Vertical Clock Amplitude that corresponds to the string passed in.

Parameters:string – “Normal” , “+1” , “+2” , “+3” , “+4”
vert_amp_string(index)[source]

This Function is used to get the Vertical Clock Amplitude string that corresponds to the index passed in.

Parameters:index – Index of VS amplitude required Valid values 0 to GetNumberVSAmplitudes() - 1
wait_for_acquisition_async(*args, **kwargs)

(Async) WaitForAcquisition can be called after an acquisition is started using StartAcquisition to put the calling thread to sleep until an Acquisition Event occurs. This can be used as a simple alternative to the functionality provided by the SetDriverEvent function, as all Event creation and handling is performed internally by the SDK library. Like the SetDriverEvent functionality it will use less processor resources than continuously polling with the GetStatus function. If you wish to restart the calling thread without waiting for an Acquisition event, call the function CancelWait. An Acquisition Event occurs each time a new image is acquired during an Accumulation, Kinetic Series or Run-Till-Abort acquisition or at the end of a Single Scan Acquisition. If a second event occurs before the first one has been acknowledged, the first one will be ignored. Care should be taken in this case, as you may have to use CancelWait to exit the function.

waitbuffer(ptr, bufsize)[source]

Wait for next buffer ready.

EM_advanced_enabled
This function turns on and off access to higher EM gain levels
within the SDK. Typically, optimal signal to noise ratio and dynamic range is achieved between x1 to x300 EM Gain. Higher gains of > x300 are recommended for single photon counting only. Before using higher levels, you should ensure that light levels do not exceed the regime of tens of photons per pixel, otherwise accelerated ageing of the sensor can occur. This is set to False upon initialization of the camera.
Values:{False: 0, True: 1}
EM_advanced_enabled_changed
EM_gain

Allows the user to change the gain value. The valid range for the gain depends on what gain mode the camera is operating in. See SetEMGainMode to set the mode and GetEMGainRange to get the valid range to work with. To access higher gain values (>x300) see SetEMAdvanced.

EM_gain_changed
EM_gain_mode
Set the EM Gain mode to one of the following possible settings.
Mode 0: The EM Gain is controlled by DAC settings in the range 0-255. Default mode. 1: The EM Gain is controlled by DAC settings in the range 0-4095. 2: Linear mode. 3: Real EM gain
Values:{‘DAC4095’: 1, ‘Linear’: 2, ‘RealGain’: 3, ‘DAC255’: 0}
EM_gain_mode_changed
EM_gain_range

Returns the minimum and maximum values of the current selected EM Gain mode and temperature of the sensor.

EM_gain_range_changed
FK_exposure_time
This function will return the current “valid” exposure time for a
fast kinetics acquisition. This function should be used after all the acquisitions settings have been set, i.e. SetFastKinetics and SetFKVShiftSpeed. The value returned is the actual time used in subsequent acquisitions.
Units:s
FK_exposure_time_changed
LIBRARY_NAME = 'atmcd64d.dll'
LIBRARY_NAME_changed
QE_changed
abort_acquisition = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f4f77be0>>, None)
abort_acquisition_changed
acquired_data16_changed
acquired_data_changed
acquisition_mode
This function will set the acquisition mode to be used on the next
StartAcquisition. NOTE: In Mode 5 the system uses a “Run Till Abort” acquisition mode. In Mode 5 only, the camera continually acquires data until the AbortAcquisition function is called. By using the SetDriverEvent function you will be notified as each acquisition is completed.
Values:{‘Kinetics’: 3, ‘Run till abort’: 5, ‘Accumulate’: 2, ‘Fast Kinetics’: 4, ‘Single Scan’: 1}
acquisition_mode_changed
acquisition_progress

This function will return information on the progress of the current acquisition. It can be called at any time but is best used in conjunction with SetDriverEvent. The values returned show the number of completed scans in the current acquisition. If 0 is returned for both accum and series then either: - No acquisition is currently running - The acquisition has just completed - The very first scan of an acquisition has just started and not yet completed. GetStatus can be used to confirm if the first scan has just started, returning DRV_ACQUIRING, otherwise it will return DRV_IDLE. For example, if accum=2 and series=3 then the acquisition has completed 3 in the series and 2 accumulations in the 4 scan of the series

acquisition_progress_changed
acquisition_timings

This function will return the current “valid” acquisition timing information. This function should be used after all the acquisitions settings have been set, e.g. SetExposureTime, SetKineticCycleTime and SetReadMode etc. The values returned are the actual times used in subsequent acquisitions. This function is required as it is possible to set the exposure time to 20ms, accumulate cycle time to 30ms and then set the readout mode to full image. As it can take 250ms to read out an image it is not possible to have a cycle time of 30ms. All data is measured in seconds.

acquisition_timings_changed
adv_trigger_mode
This function will set the state for the iCam functionality that
some cameras are capable of. There may be some cases where we wish to prevent the software using the new functionality and just do it the way it was previously done.
Values:{False: 0, True: 1}
adv_trigger_mode_changed
amp_available_changed
amp_descr_changed
amp_max_hspeed_changed
available_images_index

This function will return information on the number of available images in the circular buffer. This information can be used with GetImages to retrieve a series of images. If any images are overwritten in the circular buffer they no longer can be retrieved and the information returned will treat overwritten images as not available.

available_images_index_changed
averaging_factor

Averaging factor to be used with the recursive filter. For information on the various data averaging filters available see DATA AVERAGING FILTERS in the Special Guides section of the manual.

averaging_factor_changed
averaging_frame_count

Number of frames to be used when using the frame averaging filter.

averaging_frame_count_changed
averaging_mode
Current averaging mode.
Valid options are: 0 – No Averaging Filter 5 – Recursive Averaging Filter 6 – Frame Averaging Filter
Values:{‘NAF’: 0, ‘FAF’: 6, ‘RAF’: 5}
averaging_mode_changed
baseline_clamp
This function returns the status of the baseline clamp
functionality. With this feature enabled the baseline level of each scan in a kinetic series will be more consistent across the sequence.
Values:{False: 0, True: 1}
baseline_clamp_changed
baseline_offset
This function allows the user to move the baseline level by the
amount selected. For example “+100” will add approximately 100 counts to the default baseline value. The value entered should be a multiple of 100 between -1000 and +1000 inclusively.
Limits:(-1000, 1100, 100)
baseline_offset_changed
bit_depth_changed
buffer_size

This function will return the maximum number of images the circular buffer can store based on the current acquisition settings.

buffer_size_changed
camera_handle_changed
cancel_wait = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f4f77d30>>, None)
cancel_wait_changed
capabilities

This function will fill in an AndorCapabilities structure with the capabilities associated with the connected camera. Individual capabilities are determined by examining certain bits and combinations of bits in the member variables of the AndorCapabilites structure.

capabilities_changed
command_changed
controller_card

This function will retrieve the type of PCI controller card included in your system. This function is not applicable for USB systems. The maximum number of characters that can be returned from this function is 10.

controller_card_changed
cooled_on_shutdown
This function determines whether the cooler is switched off when
the camera is shut down.
Values:{False: 0, True: 1}
cooled_on_shutdown_changed
cooler_on
Values:{False: 0, True: 1}
cooler_on_changed
count_convert_available_changed
count_convert_wavelength_range

This function returns the valid wavelength range available in Count Convert mode.

count_convert_wavelength_range_changed
cr_filter_enabled
This function will set the state of the cosmic ray filter mode for
future acquisitions. If the filter mode is on, consecutive scans in an accumulation will be compared and any cosmic ray-like features that are only present in one scan will be replaced with a scaled version of the corresponding pixel value in the correct scan.
Values:{False: 0, True: 2}
cr_filter_enabled_changed
current_camera

When multiple Andor cameras are installed this function allows the user to select which camera is currently active. Once a camera has been selected the other functions can be called as normal but they will only apply to the selected camera. If only 1 camera is installed calling this function is not required since that camera will be selected by default.

current_camera_changed
detector_shape
detector_shape_changed
exposing
This function will return if the system is exposing or not. The
status of the firepulse will be returned. NOTE This is only supported by the CCI23 card.
Values:{False: 0, True: 1}
exposing_changed
exposure_times_changed
fan_mode
Allows the user to control the mode of the camera fan. If the
system is cooled, the fan should only be turned off for short periods of time. During this time the body of the camera will warm up which could compromise cooling capabilities. If the camera body reaches too high a temperature, depends on camera, the buzzer will sound. If this happens, turn off the external power supply and allow the system to stabilize before continuing.
Values:{‘onfull’: 0, ‘off’: 2, ‘onlow’: 1}
fan_mode_changed

As your Andor SDK system may be capable of operating at more than one vertical shift speed this function will return the fastest recommended speed available. The very high readout speeds, may require an increase in the amplitude of the Vertical Clock Voltage using SetVSAmplitude. This function returns the fastest speed which does not require the Vertical Clock Voltage to be adjusted. The values returned are the vertical shift speed index and the actual speed in microseconds per pixel shift.

filter_threshold

Sets the threshold value for the Noise Filter. For information on the various spurious noise filters available see SPURIOUS NOISE FILTERS in the Special Guides section of the manual. Valid values are: 0 – 65535 for Level Above filte 0 – 10 for all other filters.

filter_threshold_changed
finalize_changed
flush_changed
frame_transfer_mode
This function will set whether an acquisition will readout in Frame
Transfer Mode. If the acquisition mode is Single Scan or Fast Kinetics this call will have no affect.
Values:{False: 0, True: 1}
frame_transfer_mode_changed
free_int_mem = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f5007160>>, None)
free_int_mem_changed
getbool_changed
getenumerated_changed
getfloat_changed
getint_changed
hardware_version
hardware_version_changed
has_mechanical_shutter
has_mechanical_shutter_changed
horiz_shift_speed

This function will set the speed at which the pixels are shifted into the output node during the readout phase of an acquisition. Typically your camera will be capable of operating at several horizontal shift speeds. To get the actual speed that an index corresponds to use the GetHSSpeed function.

Parameters:
  • typ – output amplification. 0 electron multiplication/Conventional(clara). 1 conventional/Extended NIR mode(clara).
  • index – the horizontal speed to be used 0 to GetNumberHSSpeeds() - 1
horiz_shift_speed_changed
idn

Identification of the device

idn_changed
images16_changed
images_changed
in_aux_port
Keys:[1, 2, 3, 4]
This function returns the state of the TTL Auxiliary Input Port on
the Andor plug-in card.
Values:{False: 0, True: True}
in_aux_port_changed
initialize_changed
is_implemented_changed
is_writable_changed
keep_clean_time
This function will return the time to perform a keep clean cycle.
This function should be used after all the acquisitions settings have been set, e.g. SetExposureTime, SetKineticCycleTime and SetReadMode etc. The value returned is the actual times used in subsequent acquisitions.
Units:s
keep_clean_time_changed
max_exposure
This function will return the maximum Exposure Time in seconds that
is settable by the SetExposureTime function.
Units:s
max_exposure_changed
max_images_per_dma

This function will return the maximum number of images that can be transferred during a single DMA transaction.

max_images_per_dma_changed
max_temperature
This function returns the valid range of temperatures in centigrads
to which the detector can be cooled.
Units:degC
max_temperature_changed
min_image_length

This function will return the minimum number of pixels that can be read out from the chip at each exposure. This minimum value arises due the way in which the chip is read out and will limit the possible sub image dimensions and binning sizes that can be applied.

min_image_length_changed
min_temperature
This function returns the valid range of temperatures in centigrads
to which the detector can be cooled.
Units:degC
min_temperature_changed
most_recent_image16_changed
most_recent_image_changed
n_ad_channels
n_ad_channels_changed
n_amps
n_amps_changed
n_exposures_in_ring

Gets the number of exposures in the ring at this moment.

n_exposures_in_ring_changed
n_horiz_shift_speeds_changed
n_images_acquired

This function will return the total number of images acquired since the current acquisition started. If the camera is idle the value returned is the number of images acquired during the last acquisition.

n_images_acquired_changed
n_max_nexposure

This function will return the maximum number of exposures that can be configured in the SetRingExposureTimes SDK function.

n_max_nexposure_changed
n_photon_counting_div

Available in some systems is photon counting mode. This function gets the number of photon counting divisions available. The functions SetPhotonCounting and SetPhotonCountingThreshold can be used to specify which of these divisions is to be used.

n_photon_counting_div_changed
n_preamps

Available in some systems are a number of pre amp gains that can be applied to the data as it is read out. This function gets the number of these pre amp gains available. The functions GetPreAmpGain and SetPreAmpGain can be used to specify which of these gains is to be used.

n_preamps_changed
n_vert_clock_amps

This function will normally return the number of vertical clock voltage amplitudes that the camera has.

n_vert_clock_amps_changed
n_vert_shift_speeds

As your Andor system may be capable of operating at more than one vertical shift speed this function will return the actual number of speeds available.

n_vert_shift_speeds_changed
ncameras

This function returns the total number of Andor cameras currently installed. It is possible to call this function before any of the cameras are initialized.

ncameras_changed
new_images_index

This function will return information on the number of new images (i.e. images which have not yet been retrieved) in the circular buffer. This information can be used with GetImages to retrieve a series of the latest images. If any images are overwritten in the circular buffer they can no longer be retrieved and the information returned will treat overwritten images as having been retrieved.

new_images_index_changed
noise_filter_mode
Set the Noise Filter to use; For information on the various
spurious noise filters available see SPURIOUS NOISE FILTERS in the Special Guides section of the manual. Valid options are: 0 – No Averaging Filter 1 – Median Filter 2 – Level Above Filter 3 – Interquartile Range Filter 4 – Noise Threshold Filter
Values:{‘MF’: 1, ‘LAF’: 2, ‘NTF’: 4, ‘IRF’: 3, ‘NF’: 0}
noise_filter_mode_changed
oldest_image16_changed
oldest_image_changed
out_aux_port
Keys:[1, 2, 3, 4]
This function sets the TTL Auxiliary Output port (P) on the Andor
plug-in card to either ON/HIGH or OFF/LOW.
Values:{False: 0, True: 1}
out_aux_port_changed
photon_counting_mode

This function activates the photon counting option.

Values:{False: 0, True: 1}
photon_counting_mode_changed
preamp

This function will set the pre amp gain to be used for subsequent acquisitions. The actual gain factor that will be applied can be found through a call to the GetPreAmpGain function. The number of Pre Amp Gains available is found by calling the GetNumberPreAmpGains function.

preamp_available_changed
preamp_changed
preamp_descr_changed
prepare_acquisition = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f4f77a20>>, None)
prepare_acquisition_changed
px_size

This function returns the dimension of the pixels in the detector in microns.

px_size_changed
queuebuffer_changed
readout_flipped_changed
readout_mode
This function will set the readout mode to be used on the subsequent
acquisitions.
Values:{‘Random-Track’: 2, ‘Image’: 4, ‘Single-Track’: 3, ‘Multi-Track’: 1, ‘FVB’: 0}
readout_mode_changed
readout_packing
This function will configure whether data is packed into the readout
register to improve frame rates for sub-images. Note: It is important to ensure that no light falls outside of the sub-image area otherwise the acquired data will be corrupted. Only currently available on iXon+ and iXon3.
Values:{False: 0, True: 1}
readout_packing_changed
readout_time
This function will return the time to readout data from a sensor.
This function should be used after all the acquisitions settings have been set, e.g. SetExposureTime, SetKineticCycleTime and SetReadMode etc. The value returned is the actual times used in subsequent acquisitions.
Units:s
readout_time_changed
save_raw = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f50077f0>>, None)
save_raw_changed
send_software_trigger = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f5021ef0>>, None)
send_software_trigger_changed
sensitivity_changed
set_accum_time = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f5007b00>>, None)
set_accum_time_changed
set_dma_parameters_changed
set_exposure_time = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f5007a90>>, None)
set_exposure_time_changed
set_image = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f4f7f9b0>>, None)
set_image_changed
set_kinetic_cycle_time = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f5007c88>>, None)
set_kinetic_cycle_time_changed
set_n_accum = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f5007dd8>>, None)
set_n_accum_changed
set_n_kinetics = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f5007d30>>, None)
set_n_kinetics_changed
set_photon_counting_divs = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f4f773c8>>, None)
set_photon_counting_divs_changed
set_photon_counting_thres = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f4f77438>>, None)
set_photon_counting_thres_changed
set_vert_clock = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f50210b8>>, None)
set_vert_clock_changed
setbool_changed
setenumerated_changed
setenumstring_changed
setfloat_changed
setint_changed
shutter = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f51ad7b8>>, None)
shutter_changed
shutter_min_times

This function will return the minimum opening and closing times in milliseconds for the shutter on the current camera.

shutter_min_times_changed
software_version
software_version_changed
start_acquisition = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f4f77a90>>, None)
start_acquisition_changed
status

This function will return the current status of the Andor SDK system. This function should be called before an acquisition is started to ensure that it is IDLE and during an acquisition to monitor the process.

status_changed
temperature
This function returns the temperature of the detector to the
nearest degree. It also gives the status of cooling process.
Units:degC
temperature_changed
temperature_setpoint
Units:degC
temperature_setpoint_changed
temperature_status

This function returns the temperature of the detector to the nearest degree. It also gives the status of cooling process.

temperature_status_changed
trigger_level = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f5021f60>>, None)
trigger_level_changed
trigger_mode
This function will set the trigger mode that the camera will
operate in.
Values:{‘External Start’: 6, ‘Software Trigger’: 10, ‘External’: 1, ‘External Charge Shifting’: 12, ‘Internal’: 0, ‘External Exposure’: 7, ‘External FVB EM’: 9}
trigger_mode_available_changed
trigger_mode_changed
true_exposure_times_changed
true_horiz_shift_speed_changed
true_preamp_changed
true_vert_amp_changed
true_vert_shift_speed_changed
vert_amp_index_changed
vert_amp_string_changed
vert_shift_speed

This function will set the vertical speed to be used for subsequent acquisitions.

vert_shift_speed_changed
wait_for_acquisition = functools.partial(<bound method Action.call of <lantz.action.Action object at 0x7fe1f4f77c88>>, None)
wait_for_acquisition_changed
waitbuffer_changed