1

pylablib/Andor/Shamrock.py

@@ -0,0 +1,560 @@
+from .base import AndorError, AndorNotSupportedError
+from .ShamrockCIF_lib import wlib as lib, ShamrockLibError, SHAMROCK_ERR, SHAMROCK_CONST
+from .AndorSDK2 import _camsel_lock
+
+from ...core.devio import interface
+from ...core.utils import py3
+from ..utils import load_lib
+
+import numpy as np
+import collections
+import functools
+
+
+_detector_ini_path=""
+class LibraryController(load_lib.LibraryController):
+    def _do_init(self):
+        self.lib.ShamrockInitialize(_detector_ini_path)
+    def _do_uninit(self):
+        try:
+            self.lib.ShamrockClose()
+        except ShamrockLibError as e:
+            if e.code!=SHAMROCK_ERR.SHAMROCK_NOT_INITIALIZED:
+                raise
+libctl=LibraryController(lib)
+def restart_lib():
+    libctl.shutdown()
+
+def list_spectrographs():
+    """Return list of serial numbers of all connected Shamrock spectrographs"""
+    with libctl.temp_open():
+        spec_num=lib.ShamrockGetNumberDevices()
+        return [py3.as_str(lib.ShamrockGetSerialNumber(i)) for i in range(spec_num)]
+def get_spectrographs_number():
+    """Get number of connected Shamrock spectrographs"""
+    return len(list_spectrographs())
+
+
+TDeviceInfo=collections.namedtuple("TDeviceInfo",["serial_number"])
+TOpticalParameters=collections.namedtuple("TOpticalParameters",["focal_length","angular_deviation","focal_tilt"])
+TGratingInfo=collections.namedtuple("TGratingInfo",["lines","blaze_wavelength","home","offset"])
+
+def _specfunc(func):
+    @functools.wraps(func)
+    def wrapped(self, *args, **kwargs):
+        if getattr(self,"_sync_with_SDK2",False):
+            with _camsel_lock:
+                return func(self,*args,**kwargs)
+        return func(self,*args,**kwargs)
+    return wrapped
+class ShamrockSpectrograph(interface.IDevice):
+    """
+    Shamrock spectrograph.
+
+    Args:
+        idx(int): spectrograph index (starting from 0; use :func:`list_spectrographs` to get the list of all connected spectrographs)
+    """
+    Error=AndorError
+    def __init__(self, idx=0):
+        super().__init__()
+        self.idx=idx
+        self._opid=None
+        self.open()
+        
+        self._sync_with_SDK2=False
+        self._add_info_variable("device_info",self.get_device_info)
+        self._add_info_variable("optical_parameters",self.get_optical_parameters)
+        self._add_info_variable("gratings_number",self.get_gratings_number)
+        self._add_status_variable("grating_infos",lambda: [self.get_grating_info(g) for g in range(1,self.get_gratings_number()+1)])
+        self._add_settings_variable("grating",self.get_grating,self.set_grating)
+        self._add_settings_variable("grating_offsets",self._get_all_grating_offsets,self._set_all_grating_offsets)
+        self._add_settings_variable("detector_offset",self.get_detector_offset,self.set_detector_offset)
+        self._add_info_variable("wavelength_present",self.is_wavelength_control_present)
+        self._add_info_variable("wavelength_limits",lambda: [self.get_wavelength_limits(g) for g in range(1,self.get_gratings_number()+1)],ignore_error=(AndorError,))
+        self._add_settings_variable("wavelength",self.get_wavelength,self.set_wavelength,ignore_error=(AndorError,))
+        self._add_status_variable("zero_order",self.is_at_zero_order,ignore_error=(AndorError,))
+        self._add_info_variable("slits_present",lambda: [self.is_slit_present(s) for s in range(1,5)])
+        self._add_settings_variable("slit_widths",self._get_all_slit_widths,self._set_all_slit_widths)
+        self._add_info_variable("irises_present",lambda: [self.is_iris_present(s) for s in range(2)])
+        self._add_settings_variable("iris_widths",self._get_all_iris_widths,self._set_all_iris_widths)
+        self._add_settings_variable("focus_mirror_present",self.is_focus_mirror_present)
+        self._add_settings_variable("focus_mirror",self.get_focus_mirror_position,self.set_focus_mirror_position,ignore_error=(AndorError,))
+        self._add_info_variable("focus_mirror_max",self.get_focus_mirror_position_max,ignore_error=(AndorError,))
+        self._add_info_variable("shutter_present",self.is_shutter_present)
+        self._add_settings_variable("shutter_mode",self.get_shutter,self.set_shutter,ignore_error=(AndorError,))
+        self._add_info_variable("filter_present",self.is_filter_present)
+        self._add_settings_variable("filter",self.get_filter,self.set_filter,ignore_error=(AndorError,))
+        self._add_info_variable("flippers_present",lambda: [self.is_flipper_present(s) for s in range(1,3)])
+        self._add_settings_variable("flipper_ports",self._get_all_flipper_ports,self._set_all_flipper_ports)
+        self._add_info_variable("accessory_present",self.is_accessory_present)
+        self._add_settings_variable("accessory_states",self._get_all_accessory_states,self._set_all_accessory_states)
+        self._add_settings_variable("pixel_width",self.get_pixel_width,self.set_pixel_width)
+        self._add_settings_variable("number_pixels",self.get_number_pixels,self.set_number_pixels)
+        self._add_status_variable("calibration",self.get_calibration)
+
+    def open(self):
+        if self._opid:
+            return
+        with libctl.temp_open():
+            ncams=get_spectrographs_number()
+            if self.idx>=ncams:
+                raise AndorError("spectrograph index {} is not available ({} spectrograph exist)".format(self.idx,ncams))
+            self._opid=libctl.open().opid
+    def close(self):
+        if self._opid is None:
+            return
+        libctl.close(self._opid)
+        self._opid=None
+    def is_opened(self):
+        return self._opid is not None
+    def _get_connection_parameters(self):
+        return (self.idx,)
+
+    @_specfunc
+    def get_device_info(self):
+        """
+        Get spectrograph device info.
+
+        Return tuple ``(serial_number)``.
+        """
+        serial_number=py3.as_str(lib.ShamrockGetSerialNumber(self.idx))
+        return TDeviceInfo(serial_number)
+    @_specfunc
+    def get_optical_parameters(self):
+        """
+        Get device optical parameters.
+
+        Return tuple ``(focal_length, angular_deviation, focal_tilt)``.
+        """
+        params=lib.ShamrockEepromGetOpticalParams(self.idx)
+        return TOpticalParameters(*params)
+        
+    
+    ### Grating control ###
+    @_specfunc
+    def get_gratings_number(self):
+        """Get number of gratings"""
+        return lib.ShamrockGetNumberGratings(self.idx)
+    def _check_grating(self, grating):
+        if grating is None:
+            return self.get_grating()
+        if grating<1 or grating>self.get_gratings_number():
+            raise ValueError("incorrect grating index: {}; should be between 1 and {}".format(grating,self.get_gratings_number()))
+        return grating
+    @_specfunc
+    def get_grating(self):
+        """Get current grating index (counting from 1)"""
+        return lib.ShamrockGetGrating(self.idx)
+    @_specfunc
+    def set_grating(self, grating, force=False):
+        """
+        Set current grating (counting from 1)
+        
+        Call blocks until the grating is exchanged (up to 10-20 seconds).
+        If ``force==False`` and the current grating index is the same as requested, skip the call;
+        otherwise, call the grating set command regardless (takes about a second in the grating is unchanged).
+        """
+        grating=self._check_grating(grating)
+        if force or self.get_grating()!=grating:
+            lib.ShamrockSetGrating(self.idx,grating)
+        return self.get_grating()
+    @_specfunc
+    def get_grating_info(self, grating=None):
+        """
+        Get info of a given grating (by default, current grating).
+
+        Return tuple ``(lines, blaze_wavelength, home, offset)`` (blazing wavelength is in nm).
+        """
+        grating=self._check_grating(grating)
+        lines,blaze_wavelength,home,offset=lib.ShamrockGetGratingInfo(self.idx,grating)
+        return TGratingInfo(lines,py3.as_str(blaze_wavelength),home,offset)
+    @_specfunc
+    def get_grating_offset(self, grating=None):
+        """Get grating offset (in steps) for a given grating (by default, current grating)"""
+        grating=self._check_grating(grating)
+        return lib.ShamrockGetGratingOffset(self.idx,grating)
+    @_specfunc
+    def set_grating_offset(self, offset, grating=None):
+        """Set grating offset (in steps) for a given grating (by default, current grating)"""
+        grating=self._check_grating(grating)
+        lib.ShamrockSetGratingOffset(self.idx,grating,offset)
+        return self.get_grating_offset(grating)
+    def _get_all_grating_offsets(self):
+        return [self.get_grating_offset(g) for g in range(1,self.get_gratings_number()+1)]
+    def _set_all_grating_offsets(self, offsets):
+        for g,o in enumerate(offsets,start=1):
+            if o is not None:
+                self.set_grating_offset(g,o)
+    @_specfunc
+    def get_detector_offset(self):
+        """Get detector offset (in steps)"""
+        return lib.ShamrockGetDetectorOffset(self.idx)
+    @_specfunc
+    def set_detector_offset(self, offset):
+        """Set detector offset (in steps)"""
+        lib.ShamrockSetDetectorOffset(self.idx,offset)
+        return self.get_detector_offset()
+    @_specfunc
+    def get_turret(self):
+        """Get turret"""
+        return lib.ShamrockGetTurret(self.idx)
+    @_specfunc
+    def set_turret(self, turret):
+        """Set turret"""
+        lib.ShamrockSetTurret(self.idx,turret)
+        return self.get_turret()
+        
+    
+    ### Wavelength control ###
+    @_specfunc
+    def is_wavelength_control_present(self):
+        """Check if wavelength control is present"""
+        return bool(lib.ShamrockWavelengthIsPresent(self.idx))
+    def _check_wavelength(self):
+        if not self.is_wavelength_control_present():
+            raise AndorNotSupportedError("wavelength control is not present")
+    @_specfunc
+    def get_wavelength(self):
+        """Get current central wavelength (in m)"""
+        self._check_wavelength()
+        return lib.ShamrockGetWavelength(self.idx)*1E-9
+    @_specfunc
+    def set_wavelength(self, wavelength):
+        """Get current central wavelength (in m)"""
+        self._check_wavelength()
+        lib.ShamrockSetWavelength(self.idx,wavelength/1E-9)
+        return self.get_wavelength()
+    @_specfunc
+    def get_wavelength_limits(self, grating=None):
+        """Get wavelength limits (in m) for a given grating (by default, current grating)"""
+        self._check_wavelength()
+        grating=self._check_grating(grating)
+        lim=lib.ShamrockGetWavelengthLimits(self.idx,grating)
+        return lim[0]*1E-9,lim[1]*1E-9
+    @_specfunc
+    def reset_wavelength(self):
+        """Reset current wavelength to 0 nm"""
+        self._check_wavelength()
+        lib.ShamrockWavelengthReset(self.idx)
+        return self.get_wavelength()
+    @_specfunc
+    def is_at_zero_order(self):
+        """Check if current grating is at zero order"""
+        self._check_wavelength()
+        return bool(lib.ShamrockAtZeroOrder(self.idx))
+    @_specfunc
+    def goto_zero_order(self):
+        """Set current grating to zero order"""
+        self._check_wavelength()
+        lib.ShamrockGotoZeroOrder(self.idx)
+        return self.is_at_zero_order()
+        
+
+    ### Slit control ###
+    _p_slit_index=interface.EnumParameterClass("slit_index",
+        {"input_side":SHAMROCK_CONST.SHAMROCK_INPUT_SLIT_SIDE,"input_direct":SHAMROCK_CONST.SHAMROCK_INPUT_SLIT_DIRECT,
+        "output_side":SHAMROCK_CONST.SHAMROCK_OUTPUT_SLIT_SIDE,"output_direct":SHAMROCK_CONST.SHAMROCK_OUTPUT_SLIT_DIRECT})
+    @interface.use_parameters(slit="slit_index")
+    @_specfunc
+    def is_slit_present(self, slit):
+        """
+        Check if the slit is present.
+
+        `slit` cen be either a slit index (starting from 1), or one of the following: ``"input_side"``, ``"input_direct"``, ``"output_side"``, or ``"output_direct"``.
+        """
+        return bool(lib.ShamrockAutoSlitIsPresent(self.idx,slit))
+    def _check_slit(self, slit):
+        if not self.is_slit_present(slit):
+            raise AndorNotSupportedError("slit '{}' is not present".format(self._p_slit_index.i(slit)))
+    @interface.use_parameters(slit="slit_index")
+    @_specfunc
+    def get_slit_width(self, slit):
+        """
+        Get slit width (in m).
+
+        `slit` cen be either a slit index (starting from 1), or one of the following: ``"input_side"``, ``"input_direct"``, ``"output_side"``, or ``"output_direct"``.
+        """
+        self._check_slit(slit)
+        return lib.ShamrockGetAutoSlitWidth(self.idx,slit)*1E-6
+    @interface.use_parameters(slit="slit_index")
+    @_specfunc
+    def set_slit_width(self, slit, width):
+        """
+        Set slit width (in m).
+
+        `slit` cen be either a slit index (starting from 1), or one of the following: ``"input_side"``, ``"input_direct"``, ``"output_side"``, or ``"output_direct"``.
+        """
+        self._check_slit(slit)
+        lib.ShamrockSetAutoSlitWidth(self.idx,slit,width/1E-6)
+        return self._wip.get_slit_width(slit)
+    def _get_all_slit_widths(self):
+        return [self.get_slit_width(s) if self.is_slit_present(s) else None for s in range(1,5)]
+    def _set_all_slit_widths(self, widths):
+        for s,w in enumerate(widths,start=1):
+            if w is not None:
+                self.set_slit_width(s,w)
+    @interface.use_parameters(slit="slit_index")
+    @_specfunc
+    def reset_slit(self, slit):
+        """
+        Reset slit to the default width (10 um).
+
+        `slit` cen be either a slit index (starting from 1), or one of the following: ``"input_side"``, ``"input_direct"``, ``"output_side"``, or ``"output_direct"``.
+        """
+        self._check_slit(slit)
+        lib.ShamrockAutoSlitReset(self.idx,slit)
+        return self._wip.get_slit_width(slit)
+        
+
+    ### Shutter control ###
+    @_specfunc
+    def is_shutter_present(self):
+        """Check if the shutter is present"""
+        return bool(lib.ShamrockShutterIsPresent(self.idx))
+    def _check_shutter(self):
+        if not self.is_shutter_present():
+            raise AndorNotSupportedError("shutter is not present")
+    _p_shutter_mode=interface.EnumParameterClass("shutter_mode",{"closed":0,"opened":1,"bnc":2,"not_set":-1})
+    @interface.use_parameters(_returns="shutter_mode")
+    @_specfunc
+    def get_shutter(self):
+        """
+        Get shutter mode.
+
+        Can return ``"closed"``, ``"opened"``, ``"bnc"``, or ``"not_set"``.
+        """
+        self._check_shutter()
+        return lib.ShamrockGetShutter(self.idx)
+    @interface.use_parameters(mode="shutter_mode")
+    @_specfunc
+    def is_shutter_mode_possible(self, mode):
+        """Check if the shutter mode (``"closed"``, ``"opened"``, or ``"bnc"``) is supported"""
+        self._check_shutter()
+        return mode>=0 and lib.ShamrockIsModePossible(self.idx,mode)
+    @interface.use_parameters(mode="shutter_mode")
+    @_specfunc
+    def set_shutter(self, mode):
+        """Set shutter mode (``"closed"`` or ``"opened"``)"""
+        self._check_shutter()
+        if not self._wip.is_shutter_mode_possible(mode):
+            raise AndorNotSupportedError("shutter mode '{}' is not supported".format(self._p_shutter_mode.i(mode)))
+        if mode!=-1:
+            lib.ShamrockSetShutter(self.idx,mode)
+        return self.get_shutter()
+        
+
+    ### Filter control ###
+    @_specfunc
+    def is_filter_present(self):
+        """Check if the filter is present"""
+        return bool(lib.ShamrockFilterIsPresent(self.idx))
+    def _check_filter(self):
+        if not self.is_filter_present():
+            raise AndorNotSupportedError("filter is not present")
+    @_specfunc
+    def get_filter(self):
+        """Get current filter"""
+        self._check_filter()
+        return lib.ShamrockGetFilter(self.idx)
+    @_specfunc
+    def set_filter(self, flt):
+        """Set current filter"""
+        self._check_filter()
+        lib.ShamrockSetFilter(self.idx,flt)
+        return self.get_filter()
+    @_specfunc
+    def get_filter_info(self, flt):
+        """Get info of the given filter"""
+        self._check_filter()
+        return lib.ShamrockGetFilterInfo(self.idx,flt)
+    @_specfunc
+    def reset_filter(self):
+        """Reset filter to default position"""
+        self._check_filter()
+        lib.ShamrockFilterReset(self.idx)
+        return self.get_filter()
+        
+
+    ### Flipper control ###
+    _p_flipper_index=interface.EnumParameterClass("flipper_index",{"input":1,"output":2})
+    @interface.use_parameters(flipper="flipper_index")
+    @_specfunc
+    def is_flipper_present(self, flipper):
+        """
+        Check if the flipper is present.
+
+        `flipper` can be a flipper index (starting from 1), ``"input"``, or `"output"``.
+        """
+        return bool(lib.ShamrockFlipperMirrorIsPresent(self.idx,flipper))
+    def _check_flipper(self, flipper):
+        if not self.is_flipper_present(flipper):
+            raise AndorNotSupportedError("flipper {} is not present".format(flipper))
+    _p_flipper_port=interface.EnumParameterClass("flipper_port",{"direct":0,"side":1})
+    @interface.use_parameters(flipper="flipper_index",_returns="flipper_port")
+    @_specfunc
+    def get_flipper_port(self, flipper):
+        """
+        Get flipper port.
+
+        `flipper` can be a flipper index (starting from 1), ``"input"``, or `"output"``.
+        Return either ``"direct"`` or ``"side"``.
+        """
+        self._check_flipper(flipper)
+        return lib.ShamrockGetFlipperMirror(self.idx,flipper)
+    @interface.use_parameters(flipper="flipper_index",port="flipper_port")
+    @_specfunc
+    def set_flipper_port(self, flipper, port):
+        """
+        Set flipper port.
+
+        `flipper` can be a flipper index (starting from 1), ``"input"``, or `"output"``.
+        Port can be ``"direct"`` or ``"side"``.
+        """
+        self._check_flipper(flipper)
+        lib.ShamrockSetFlipperMirror(self.idx,flipper,port)
+        return self._wip.get_flipper_port(flipper)
+    def _get_all_flipper_ports(self):
+        return [self.get_flipper_port(f) if self.is_flipper_present(f) else None for f in range(1,3)]
+    def _set_all_flipper_ports(self, ports):
+        for f,p in enumerate(ports,start=1):
+            if p is not None:
+                self.set_flipper_port(f,p)
+    @interface.use_parameters(flipper="flipper_index")
+    @_specfunc
+    def reset_flipper(self, flipper):
+        """
+        Reset flipper to the default state.
+
+        `flipper` can be a flipper index (starting from 1), ``"input"``, or `"output"``.
+        """
+        self._check_flipper(flipper)
+        lib.ShamrockFlipperMirrorReset(self.idx,flipper)
+        return self._wip.get_flipper_port(flipper)
+        
+
+    ### Iris control ###
+    _p_iris_port=interface.EnumParameterClass("iris_port",{"direct":0,"side":1})
+    @interface.use_parameters(iris="iris_port")
+    @_specfunc
+    def is_iris_present(self, iris):
+        """Check if the iris is present"""
+        return bool(lib.ShamrockIrisIsPresent is not None and lib.ShamrockIrisIsPresent(self.idx,iris))
+    def _check_iris(self, iris):
+        if lib.ShamrockIrisIsPresent is None or not lib.ShamrockIrisIsPresent(self.idx,iris):
+            raise AndorNotSupportedError("iris is not present")
+    @interface.use_parameters(iris="iris_port")
+    @_specfunc
+    def get_iris_width(self, iris):
+        """Get current iris width (0 to 100)"""
+        self._check_iris(iris)
+        return lib.ShamrockGetIris(self.idx,iris)
+    @interface.use_parameters(iris="iris_port")
+    @_specfunc
+    def set_iris_width(self, iris, width):
+        """Set current iris width (0 to 100)"""
+        self._check_iris(iris)
+        lib.ShamrockSetIris(self.idx,iris,int(width))
+        return lib.ShamrockGetIris(self.idx,iris)
+    def _get_all_iris_widths(self):
+        return [self.get_iris_width(s) if self.is_iris_present(s) else None for s in range(2)]
+    def _set_all_iris_widths(self, widths):
+        for s,w in enumerate(widths):
+            if w is not None:
+                self.set_iris_width(s,w)
+        
+
+    ### Focus mirror control ###
+    @_specfunc
+    def is_focus_mirror_present(self):
+        """Check if the focus mirror is present"""
+        return bool(lib.ShamrockFocusMirrorIsPresent is not None and lib.ShamrockFocusMirrorIsPresent(self.idx))
+    def _check_focus_mirror(self):
+        if lib.ShamrockFocusMirrorIsPresent is None or not lib.ShamrockFocusMirrorIsPresent(self.idx):
+            raise AndorNotSupportedError("focus mirror is not present")
+    @_specfunc
+    def get_focus_mirror_position(self):
+        """Get current focus mirror position"""
+        self._check_focus_mirror()
+        return lib.ShamrockGetFocusMirror(self.idx)
+    @_specfunc
+    def set_focus_mirror_position(self, position):
+        """Set current focus mirror position"""
+        self._check_focus_mirror()
+        lib.ShamrockSetFocusMirror(self.idx,int(position))
+        return lib.ShamrockGetFocusMirror(self.idx)
+    @_specfunc
+    def get_focus_mirror_position_max(self):
+        """Get maximal focus mirror position"""
+        self._check_focus_mirror()
+        return lib.ShamrockGetFocusMirrorMaxSteps(self.idx)
+    @_specfunc
+    def reset_focus_mirror(self):
+        """Reset focus mirror position"""
+        self._check_focus_mirror()
+        return lib.ShamrockFocusMirrorReset(self.idx)
+        
+
+    ### Accessory control ###
+    @_specfunc
+    def is_accessory_present(self):
+        """Check if the accessory is present"""
+        return bool(lib.ShamrockAccessoryIsPresent(self.idx))
+    def _check_accessory(self):
+        if not self.is_accessory_present():
+            raise AndorNotSupportedError("accessory is not present")
+    @_specfunc
+    def get_accessory_state(self, line):
+        """Get current accessory state on a given line (1 or 2)"""
+        self._check_accessory()
+        return lib.ShamrockGetAccessoryState(self.idx,line)
+    @_specfunc
+    def set_accessory_state(self, line, state):
+        """Set current accessory state (0 or 1) on a given line (1 or 2)"""
+        self._check_accessory()
+        lib.ShamrockSetAccessory(self.idx,line,state)
+        return self.get_accessory_state(line)
+    def _get_all_accessory_states(self):
+        return [self.get_accessory_state(l) if self.is_accessory_present() else None for l in range(1,3)]
+    def _set_all_accessory_states(self, states):
+        for l,s in enumerate(states,start=1):
+            if s is not None:
+                self.set_accessory_state(l,s)
+
+
+    ### Calibration ###
+    @_specfunc
+    def get_pixel_width(self):
+        """Get current set detector pixel width (in m)"""
+        return lib.ShamrockGetPixelWidth(self.idx)*1E-6
+    @_specfunc
+    def set_pixel_width(self, width):
+        """Set current detector pixel width (in m)"""
+        lib.ShamrockSetPixelWidth(self.idx,width/1E-6)
+        return self.get_pixel_width()
+    @_specfunc
+    def get_number_pixels(self):
+        """Get current set detector number of pixels"""
+        return lib.ShamrockGetNumberPixels(self.idx)
+    @_specfunc
+    def set_number_pixels(self, number):
+        """Set current detector number of pixels"""
+        lib.ShamrockSetNumberPixels(self.idx,number)
+        return self.get_number_pixels()
+    def setup_pixels_from_camera(self, cam):
+        """Setup detector parameters (number of pixels, pixel width) from the camera"""
+        pixel_size=cam.get_pixel_size()
+        det_size=cam.get_detector_size()
+        self.set_pixel_width(pixel_size[0])
+        self.set_number_pixels(det_size[0])
+        return self.get_pixel_width(),self.get_number_pixels()
+    @_specfunc
+    def get_calibration(self):
+        """
+        Get wavelength calibration.
+
+        Return numpy array which specifies wavelength (in m) corresponding to each pixel.
+        Prior to calling this method, the total number of pixels and the pixel width of the sensor should be set up using the corresponding methods
+        (:meth:`set_number_pixels` and :meth:`set_pixel_width`, or :meth:`setup_pixels_from_camera` to set both parameters using and AndorSDK2 camera instance)
+        """
+        npx=self.get_number_pixels()
+        return np.array(lib.ShamrockGetCalibration(self.idx,self.get_number_pixels()))*1E-9 if npx else np.zeros(0)