PDMS.py

 
 
import numpy as np
import shesha.constants as scons
from . import config_setter_utils as csu
 
 
 
class Param_dm:
 
    def __init__(self):
 
        # DM properties
        self.__nact__nact = 0  # linear number of actuators across the pupil diameter
        self.__alt__alt = 0.0  # DM conjugation altitude
        self.__thresh__thresh = 0.0  # Threshold on response for selection
        self.__keep_all_actu__keep_all_actu = False  # if True, don't mask actu by pupil
        self.__coupling__coupling = 0.2  # Actuator coupling (< .3)
        self.__gain__gain = 1.0  # Actuator gains
        self.__pupoffset__pupoffset = np.array([0, 0])
        self.__dim_screen__dim_screen = 0  # Phase screen dimension
        # Global offset in pupil (x,y) of the whole actuator pattern
 
        self.__unitpervolt__unitpervolt = 0.01
        # Influence function sensitivity in unit/volt. Optional [0.01]
        # Stackarray: mic/volt, Tip-tilt: arcsec/volt.
        self.__push4imat__push4imat = 1.  # nominal voltage for imat
 
        # Margins for actuator selection
        self.__margin_out__margin_out = None  # outer margin (pitches) from pupil diameter
        # inner margin (pitches) from central obstruction
        self.__margin_in__margin_in = 0.
        self.__pzt_extent__pzt_extent = 5.  # Extent of pzt DM (pitches)
        self.__segmented_mirror__segmented_mirror = False  # Crop influence functions where spiders are.
 
        # KL DM
        self.__nfunc__nfunc = 0
        self.__nkl__nkl = 0  # Number of KL for KL dm
        self.__outscl__outscl = None  # Outer scale in units of telescope diam for Karman KL
        self.__nr__nr = None  # number of radial points
        self.__npp__npp = None  # number of elements
        self.__ord__ord = None  # the radial orders of the basis
        self.__rabas__rabas = None  # the radial array of the basis
        self.__azbas__azbas = None  # the azimuthal array of the basis
        self.__ncp__ncp = None  # dim of grid
        self.__cr__cr = None  # radial coord in cartesien grid
        self.__cp__cp = None  # phi coord in cartesien grid
        self.__ap__ap = None
        self.__nfunc__nfunc = 0
 
        # Hidden variable safe-typed in shesha_constants
        self.__type__type = None  # Private storage of type
        self.__type_pattern__type_pattern = None  # Private storage of type_pattern
        self.__influ_type__influ_type = scons.InfluType.DEFAULT  # Private storage of influ_type
        self.__type_kl__type_kl = scons.KLType.KOLMO  # Private storage for KL type
 
        # HDF5 storage management
        self.__file_influ_fits__file_influ_fits = None  # Filename for influ hdf5 file
        self.__center_name__center_name = None  # Center name in hdf5
        self.__cube_name__cube_name = None  # Influence function cube name in hdf5
        self.__x_name__x_name = None  # x coord name in hdf5
        self.__y_name__y_name = None  # y coord name in hdf5
        self.__influ_res__influ_res = None  # influence resolution name in hdf5
        self.__diam_dm__diam_dm = None  # diam of the tel pupil projected on the dm plane
        self.__diam_dm_proj__diam_dm_proj = None  # diam of the dm pupil projected on the tel pupil plane
 
        # PXD cleanup
        # internal kwrd
        self.__pitch__pitch = None
        """ inter-actuator space in pixels"""
        self.__ntotact__ntotact = None
        """ total number of actuators over the full area of the pupil"""
        self.__influsize__influsize = None
        """ influ function support size"""
        self.__n1__n1 = None
        """ position of leftmost pixel in largest support"""
        self.__n2__n2 = None
        """ position of rightmost pixel in largest support"""
        self.__puppixoffset__puppixoffset = None
        self.__influ__influ = None
        """ influence functions"""
        self.__xpos__xpos = None
        """ x positions of influ functions"""
        self.__ypos__ypos = None
        """ y positions of influ functions"""
        self.__i1__i1 = None
        self.__j1__j1 = None
        self.__influpos__influpos = None
        self.__ninflu__ninflu = None
        """ Influence functions"""
        self.__influstart__influstart = None  # np.ndarray - Influence function handling
 
        # Registration
        self.__G__G = 1.0
        """ Magnifying factor"""
        self.__theta__theta = 0.0
        """ WFS rotation angle in the pupil"""
        self.__dx__dx = 0.0
        """ X axis misalignment in meters"""
        self.__dy__dy = 0.0
        """ Y axis misalignment in meters"""
 
    def get_ap(self):
        """ Get ap TODO!!!
 
        :return: (float) : TODO
        """
        return self.__ap__ap
 
    def set_ap(self, ap):
        """ Set ap TODO!!!
 
        :param ap: (float) : TODO
        """
        self.__ap__ap = csu.enforce_arrayMultiDim(ap, (ap.shape[0], ap.shape[1]),
                                              dtype=np.float32)
 
    ap = property(get_ap, set_ap)
 
    def get_nfunc(self):
        """ Get nfunc TODO !!!
 
        :return: (int) : TODO
        """
        return self.__nfunc__nfunc
 
    def set_nfunc(self, nfunc):
        """ Set nfunc TODO !!!
 
        :param nfunc: (int) : TODO
        """
        self.__nfunc__nfunc = csu.enforce_int(nfunc)
 
    nfunc = property(get_nfunc, set_nfunc)
 
    def get_pzt_extent(self):
        """ Get extent of pzt dm in pich unit default = 5
 
        :return: (int) : extent pzt dm
        """
        return self.__pzt_extent__pzt_extent
 
    def set_pzt_extent(self, p):
        """ Set extent of pzt dm in pich unit default = 5
 
        :param p: (int) : extent pzt dm
        """
        self.__pzt_extent__pzt_extent = csu.enforce_int(p)
 
    pzt_extent = property(get_pzt_extent, set_pzt_extent)
 
    def get_segmented_mirror(self):
        return self.__segmented_mirror__segmented_mirror
 
    def set_segmented_mirror(self, b):
        """ Define mirror influence functions to be cropped by the spiders
        (more generally, pupil edges)
 
        :param p: (bool) : segment the mirror
        """
        self.__segmented_mirror__segmented_mirror = csu.enforce_or_cast_bool(b)
 
    segmented_mirror = property(get_segmented_mirror, set_segmented_mirror)
 
    def get_influ_type(self):
        """ Get the influence function type for pzt DM
 
        :return: (str) : centroider type
        """
        return self.__influ_type__influ_type
 
    def set_influ_type(self, t):
        """ Set the influence function type for pzt DM
 
        :param t: (str) : centroider type
        """
        self.__influ_type__influ_type = scons.check_enum(scons.InfluType, t)
 
    influ_type = property(get_influ_type, set_influ_type)
 
    def get_influpos(self):
        """ Get the influence functions pixels that contributes to each DM pixel
 
        :return: (np.ndarray[ndim=1, drype=np.int32]) : influpos
        """
        return self.__influpos__influpos
 
    def set_influpos(self, ip):
        """ Set the influence functions pixels that contributes to each DM pixel
 
        :param ip: (np.ndarray[ndim=1, drype=np.int32]) : influpos
        """
        self.__influpos__influpos = csu.enforce_array(ip, ip.size, dtype=np.int32)
 
    _influpos = property(get_influpos, set_influpos)
 
    def get_ninflu(self):
        """ Get the number of influence functions pixels that contributes
        to each DM pixel
 
        :return: (np.ndarray[ndim=1, drype=np.int32]) : ninflu
        """
        return self.__ninflu__ninflu
 
    def set_ninflu(self, n):
        """ Set the number of influence functions pixels that contributes
        to each DM pixel
 
        :param n: (np.ndarray[ndim=1, drype=np.int32]) : ninflu
        """
        self.__ninflu__ninflu = csu.enforce_array(n, n.size, dtype=np.int32)
 
    _ninflu = property(get_ninflu, set_ninflu)
 
    def get_influstart(self):
        """ Get the index where to start a new DM pixel shape in the array influpos
        to each DM pixel
 
        :return: (np.ndarray[ndim=1, drype=np.int32]) : influstart
        """
        return self.__influstart__influstart
 
    def set_influstart(self, n):
        """ Set the index where to start a new DM pixel shape in the array influpos
        to each DM pixel
 
        :param n: (np.ndarray[ndim=1, drype=np.int32]) : influstart
        """
        self.__influstart__influstart = csu.enforce_array(n, n.size, dtype=np.int32)
 
    _influstart = property(get_influstart, set_influstart)
 
    def get_gain(self):
        """ Get the gain to apply to the actuators of the dm
 
        :return: (float) : gain
        """
        return self.__gain__gain
 
    def set_gain(self, g):
        """ Set the gain to apply to the actuators of the dm
 
        :param g: (float) : gain
        """
        self.__gain__gain = csu.enforce_float(g)
 
    gain = property(get_gain, set_gain)
 
    def _get_dim_screen(self):
        """ Get the phase screen dimension
 
        :return: (long) : phase screen dimension
        """
        return self.__dim_screen__dim_screen
 
    def _set_dim_screen(self, n):
        """ Set the phase screen dimension
 
        :param n: (long) : phase screen dimension
        """
        self.__dim_screen__dim_screen = csu.enforce_int(n)
 
    _dim_screen = property(_get_dim_screen, _set_dim_screen)
 
    def get_nkl(self):
        """ Get the number of KL modes used for computation of covmat in case of minimum variance controller
 
        :return: (long) : number of KL modes
        """
        return self.__nkl__nkl
 
    def set_nkl(self, n):
        """ Set the number of KL modes used for computation of covmat in case of minimum variance controller
 
        :param n: (long) : number of KL modes
        """
        self.__nkl__nkl = csu.enforce_int(n)
 
    nkl = property(get_nkl, set_nkl)
 
    def get_type_kl(self):
        """ Get the type of KL used for computation
 
        :return: (string) : KL types : kolmo or karman
        """
        return self.__type_kl__type_kl
 
    def set_type_kl(self, t):
        """ Set the type of KL used for computation
 
        :param t: (string) : KL types : kolmo or karman
        """
        self.__type_kl__type_kl = scons.check_enum(scons.KLType, t)
 
    type_kl = property(get_type_kl, set_type_kl)
 
    def get_type(self):
        """ Get the dm type
 
        :return: (str) : type of dm
        """
        return self.__type__type
 
    def set_type(self, t):
        """ set the dm type
 
        :param t: (str) : type of dm
        """
        self.__type__type = scons.check_enum(scons.DmType, t)
 
    type = property(get_type, set_type)
 
    def get_type_pattern(self):
        """ Get the pattern type
 
        :return: (str) : type of pattern
        """
        return self.__type_pattern__type_pattern
 
    def set_type_pattern(self, t):
        """ set the pattern type
 
        :param t: (str) : type of pattern
        """
        self.__type_pattern__type_pattern = scons.check_enum(scons.PatternType, t)
 
    type_pattern = property(get_type_pattern, set_type_pattern)
 
    def get_file_influ_fits(self):
        """ Get the name of hdf5 influence file
 
        :return: (str) : Hdf5 file influence name
        """
        return self.__file_influ_fits__file_influ_fits
 
    def set_file_influ_fits(self, f):
        """ set the name of hdf5 influence file
 
        :param filename: (str) : Hdf5 file influence name
        """
        self.__file_influ_fits__file_influ_fits = f
 
    file_influ_fits = property(get_file_influ_fits, set_file_influ_fits)
 
    def get_center_name(self):
        """ Get the name of hdf5 influence file
 
        :return: (str) : Hdf5 file influence name
        """
        return self.__center_name__center_name
 
    def set_center_name(self, f):
        """ set the name of hdf5 influence file
 
        :param filename: (str) : Hdf5 file influence name
        """
        self.__center_name__center_name = f
 
    center_name = property(get_center_name, set_center_name)
 
    def get_cube_name(self):
        """ Get the name of influence cube in hdf5
 
        :return: (str) : name of influence cube
        """
        return self.__cube_name__cube_name
 
    def set_cube_name(self, cubename):
        """ set the name of influence cube in hdf5
 
        :param cubename: (str) : name of influence cube
        """
        self.__cube_name__cube_name = cubename
 
    cube_name = property(get_cube_name, set_cube_name)
 
    def get_x_name(self):
        """ Get the name of x coord of influence fonction in file
 
        :return: (str) : name of x coord of influence
        """
        return self.__x_name__x_name
 
    def set_x_name(self, xname):
        """ set the name of x coord of influence fonction in file
 
        :param t: (str) : name of x coord of influence
        """
        self.__x_name__x_name = xname
 
    x_name = property(get_x_name, set_x_name)
 
    def get_y_name(self):
        """ Get the name of y coord of influence fonction in file
 
        :return: (str) : name of y coord of influence
        """
        return self.__y_name__y_name
 
    def set_y_name(self, yname):
        """ set the name of y coord of influence fonction in file
 
        :param yname: (str) : name of y coord of influence
        """
        self.__y_name__y_name = yname
 
    y_name = property(get_y_name, set_y_name)
 
    def get_influ_res(self):
        """ Get the name of influence fonction resolution in file
 
        :return: (str) : name of resoltion (meter/pixel) of influence
        """
        return self.__influ_res__influ_res
 
    def set_influ_res(self, res):
        """ set the name of influence fonction resolution in file
 
        :param res: (str) : name of resoltion (meter/pixel) of influence
        """
        self.__influ_res__influ_res = res
 
    influ_res = property(get_influ_res, set_influ_res)
 
    def get_diam_dm(self):
        """ Get the diameter of the tel pupil projected on the dm plane
 
        :return: (float) : diameter (meters) of the tel pupil projected on the dm plane
        """
        return self.__diam_dm__diam_dm
 
    def set_diam_dm(self, di):
        """ Set the diameter of the tel pupil projected on the dm plane
 
        :param di: (float) : diameter (meters) of the tel pupil projected on the dm plane
        """
        self.__diam_dm__diam_dm = di
 
    diam_dm = property(get_diam_dm, set_diam_dm)
 
    def get_diam_dm_proj(self):
        """ Get the diameter of the dm pupil projected on the tel pupil plane
 
        :return: (float) : diameter (meters) of the dm pupil projected on the tel pupil plane
        """
        return self.__diam_dm_proj__diam_dm_proj
 
    def set_diam_dm_proj(self, dp):
        """ Set the diameter of the dm pupil projected on the tel pupil plane
 
        :param dp: (float) : diameter (meters) of the dm pupil projected on the tel pupil plane
        """
        self.__diam_dm_proj__diam_dm_proj = dp
 
    diam_dm_proj = property(get_diam_dm_proj, set_diam_dm_proj)
 
    def get_nact(self):
        """ Get the number of actuator
 
        :return: (long) : number of actuators in the dm
        """
        return self.__nact__nact
 
    def set_nact(self, n):
        """ set the number of actuator
 
        :param n: (long) : number of actuators in the dm
        """
        self.__nact__nact = csu.enforce_int(n)
 
    nact = property(get_nact, set_nact)
 
    def get_margin_out(self):
        """ Get the margin for outside actuator select
 
        :return: (float) : unit is actuator pitch (+) for extra (-) for intra
        """
        return self.__margin_out__margin_out
 
    def set_margin_out(self, n):
        """ set the margin for outside actuator select
 
        :param n: (float) : unit is actuator pitch (+) for extra (-) for intra
        """
        self.__margin_out__margin_out = csu.enforce_float(n)
 
    margin_out = property(get_margin_out, set_margin_out)
 
    def get_margin_in(self):
        """ Get the margin for inside actuator select (central obstruction)
 
        :return: (float) : unit is actuator pitch (+) for extra (-) for intra
        """
        return self.__margin_in__margin_in
 
    def set_margin_in(self, n):
        """ set the margin for inside actuator select (central obstruction)
 
        :param n: (float) : unit is actuator pitch (+) for extra (-) for intra
        """
        self.__margin_in__margin_in = csu.enforce_float(n)
 
    margin_in = property(get_margin_in, set_margin_in)
 
    def get_alt(self):
        """ Get the conjugaison altitude
 
        :return: (float) : conjugaison altitude (im m)
        """
        return self.__alt__alt
 
    def set_alt(self, a):
        """ set the conjugaison altitude
 
        :param a: (float) : conjugaison altitude (im m)
        """
        self.__alt__alt = csu.enforce_float(a)
 
    alt = property(get_alt, set_alt)
 
    def get_thresh(self):
        """ Get the threshold on response for selection
 
        :return: (float) : threshold on response for selection (<1)
        """
        return self.__thresh__thresh
 
    def set_thresh(self, t):
        """ set the threshold on response for selection
 
        :param t: (float) : threshold on response for selection (<1)
        """
        self.__thresh__thresh = csu.enforce_float(t)
 
    thresh = property(get_thresh, set_thresh)
 
    def get_keep_all_actu(self):
        """ Get the flag for keeping all actuators
 
        :return: (bool) : keep all actuator flag (boolean)
        """
        return self.__keep_all_actu__keep_all_actu
 
    def set_keep_all_actu(self, k):
        """ set the flag for keeping all actuators
 
        :param k: (f) : keep all actuator flag (boolean)
        """
        self.__keep_all_actu__keep_all_actu = csu.enforce_or_cast_bool(k)
 
    keep_all_actu = property(get_keep_all_actu, set_keep_all_actu)
 
    def get_coupling(self):
        """ Get the actuators coupling
 
        :return: (float) : actuators coupling (<0.3)
        """
        return self.__coupling__coupling
 
    def set_coupling(self, c):
        """ set the actuators coupling
 
        :param c: (float) : actuators coupling (<0.3)
        """
        self.__coupling__coupling = csu.enforce_float(c)
 
    coupling = property(get_coupling, set_coupling)
 
    def get_unitpervolt(self):
        """ Get the Influence function sensitivity
 
        :return: (float) : Influence function sensitivity in unit/volt
        """
        return self.__unitpervolt__unitpervolt
 
    def set_unitpervolt(self, u):
        """ set the Influence function sensitivity
 
        :param u: (float) : Influence function sensitivity in unit/volt
        """
        self.__unitpervolt__unitpervolt = csu.enforce_float(u)
 
    unitpervolt = property(get_unitpervolt, set_unitpervolt)
 
    def get_push4imat(self):
        """ Get the nominal voltage for imat
 
        :return: (float) : nominal voltage for imat
        """
        return self.__push4imat__push4imat
 
    def set_push4imat(self, p):
        """ set the nominal voltage for imat
 
        :param p: (float) : nominal voltage for imat
        """
        self.__push4imat__push4imat = csu.enforce_float(p)
 
    push4imat = property(get_push4imat, set_push4imat)
 
    def get_ntotact(self):
        """ Get the total number of actuators
 
        :return: (long) : total number of actuators
        """
        return self.__ntotact__ntotact
 
    def set_ntotact(self, n):
        """ set the total number of actuators
 
        :param n: (long) : total number of actuators
        """
        self.__ntotact__ntotact = csu.enforce_int(n)
 
    _ntotact = property(get_ntotact, set_ntotact)
 
    def get_pitch(self):
        """ Get the actuators pitch [pixels]
 
        :return: (float) : actuators pitch [pixels]
        """
        return self.__pitch__pitch
 
    def set_pitch(self, p):
        """ set the actuators pitch [pixels]
 
        :param p: (float) : actuators pitch [pixels]
        """
        self.__pitch__pitch = csu.enforce_float(p)
 
    _pitch = property(get_pitch, set_pitch)
 
    def get_influsize(self):
        """ Get the actuators influsize [pixels]
 
        :return: (int) : actuators influsize [pixels]
        """
        return self.__influsize__influsize
 
    def set_influsize(self, s):
        """ set the actuators influsize [pixels]
 
        :param s: (int) : actuators influsize [pixels]
        """
        self.__influsize__influsize = csu.enforce_int(s)
 
    _influsize = property(get_influsize, set_influsize)
 
    def get_n1(self):
        """ Get the position of bottom left pixel in the largest support
 
        :return: (int) : actuators n1 [pixels]
        """
        return self.__n1__n1
 
    def set_n1(self, n):
        """ set the position of bottom left pixel in the largest support
 
        :param n: (int) : actuators n1 [pixels]
        """
        self.__n1__n1 = csu.enforce_int(n)
 
    _n1 = property(get_n1, set_n1)
 
    def get_n2(self):
        """ Get the position of bottom right pixel in the largest support
 
        :return: (int) : actuators n2 [pixels]
        """
        return self.__n2__n2
 
    def set_n2(self, n):
        """ set the position of bottom right pixel in the largest support
 
        :param n: (int) : actuators n2 [pixels]
        """
        self.__n2__n2 = csu.enforce_int(n)
 
    _n2 = property(get_n2, set_n2)
 
    def get_xpos(self):
        """ Get the x positions of influ functions (lower left corner)
 
        :return: (np.ndarray[ndim=1,dtype=np.float32_t]) : x positions of influ functions
        """
        return self.__xpos__xpos
 
    def set_xpos(self, xpos):
        """ Set the x positions of influ functions (lower left corner)
 
        :param xpos: (np.ndarray[ndim=1,dtype=np.float32_t]) : x positions of influ functions
        """
        self.__xpos__xpos = csu.enforce_array(xpos, self.__ntotact__ntotact, dtype=np.float32)
 
    _xpos = property(get_xpos, set_xpos)
 
    def get_ypos(self):
        """ Get the y positions of influ functions (lower left corner)
 
        :return: (np.ndarray[ndim=1,dtype=np.float32_t]) : y positions of influ functions
        """
        return self.__ypos__ypos
 
    def set_ypos(self, ypos):
        """ Set the y positions of influ functions (lower left corner)
 
        :param ypos: (np.ndarray[ndim=1,dtype=np.float32_t]) : y positions of influ functions
        """
        self.__ypos__ypos = csu.enforce_array(ypos, self.__ntotact__ntotact, dtype=np.float32)
 
    _ypos = property(get_ypos, set_ypos)
 
    def get_i1(self):
        """ Get the X-position of the bottom left corner of each influence function
 
        :return: (np.ndarray[ndim=1,dtype=np.int32_t]) :
        """
        return self.__i1__i1
 
    def set_i1(self, i1):
        """ Set the X-position of the bottom left corner of each influence function
 
        :param i1: (np.ndarray[ndim=1,dtype=np.int32_t]) :
        """
        self.__i1__i1 = csu.enforce_array(i1, self.__ntotact__ntotact, dtype=np.int32)
 
    _i1 = property(get_i1, set_i1)
 
    def get_j1(self):
        """ Get the Y-position of the bottom left corner of each influence function
 
        :return: (np.ndarray[ndim=1,dtype=np.int32_t]) :
        """
        return self.__j1__j1
 
    def set_j1(self, j1):
        """ Set the Y-position of the bottom left corner of each influence function
 
        :param j1: (np.ndarray[ndim=1,dtype=np.int32_t]) :
        """
        self.__j1__j1 = csu.enforce_array(j1, self.__ntotact__ntotact, dtype=np.int32)
 
    _j1 = property(get_j1, set_j1)
 
    def get_influ(self):
        """ Get the influence function
 
        :return: (np.ndarray[ndim=3,dtype=np.float32_t]) : influence function
        """
        return self.__influ__influ
 
    def set_influ(self, influ):
        """ Set the influence function
 
        :param influ: (np.ndarray[ndim=3,dtype=np.float32_t]) : influence function
        """
        self.__influ__influ = csu.enforce_arrayMultiDim(influ,
                                                 (self.__influsize__influsize, self.__influsize__influsize,
                                                  self._ntotact_ntotact), dtype=np.float32)
 
    _influ = property(get_influ, set_influ)
 
    def get_pupoffset(self):
        """ Get the pupil offset in meters
 
        :return: (np.ndarray[ndim=1,dtype=np.float32_t]) : offsets [m]
        """
        return self.__pupoffset__pupoffset
 
    def set_pupoffset(self, off):
        """ Set the pupil offset in meters
 
        :param off: (np.ndarray[ndim=1,dtype=np.float32_t]) : offsets [m]
        """
        self.__pupoffset__pupoffset = csu.enforce_array(off, 2, dtype=np.float32)
 
    pupoffset = property(get_pupoffset, set_pupoffset)
 
    def get_puppixoffset(self):
        """ Get the pupil offset in pixels
 
        :return: (np.ndarray[ndim=1,dtype=np.float32_t]) : offsets [pixels]
        """
        return self.__puppixoffset__puppixoffset
 
    def set_puppixoffset(self, off):
        """ Set the pupil offset in pixels
 
        :param off: (np.ndarray[ndim=1,dtype=np.float32_t]) : offsets [pixels]
        """
        self.__puppixoffset__puppixoffset = csu.enforce_array(off, 2, dtype=np.float32)
 
    _puppixoffset = property(get_puppixoffset, set_puppixoffset)
 
    def get_outscl(self):
        """ Get the outer scale for KL with Von Karman spectrum
 
        :return: (float) : outer scale [m]
        """
        return self.__outscl__outscl
 
    def set_outscl(self, L0):
        """ Set the outer scale for KL with Von Karman spectrum
 
        :param L0: (float) : outer scale [m]
        """
        self.__outscl__outscl = csu.enforce_float(L0)
 
    outscl = property(get_outscl, set_outscl)
 
    def get_nr(self):
        """ Get the number of radial points for KL
 
        :return: (int) : number of radial points
        """
        return self.__nr__nr
 
    def set_nr(self, n):
        """ Set the number of radial points for KL
 
        :param n: (int) : number of radial points
        """
        self.__nr__nr = csu.enforce_int(n)
 
    _nr = property(get_nr, set_nr)
 
    def get_npp(self):
        """ Get the number of elements (?) for KL
 
        :return: (int) : number of elements
        """
        return self.__npp__npp
 
    def set_npp(self, n):
        """ Set the number of elements (?) for KL
 
        :param n: (int) : number of elements
        """
        self.__npp__npp = csu.enforce_int(n)
 
    _npp = property(get_npp, set_npp)
 
    def get_ncp(self):
        """ Get the dimension of grid (?)
 
        :return: (int) : dimension
        """
        return self.__ncp__ncp
 
    def set_ncp(self, n):
        """ Set the dimension of grid (?)
 
        :param n: (int) : dimension
        """
        self.__ncp__ncp = csu.enforce_int(n)
 
    _ncp = property(get_ncp, set_ncp)
 
    def get_ord(self):
        """ Get the radial orders of the basis
 
        :return: (int) : radial order of the basis
        """
        return self.__ord__ord
 
    def set_ord(self, n):
        """ Set the radial orders of the basis
 
        :param n: (int) : radial order of the basis
        """
        self.__ord__ord = csu.enforce_array(n, n.size, dtype=np.int32)
 
    _ord = property(get_ord, set_ord)
 
    def get_rabas(self):
        """ Get the radial array of the KL basis
 
        :return: (np.ndarray[ndim=1,dtype=np.float32_t]) : radial array
        """
        return self.__rabas__rabas
 
    def set_rabas(self, r):
        """ Set the radial array of the KL basis
 
        :param r: (np.ndarray[ndim=1,dtype=np.float32_t]) : radial array
        """
        self.__rabas__rabas = csu.enforce_arrayMultiDim(r, r.shape, dtype=np.float32)
 
    _rabas = property(get_rabas, set_rabas)
 
    def get_azbas(self):
        """ Get the azimuthal array of the KL basis
 
        :return: (np.ndarray[ndim=1,dtype=np.float32_t]) : azimuthal array
        """
        return self.__azbas__azbas
 
    def set_azbas(self, r):
        """ Set the azimuthal array of the KL basis
 
        :param r: (np.ndarray[ndim=1,dtype=np.float32_t]) : azimuthal array
        """
        self.__azbas__azbas = csu.enforce_arrayMultiDim(r, r.shape, dtype=np.float32)
 
    _azbas = property(get_azbas, set_azbas)
 
    def get_cr(self):
        """ Get the radial coordinates in carthesian grid
 
        :return: (np.ndarray[ndim=1,dtype=np.float32_t]) : radial coordinates in carthesian grid
        """
        return self.__cr__cr
 
    def set_cr(self, r):
        """ Set the radial coordinates in carthesian grid
 
        :param r: (np.ndarray[ndim=1,dtype=np.float32_t]) : radial coordinates in carthesian grid
        """
        self.__cr__cr = csu.enforce_arrayMultiDim(r, r.shape, dtype=np.float32)
 
    _cr = property(get_cr, set_cr)
 
    def get_cp(self):
        """ Get the phi coordinates in carthesian grid
 
        :return: (np.ndarray[ndim=1,dtype=np.float32_t]) : phi coordinates in carthesian grid
        """
        return self.__cp__cp
 
    def set_cp(self, r):
        """ Set the phi coordinates in carthesian grid
 
        :param r: (np.ndarray[ndim=1,dtype=np.float32_t]) : phi coordinates in carthesian grid
        """
        self.__cp__cp = csu.enforce_arrayMultiDim(r, r.shape, dtype=np.float32)
 
    _cp = property(get_cp, set_cp)
 
    def get_G(self):
        """ Get the magnifying factor
 
        :return: (float) : magnifying factor
        """
        return self.__G__G
 
    def set_G(self, G):
        """ Set the magnifying factor
 
        :param G: (float) : magnifying factor
        """
        self.__G__G = csu.enforce_float(G)
 
    G = property(get_G, set_G)
 
    def get_theta(self):
        """ Get the rotation angle in the pupil
 
        :return: (float) : rotation angle (rad)
        """
        return self.__theta__theta
 
    def set_theta(self, theta):
        """ Set the rotation angle in the pupil
 
        :param theta: (float) : rotation angle (rad)
        """
        self.__theta__theta = csu.enforce_float(theta)
 
    theta = property(get_theta, set_theta)
 
    def get_dx(self):
        """ Get the X axis misalignment
 
        :return: (float) : dx (pix)
        """
        return self.__dx__dx
 
    def set_dx(self, dx):
        """ Set the X axis misalignment
 
        :param dx: (float) : dx (pix)
        """
        self.__dx__dx = csu.enforce_float(dx)
 
    dx = property(get_dx, set_dx)
 
    def get_dy(self):
        """ Get the Y axis misalignment
 
        :return: (float) : dy (pix)
        """
        return self.__dy__dy
 
    def set_dy(self, dy):
        """ Set the Y axis misalignment
 
        :param dy: (float) : dy (pix)
        """
        self.__dy__dy = csu.enforce_float(dy)
 
    dy = property(get_dy, set_dy)