sutraWrap.py

 
"""Binding module for libsutra"""
from __future__ import annotations
import sutraWrap
import typing
import carmaWrap
import numpy
_Shape = typing.Tuple[int, ...]
 
__all__ = [
    "Atmos",
    "CentroiderBPCOG_FF",
    "CentroiderBPCOG_UF",
    "CentroiderCORR_FF",
    "CentroiderCORR_UF",
    "CentroiderMASKEDPIX_FF",
    "CentroiderMASKEDPIX_UF",
    "CentroiderPYR_FF",
    "CentroiderPYR_UF",
    "CentroiderTCOG_FF",
    "CentroiderTCOG_UF",
    "CentroiderWCOG_FF",
    "CentroiderWCOG_UF",
    "Centroider_FF",
    "Centroider_UF",
    "ControllerCURED_FF",
    "ControllerCURED_FU",
    "ControllerGENERICLINEAR_FF",
    "ControllerGENERICLINEAR_FU",
    "ControllerGENERIC_FF",
    "ControllerGENERIC_FU",
    "ControllerGEO_FF",
    "ControllerGEO_FU",
    "ControllerLS_FF",
    "ControllerLS_FU",
    "ControllerMV_FF",
    "ControllerMV_FU",
    "Controller_FF",
    "Controller_FU",
    "Coronagraph",
    "Dm",
    "Dms",
    "Gamora",
    "Groot",
    "LGS",
    "PYRWFS",
    "PerfectCoronagraph",
    "Rtc_FFF",
    "Rtc_FFU",
    "Rtc_UFF",
    "Rtc_UFU",
    "SHWFS",
    "Sensors",
    "Source",
    "StellarCoronagraph",
    "Target",
    "Telescope",
    "Tscreen",
    "Wfs"
]
 
 
class Atmos():
    def __init__(self, context: carmaWrap.context, nscreens: int, global_r0: float, r0_per_layer: numpy.ndarray[numpy.float32], size1: numpy.ndarray[numpy.int64], size2: numpy.ndarray[numpy.int64], altitude: numpy.ndarray[numpy.float32], windspeed: numpy.ndarray[numpy.float32], winddir: numpy.ndarray[numpy.float32], deltax: numpy.ndarray[numpy.float32], deltay: numpy.ndarray[numpy.float32], device: int) -> None: 
        """
        Create and initialise an atmos object
 
        Attributes:
            context: (CarmaContext) : current carma context
 
            nscreens: (float) : number of turbulent layers
 
            global_r0: (float): global r0
 
            r0_per_layer: (float) : r0 per layer
 
            size1: (np.ndarray[ndim=1, dtype=np.int64_t]) : First size of screens
 
            size2: (np.ndarray[ndim=1, dtype=np.int64_t]) : Second size of screens
 
            altitude: (np.ndarray[ndim=1,dtype=np.float32_t]) : altitudes [m]
 
            windspeed: (np.ndarray[ndim=1,dtype=np.float32_t]) : wind speed [m/s]
 
            winddir: (np.ndarray[ndim=1,dtype=np.float32_t]) : wind direction [deg]
 
            deltax: (np.ndarray[ndim=1,dtype=np.float32_t]) : extrude deltax pixels in the x-direction at each iteration
 
            deltay: (np.ndarray[ndim=1,dtype=np.float32_t]) : extrude deltay pixels in the y-direction at each iteration
 
            device: (int): GPU device index
            
        """
    def __str__(self) -> str: ...
    def add_screen(self, altitude: float, size: int, stencil_size: int, r0: float, windspeed: float, winddir: float, deltax: float, deltay: float, device: int) -> int: 
        """
        Add a screen to the atmos object.
 
        Args:
            altitude: (float) : altitude of the screen in meters
 
            size: (long) : dimension of the screen (size x size)
 
            stencil_size: (long): dimension of the stencil
 
            r0: (float) : frac of r0**(5/3)
 
            windspeed: (float) : windspeed of the screen [m/s]
 
            winddir: (float) : wind direction (deg)
 
            deltax: (float) : extrude deltax pixels in the x-direction at each iteration
 
            deltay: (float) : extrude deltay pixels in the y-direction at each iteration
 
            device: (int) : device number
            
        """
    def del_screen(self, idx: int) -> int: 
        """
        Delete the selected screen
 
        Args:
            idx: (int): index of the screen
            
        """
    def init_screen(self, idx: int, A: numpy.ndarray[numpy.float32], B: numpy.ndarray[numpy.float32], istencilx: numpy.ndarray[numpy.uint32], istencily: numpy.ndarray[numpy.uint32], seed: int) -> int: 
        """
        Initialize an newly allocated screen
 
        Args:
            idx: (int): index of the screen
 
            A: (np.ndarray[ndim=2, dtype=np.float32]): A matrix (cf. Assemat)
 
            B: (np.ndarray[ndim=2, dtype=np.float32]): B matrix (cf. Assemat)
 
            istencilx: (np.ndarray[ndim=2, dtype=int32]): X stencil index
 
            istencily: (np.ndarray[ndim=2, dtype=int32]): Y stencil index
 
            seed: (int): seed for RNG
            
        """
    def move_atmos(self) -> int: 
        """
        Move the turbulence in the atmos screen following loaded
        parameters such as windspeed and wind direction
        """
    def refresh_screen(self, idx: int) -> int: 
        """
        Refresh the selected screen by extrusion
 
        Args:
            idx: (int): index of the screen
            
        """
    def set_r0(self, r0: float) -> int: 
        """
        Change the current global r0 of all layers
 
        Args:
            r0: (float): r0 @ 0.5 microns
            
        """
    def set_seed(self, idx: int, seed: float) -> int: 
        """
        Set the seed of the selected screen RNG
 
        Args:
            idx: (int): index of the screen
 
            seed: (int) :new seed
            
        """
    @property
    def d_screens(self) -> typing.List[Tscreen]:
        """
        Vector of tscreens
 
        :type: typing.List[Tscreen]
        """
    @property
    def nscreens(self) -> int:
        """
        Number of turbulent screens
 
        :type: int
        """
    @property
    def r0(self) -> float:
        """
        Global r0
 
        :type: float
        """
    pass
class Centroider_FF():
    def calibrate_img(self) -> int: 
        """
        Performs the raw WFS frame calibration
        """
    def calibrate_img_validPix(self) -> int: 
        """
        Performs the raw WFS frame calibration only on useful pixels
        """
    def get_cog(self) -> int: 
        """
        Computes centroids and stores it in d_slopes of the WFS
        """
    def init_calib(self, n: int, m: int) -> int: 
        """
        Initialize data used for calibration
 
        Args:
           n: (int): image support height
 
           m: (int): image support width
        """
    def init_img_raw(self, n: int, m: int) -> int: 
        """
        Initialize array to store raw WFS image in RTC standalone mode
 
        Args:
           n: (int): image support height
 
           m: (int): image support width
        """
    @typing.overload
    def load_img(self, img: numpy.ndarray[numpy.float32], m: int, n: int, location: int) -> int: 
        """
        Load an image in a RTC standalone (host to device)
 
        Args:
           img: (np.ndarray[ndim=2, dtype=np.float32_t]): SH image
 
           m: (int): Image support size X
 
           n: (int): Image support size Y
 
           location: (int): If -1, image is located on the CPU (hostToDevice). Else, it is the GPU index where the image is located
 
 
 
        Load a square image (n, n) in a RTC standalone
 
        Args:
           img: (np.ndarray[ndim=2, dtype=np.float32_t]): SH image
 
           n: (int): Image support size along one axis
 
        Kwargs:
           location: (int): (optionnal) If -1 (default), image is located on the CPU (hostToDevice). Else, it is the GPU index where the image is located
 
 
 
        Load an image in a RTC standalone from a CarmaObj
 
        Args:
           img: (CarmaObj): SH image
        """
    @typing.overload
    def load_img(self, img: numpy.ndarray[numpy.float32], n: int, location: int = -1) -> int: ...
    @typing.overload
    def load_img(self, img: carmaWrap.obj_float) -> int: ...
    def load_validpos(self, validx: numpy.ndarray[numpy.int32], validy: numpy.ndarray[numpy.int32], N: int) -> int: 
        """
        Load the validx and validy arrays
 
        Args:
           validx: (np.array[ndim=1,dtype=np.float32]): X positions of the valid ssp
 
           validy: (np.array[ndim=1,dtype=np.float32]): Y positions of the valid ssp
 
           N: (int): arrays size
        """
    def set_centroids_ref(self, refslopes: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the references slopes
 
        Args:
             refslopes: (np.array[ndim1,dtype=np.float32]): reference slopes to set
        """
    def set_dark(self, dark: numpy.ndarray[numpy.float32], n: int) -> int: 
        """
        Set the dark frame for calibration
 
        Args:
           dark: (np.ndarray[ndim=2, dtype=np.float32_t): dark frame (size n by n)
 
           n: (int): image support size
        """
    def set_flat(self, flat: numpy.ndarray[numpy.float32], n: int) -> int: 
        """
        Set the flat frame for calibration
 
        Args:
           flat: (np.ndarray[ndim=2, dtype=np.float32_t): flat frame (size n by n)
 
           n: (int): image support size
        """
    def set_lutPix(self, lutPix: numpy.ndarray[numpy.int32], n: int) -> int: 
        """
        Set the lookup Table Pixel vector for calibration
 
        Args:
           lutPix: (np.ndarray[ndim=1, dtype=np.float32_t): lutPix vector
 
           n: (int): image pixel size
        """
    def set_npix(self, npix: int) -> int: 
        """
        Set the number of pixels per subap for a RTC standalone
 
        Args:
           npix: (int): number of pixel along a subap. side
        """
    def set_nxsub(self, nxsub: int) -> int: 
        """
        Set the number of ssp across the pupil diameter for a RTC standalone
 
        Args:
           nxsub: (int): number of ssp across the pupil diameter
        """
    def set_offset(self, offset: float) -> int: 
        """
        Set the controider offset [pixels]
 
        Args:
           offset: (float): new offset [pixels]
        """
    def set_scale(self, scale: float) -> int: 
        """
        Set the controider scale factor
 
        Args:
           scale: (float): new scale factor
        """
    @property
    def context(self) -> carmaWrap.context:
        """
        GPU context
 
        :type: carmaWrap.context
        """
    @property
    def d_TT_slopes(self) -> carmaWrap.obj_float:
        """
        Tip/tilt slopes removed after filtering
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_bincube(self) -> carmaWrap.obj_float:
        """
        Bincube of the WFS image
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_centroids_ref(self) -> carmaWrap.obj_float:
        """
        Reference slopes vector
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_dark(self) -> carmaWrap.obj_float:
        """
        Dark frame for calibration
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_flat(self) -> carmaWrap.obj_float:
        """
        Flat frame for calibration
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_img(self) -> carmaWrap.obj_float:
        """
        Calibrated WFS image
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_img_raw(self) -> carmaWrap.obj_float:
        """
        Raw WFS image
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_intensities(self) -> carmaWrap.obj_float:
        """
        intensities of the WFS image
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_lutPix(self) -> carmaWrap.obj_int:
        """
        Lookup Table of pixels for calibration
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_ref_Tilt(self) -> carmaWrap.obj_float:
        """
        Tilt mode reference for filtering
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_ref_Tip(self) -> carmaWrap.obj_float:
        """
        Tip mode reference for filtering
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_validMask(self) -> carmaWrap.obj_int:
        """
        Flat frame for calibration
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_validx(self) -> carmaWrap.obj_int:
        """
        X positions of the valid ssp
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_validy(self) -> carmaWrap.obj_int:
        """
        Y positions of the valid ssp
 
        :type: carmaWrap.obj_int
        """
    @property
    def device(self) -> int:
        """
        GPU device index
 
        :type: int
        """
    @property
    def filter_TT(self) -> bool:
        """
        Tip/tilt filtering flag
 
        :type: bool
        """
    @property
    def npix(self) -> int:
        """
        Number of pixels along a side of WFS subap.
 
        :type: int
        """
    @property
    def nslopes(self) -> int:
        """
        Number of slopes
 
        :type: int
        """
    @property
    def nvalid(self) -> int:
        """
        Number of valid ssp of the WFS
 
        :type: int
        """
    @property
    def nxsub(self) -> int:
        """
        Number of ssp across the pupil diameter
 
        :type: int
        """
    @property
    def offset(self) -> float:
        """
        Offset for centroiding computation
 
        :type: float
        """
    @property
    def scale(self) -> float:
        """
        Scale factor to get slopes in arcsec
 
        :type: float
        """
    @property
    def type(self) -> str:
        """
        Centroider type
 
        :type: str
        """
    @property
    def wfs(self) -> Wfs:
        """
        SutraWfs handled by this centroider
 
        :type: Wfs
        """
    pass
class Centroider_UF():
    def calibrate_img(self) -> int: 
        """
        Performs the raw WFS frame calibration
        """
    def calibrate_img_validPix(self) -> int: 
        """
        Performs the raw WFS frame calibration only on useful pixels
        """
    def get_cog(self) -> int: 
        """
        Computes centroids and stores it in d_slopes of the WFS
        """
    def init_calib(self, n: int, m: int) -> int: 
        """
        Initialize data used for calibration
 
        Args:
           n: (int): image support height
 
           m: (int): image support width
        """
    def init_img_raw(self, n: int, m: int) -> int: 
        """
        Initialize array to store raw WFS image in RTC standalone mode
 
        Args:
           n: (int): image support height
 
           m: (int): image support width
        """
    @typing.overload
    def load_img(self, img: numpy.ndarray[numpy.uint16], m: int, n: int, location: int) -> int: 
        """
        Load an image in a RTC standalone (host to device)
 
        Args:
           img: (np.ndarray[ndim=2, dtype=np.float32_t]): SH image
 
           m: (int): Image support size X
 
           n: (int): Image support size Y
 
           location: (int): If -1, image is located on the CPU (hostToDevice). Else, it is the GPU index where the image is located
 
 
 
        Load a square image (n, n) in a RTC standalone
 
        Args:
           img: (np.ndarray[ndim=2, dtype=np.float32_t]): SH image
 
           n: (int): Image support size along one axis
 
        Kwargs:
           location: (int): (optionnal) If -1 (default), image is located on the CPU (hostToDevice). Else, it is the GPU index where the image is located
 
 
 
        Load an image in a RTC standalone from a CarmaObj
 
        Args:
           img: (CarmaObj): SH image
        """
    @typing.overload
    def load_img(self, img: numpy.ndarray[numpy.uint16], n: int, location: int = -1) -> int: ...
    @typing.overload
    def load_img(self, img: carmaWrap.obj_uint16) -> int: ...
    def load_validpos(self, validx: numpy.ndarray[numpy.int32], validy: numpy.ndarray[numpy.int32], N: int) -> int: 
        """
        Load the validx and validy arrays
 
        Args:
           validx: (np.array[ndim=1,dtype=np.float32]): X positions of the valid ssp
 
           validy: (np.array[ndim=1,dtype=np.float32]): Y positions of the valid ssp
 
           N: (int): arrays size
        """
    def set_centroids_ref(self, refslopes: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the references slopes
 
        Args:
             refslopes: (np.array[ndim1,dtype=np.float32]): reference slopes to set
        """
    def set_dark(self, dark: numpy.ndarray[numpy.float32], n: int) -> int: 
        """
        Set the dark frame for calibration
 
        Args:
           dark: (np.ndarray[ndim=2, dtype=np.float32_t): dark frame (size n by n)
 
           n: (int): image support size
        """
    def set_flat(self, flat: numpy.ndarray[numpy.float32], n: int) -> int: 
        """
        Set the flat frame for calibration
 
        Args:
           flat: (np.ndarray[ndim=2, dtype=np.float32_t): flat frame (size n by n)
 
           n: (int): image support size
        """
    def set_lutPix(self, lutPix: numpy.ndarray[numpy.int32], n: int) -> int: 
        """
        Set the lookup Table Pixel vector for calibration
 
        Args:
           lutPix: (np.ndarray[ndim=1, dtype=np.float32_t): lutPix vector
 
           n: (int): image pixel size
        """
    def set_npix(self, npix: int) -> int: 
        """
        Set the number of pixels per subap for a RTC standalone
 
        Args:
           npix: (int): number of pixel along a subap. side
        """
    def set_nxsub(self, nxsub: int) -> int: 
        """
        Set the number of ssp across the pupil diameter for a RTC standalone
 
        Args:
           nxsub: (int): number of ssp across the pupil diameter
        """
    def set_offset(self, offset: float) -> int: 
        """
        Set the controider offset [pixels]
 
        Args:
           offset: (float): new offset [pixels]
        """
    def set_scale(self, scale: float) -> int: 
        """
        Set the controider scale factor
 
        Args:
           scale: (float): new scale factor
        """
    @property
    def context(self) -> carmaWrap.context:
        """
        GPU context
 
        :type: carmaWrap.context
        """
    @property
    def d_TT_slopes(self) -> carmaWrap.obj_float:
        """
        Tip/tilt slopes removed after filtering
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_bincube(self) -> carmaWrap.obj_float:
        """
        Bincube of the WFS image
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_centroids_ref(self) -> carmaWrap.obj_float:
        """
        Reference slopes vector
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_dark(self) -> carmaWrap.obj_float:
        """
        Dark frame for calibration
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_flat(self) -> carmaWrap.obj_float:
        """
        Flat frame for calibration
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_img(self) -> carmaWrap.obj_float:
        """
        Calibrated WFS image
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_img_raw(self) -> carmaWrap.obj_uint16:
        """
        Raw WFS image
 
        :type: carmaWrap.obj_uint16
        """
    @property
    def d_intensities(self) -> carmaWrap.obj_float:
        """
        intensities of the WFS image
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_lutPix(self) -> carmaWrap.obj_int:
        """
        Lookup Table of pixels for calibration
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_ref_Tilt(self) -> carmaWrap.obj_float:
        """
        Tilt mode reference for filtering
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_ref_Tip(self) -> carmaWrap.obj_float:
        """
        Tip mode reference for filtering
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_validMask(self) -> carmaWrap.obj_int:
        """
        Flat frame for calibration
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_validx(self) -> carmaWrap.obj_int:
        """
        X positions of the valid ssp
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_validy(self) -> carmaWrap.obj_int:
        """
        Y positions of the valid ssp
 
        :type: carmaWrap.obj_int
        """
    @property
    def device(self) -> int:
        """
        GPU device index
 
        :type: int
        """
    @property
    def filter_TT(self) -> bool:
        """
        Tip/tilt filtering flag
 
        :type: bool
        """
    @property
    def npix(self) -> int:
        """
        Number of pixels along a side of WFS subap.
 
        :type: int
        """
    @property
    def nslopes(self) -> int:
        """
        Number of slopes
 
        :type: int
        """
    @property
    def nvalid(self) -> int:
        """
        Number of valid ssp of the WFS
 
        :type: int
        """
    @property
    def nxsub(self) -> int:
        """
        Number of ssp across the pupil diameter
 
        :type: int
        """
    @property
    def offset(self) -> float:
        """
        Offset for centroiding computation
 
        :type: float
        """
    @property
    def scale(self) -> float:
        """
        Scale factor to get slopes in arcsec
 
        :type: float
        """
    @property
    def type(self) -> str:
        """
        Centroider type
 
        :type: str
        """
    @property
    def wfs(self) -> Wfs:
        """
        SutraWfs handled by this centroider
 
        :type: Wfs
        """
    pass
class CentroiderCORR_FF(Centroider_FF):
    def init_corr(self, isizex: int, isizey: int, interpmat: numpy.ndarray[numpy.float32]) -> int: 
        """
        Initializes corr computation
 
        Args:
            isizex: (int): TODO: docstring
 
            isizey: (int):
 
            interpmat: (np.array[ndim=,dtype=np.float32]):
            
        """
    def load_corr(self, corr: numpy.ndarray[numpy.float32], corr_norm: numpy.ndarray[numpy.float32], ndim: int) -> int: 
        """
        Load arrays for correlation computation
 
        Args:
            corr: (np.array[ndim=,dtype=np.float32): TODO: docstring
 
            corr_norm: (np.array[ndim=,dtype=np.float32):
 
            ndim: (int):
            
        """
    @property
    def d_corr(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_corrfnct(self) -> carmaWrap.obj_float_complex:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_corrmax(self) -> carmaWrap.obj_int:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_corrnorm(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_corrspot(self) -> carmaWrap.obj_float_complex:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_interpmat(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def interp_sizex(self) -> int:
        """
        TODO: docstring
 
        :type: int
        """
    @property
    def interp_sizey(self) -> int:
        """
        TODO: docstring
 
        :type: int
        """
    @property
    def npix(self) -> int:
        """
        TODO: docstring
 
        :type: int
        """
    pass
class CentroiderCORR_UF(Centroider_UF):
    def init_corr(self, isizex: int, isizey: int, interpmat: numpy.ndarray[numpy.float32]) -> int: 
        """
        Initializes corr computation
 
        Args:
            isizex: (int): TODO: docstring
 
            isizey: (int):
 
            interpmat: (np.array[ndim=,dtype=np.float32]):
            
        """
    def load_corr(self, corr: numpy.ndarray[numpy.float32], corr_norm: numpy.ndarray[numpy.float32], ndim: int) -> int: 
        """
        Load arrays for correlation computation
 
        Args:
            corr: (np.array[ndim=,dtype=np.float32): TODO: docstring
 
            corr_norm: (np.array[ndim=,dtype=np.float32):
 
            ndim: (int):
            
        """
    @property
    def d_corr(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_corrfnct(self) -> carmaWrap.obj_float_complex:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_corrmax(self) -> carmaWrap.obj_int:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_corrnorm(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_corrspot(self) -> carmaWrap.obj_float_complex:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_interpmat(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def interp_sizex(self) -> int:
        """
        TODO: docstring
 
        :type: int
        """
    @property
    def interp_sizey(self) -> int:
        """
        TODO: docstring
 
        :type: int
        """
    @property
    def npix(self) -> int:
        """
        TODO: docstring
 
        :type: int
        """
    pass
class CentroiderMASKEDPIX_FF(Centroider_FF):
    def fill_mask(self) -> int: 
        """
        Fill the mask of valid pixels
        """
    def fill_selected_pix(self, centroids: carmaWrap.obj_float) -> None: 
        """
        Return the given pixels vector in an image format
 
        Args:
            centroids: (CarmaObj): Pixels to map on the image
        """
    @property
    def d_mask(self) -> carmaWrap.obj_float:
        """
        Mask of valid pixels
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_selected_pix(self) -> carmaWrap.obj_float:
        """
        Selected pixels as an image
 
        :type: carmaWrap.obj_float
        """
    pass
class CentroiderMASKEDPIX_UF(Centroider_UF):
    def fill_mask(self) -> int: 
        """
        Fill the mask of valid pixels
        """
    def fill_selected_pix(self, centroids: carmaWrap.obj_float) -> None: 
        """
        Return the given pixels vector in an image format
 
        Args:
            centroids: (CarmaObj): Pixels to map on the image
        """
    @property
    def d_mask(self) -> carmaWrap.obj_float:
        """
        Mask of valid pixels
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_selected_pix(self) -> carmaWrap.obj_float:
        """
        Selected pixels as an image
 
        :type: carmaWrap.obj_float
        """
    pass
class CentroiderPYR_FF(Centroider_FF):
    def set_pyr_method(self, method: int) -> int: 
        """
        Set the pyramid method for slopes computation
 
        Args:
                method : (int) : new centroiding method (0: nosinus global
                                                        1: sinus global
                                                        2: nosinus local
                                                        3: sinus local)
                                favor use of shesha_constant.PyrCentroiderMethod
 
            
        """
    def set_pyr_thresh(self, thresh: float) -> int: 
        """
        Set the pyramid threshold value
 
        Args:
                thresh : (float) : threshold value
            
        """
    @property
    def pyr_method(self) -> str:
        """
        Method used for pyramid slopes compuation
 
        :type: str
        """
    pass
class CentroiderPYR_UF(Centroider_UF):
    def set_pyr_method(self, method: int) -> int: 
        """
        Set the pyramid method for slopes computation
 
        Args:
                method : (int) : new centroiding method (0: nosinus global
                                                        1: sinus global
                                                        2: nosinus local
                                                        3: sinus local)
                                favor use of shesha_constant.PyrCentroiderMethod
 
            
        """
    def set_pyr_thresh(self, thresh: float) -> int: 
        """
        Set the pyramid threshold value
 
        Args:
                thresh : (float) : threshold value
            
        """
    @property
    def pyr_method(self) -> str:
        """
        Method used for pyramid slopes compuation
 
        :type: str
        """
    pass
class CentroiderTCOG_FF(Centroider_FF):
    def set_threshold(self, thresh: float) -> int: 
        """
        Set the threshold value of a TCOG centroider
 
        Args:
          thresh : (float) : threshold value to set
 
            
        """
    @property
    def threshold(self) -> float:
        """
        Threshold value
 
        :type: float
        """
    pass
class CentroiderTCOG_UF(Centroider_UF):
    def set_threshold(self, thresh: float) -> int: 
        """
        Set the threshold value of a TCOG centroider
 
        Args:
          thresh : (float) : threshold value to set
 
            
        """
    @property
    def threshold(self) -> float:
        """
        Threshold value
 
        :type: float
        """
    pass
class CentroiderWCOG_FF(Centroider_FF):
    def init_weights(self) -> int: 
        """
        Initializes WCOG computation
        """
    def load_weights(self, weights: numpy.ndarray[numpy.float32], ndim: int) -> int: 
        """
        Load weights on WCOG
 
        Args:
                weight: (np.array[ndim=, dtype=np.float32]: weights
 
                ndim: (int): TODO: docstring
            
        """
    def set_threshold(self, thresh: float) -> int: 
        """
        Set the threshold value of a TCOG centroider
 
        Args:
          thresh : (float) : threshold value to set
 
            
        """
    @property
    def d_weights(self) -> carmaWrap.obj_float:
        """
        Weights applied
 
        :type: carmaWrap.obj_float
        """
    @property
    def threshold(self) -> float:
        """
        Threshold value
 
        :type: float
        """
    pass
class CentroiderWCOG_UF(Centroider_UF):
    def init_weights(self) -> int: 
        """
        Initializes WCOG computation
        """
    def load_weights(self, weights: numpy.ndarray[numpy.float32], ndim: int) -> int: 
        """
        Load weights on WCOG
 
        Args:
                weight: (np.array[ndim=, dtype=np.float32]: weights
 
                ndim: (int): TODO: docstring
            
        """
    def set_threshold(self, thresh: float) -> int: 
        """
        Set the threshold value of a TCOG centroider
 
        Args:
          thresh : (float) : threshold value to set
 
            
        """
    @property
    def d_weights(self) -> carmaWrap.obj_float:
        """
        Weights applied
 
        :type: carmaWrap.obj_float
        """
    @property
    def threshold(self) -> float:
        """
        Threshold value
 
        :type: float
        """
    pass
class CentroiderBPCOG_FF(Centroider_FF):
    def set_nmax(self, nmax: int) -> int: 
        """
        Set the number of brightest pixels considered for COG computation
 
        Args:
            nmax : (float) : nmax value to set
            
        """
    @property
    def d_bpind(self) -> carmaWrap.obj_uint:
        """
        Brightest pixels indices
 
        :type: carmaWrap.obj_uint
        """
    @property
    def d_bpix(self) -> carmaWrap.obj_float:
        """
        Brightest pixels
 
        :type: carmaWrap.obj_float
        """
    @property
    def nmax(self) -> int:
        """
        Number of brightest pixels
 
        :type: int
        """
    pass
class CentroiderBPCOG_UF(Centroider_UF):
    def set_nmax(self, nmax: int) -> int: 
        """
        Set the number of brightest pixels considered for COG computation
 
        Args:
            nmax : (float) : nmax value to set
            
        """
    @property
    def d_bpind(self) -> carmaWrap.obj_uint:
        """
        Brightest pixels indices
 
        :type: carmaWrap.obj_uint
        """
    @property
    def d_bpix(self) -> carmaWrap.obj_float:
        """
        Brightest pixels
 
        :type: carmaWrap.obj_float
        """
    @property
    def nmax(self) -> int:
        """
        Number of brightest pixels
 
        :type: int
        """
    pass
class Controller_FF():
    def add_perturb(self) -> int: 
        """
        Add the perturbation voltage to the command
        """
    def add_perturb_voltage(self, name: str, perturb: numpy.ndarray[numpy.float32], N: int) -> int: 
        """
        Add a new perturbation voltage buffer
 
        Args:
            name: (str): name of the new buffer
 
            perturb: (np.array[ndim=2,dtype=np.float32]): perturbation voltage to set
 
            N: (int): Number of perturb voltage vectors in the buffer
         
        """
    def clip_commands(self) -> int: 
        """
        Clip the commands between volt_min and volt_max (values set in the controller)
        """
    def command_delay(self) -> int: 
        """
        Delay the command
        """
    def comp_voltage(self) -> int: 
        """
        Computes the final voltage to send to the DM
        """
    def disable_perturb_voltage(self, name: str) -> int: 
        """
        Disable a perturbation voltage buffer
 
        Args:
            name: (str): name of the buffer to enable
         
        """
    def enable_perturb_voltage(self, name: str) -> int: 
        """
        Enable a perturbation voltage buffer
 
        Args:
            name: (str): name of the buffer to enable
         
        """
    def remove_perturb_voltage(self, name: str) -> int: 
        """
        Remove a perturbation voltage buffer
 
        Args:
            name: (str): name of the buffer to remove
         
        """
    def reset_coms(self) -> int: 
        """
        Reset the commands circular buffer
        """
    def reset_perturb_voltage(self) -> int: 
        """
        Remove all perturbation voltage buffers
         
        """
    def set_com(self, com: numpy.ndarray[numpy.float32], nElem: int) -> int: 
        """
        Set the command vector of the controller
 
        Args:
            com: (np.array[ndim=3, dtype=np.float32]) : command vector
 
            nElem: (int): Number of elements in com
            
        """
    def set_comRange(self, volt_min: float, volt_max: float) -> None: 
        """
        Set the volt_min and volt_max value for command clipping
 
        Args:
            volt_min: (float): volt_min value for clipping
 
            volt_max: (float): volt_max value for clipping
         
        """
    def set_delay(self, delay: float) -> int: 
        """
        Set the delay
 
        Args:
            delay: (float): loop delay in frames
         
        """
    def set_gain(self, gain: float) -> int: 
        """
        Set the gain
 
        Args:
            gain: (float): loop gain
         
        """
    def set_open_loop(self, status: int, rst: bool = True) -> int: 
        """
        Open (1) or close (0) the loop
 
        Args:
            status: (int): open loop status
 
            rst: (bool): reset integrator if True
         
        """
    def set_perturb_voltage(self, name: str, perturb: numpy.ndarray[numpy.float32], N: int) -> int: 
        """
        Set an existing perturbation voltage buffer
 
        Args:
            name: (str): name of the buffer
 
            perturb: (np.array[ndim=2,dtype=np.float32]): perturbation voltage to set
 
            N: (int): Number of perturb voltage vectors in the buffer
         
        """
    def set_val_max(self, val_max: float) -> int: 
        """
        Set the val_max value for command conversion
 
        Args:
            val_max: (float): val_max value for conversion
         
        """
    def set_volt_max(self, volt_max: float) -> int: 
        """
        Set the volt_max value for command clipping
 
        Args:
            volt_max: (float): volt_max value for clipping
         
        """
    @property
    def centro_idx(self) -> typing.List[int]:
        """
        Indices of the handled centroiders
 
        :type: typing.List[int]
        """
    @property
    def comRange(self) -> typing.Tuple[float, float]:
        """
        :type: typing.Tuple[float, float]
        """
    @property
    def context(self) -> carmaWrap.context:
        """
        GPU context
 
        :type: carmaWrap.context
        """
    @property
    def d_centroids(self) -> carmaWrap.obj_float:
        """
        Slopes vector
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_circularComs0(self) -> carmaWrap.obj_float:
        """
        Oldest command vector in the circular buffer
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_circularComs1(self) -> carmaWrap.obj_float:
        """
        Second oldest Command vector in the circular buffer
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_com(self) -> carmaWrap.obj_float:
        """
        Current command vector
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_com1(self) -> carmaWrap.obj_float:
        """
        Command vector at iteration k-1
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_com_clipped(self) -> carmaWrap.obj_float:
        """
        Delayed commands
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_dmseen(self) -> typing.List[Dm]:
        """
        Vector of SutraDm commanded
 
        :type: typing.List[Dm]
        """
    @property
    def d_perturb_map(self) -> typing.Dict[str, typing.Tuple[carmaWrap.obj_float, int, bool]]:
        """
        Perturbation voltage buffers
 
        :type: typing.Dict[str, typing.Tuple[carmaWrap.obj_float, int, bool]]
        """
    @property
    def d_voltage(self) -> carmaWrap.obj_float:
        """
        Total voltage to apply on the DMs
 
        :type: carmaWrap.obj_float
        """
    @property
    def delay(self) -> float:
        """
        Loop delay
 
        :type: float
        """
    @property
    def device(self) -> int:
        """
        GPU device index
 
        :type: int
        """
    @property
    def gain(self) -> float:
        """
        Controller gain
 
        :type: float
        """
    @property
    def nactu(self) -> int:
        """
        Number of actuators to control
 
        :type: int
        """
    @property
    def nslope(self) -> int:
        """
        Number of slopes
 
        :type: int
        """
    @property
    def open_loop(self) -> int:
        """
        Open loop flag
 
        :type: int
        """
    @property
    def type(self) -> str:
        """
        Controller type
 
        :type: str
        """
    @property
    def val_max(self) -> float:
        """
        Maximum value for d_voltage (ADU). Only used if output is expected in uint16
 
        :type: float
        """
    pass
class Controller_FU():
    def add_perturb(self) -> int: 
        """
        Add the perturbation voltage to the command
        """
    def add_perturb_voltage(self, name: str, perturb: numpy.ndarray[numpy.float32], N: int) -> int: 
        """
        Add a new perturbation voltage buffer
 
        Args:
            name: (str): name of the new buffer
 
            perturb: (np.array[ndim=2,dtype=np.float32]): perturbation voltage to set
 
            N: (int): Number of perturb voltage vectors in the buffer
         
        """
    def clip_commands(self) -> int: 
        """
        Clip the commands between volt_min and volt_max (values set in the controller)
        """
    def command_delay(self) -> int: 
        """
        Delay the command
        """
    def comp_voltage(self) -> int: 
        """
        Computes the final voltage to send to the DM
        """
    def disable_perturb_voltage(self, name: str) -> int: 
        """
        Disable a perturbation voltage buffer
 
        Args:
            name: (str): name of the buffer to enable
         
        """
    def enable_perturb_voltage(self, name: str) -> int: 
        """
        Enable a perturbation voltage buffer
 
        Args:
            name: (str): name of the buffer to enable
         
        """
    def remove_perturb_voltage(self, name: str) -> int: 
        """
        Remove a perturbation voltage buffer
 
        Args:
            name: (str): name of the buffer to remove
         
        """
    def reset_coms(self) -> int: 
        """
        Reset the commands circular buffer
        """
    def reset_perturb_voltage(self) -> int: 
        """
        Remove all perturbation voltage buffers
         
        """
    def set_com(self, com: numpy.ndarray[numpy.float32], nElem: int) -> int: 
        """
        Set the command vector of the controller
 
        Args:
            com: (np.array[ndim=3, dtype=np.float32]) : command vector
 
            nElem: (int): Number of elements in com
            
        """
    def set_comRange(self, volt_min: float, volt_max: float) -> None: 
        """
        Set the volt_min and volt_max value for command clipping
 
        Args:
            volt_min: (float): volt_min value for clipping
 
            volt_max: (float): volt_max value for clipping
         
        """
    def set_delay(self, delay: float) -> int: 
        """
        Set the delay
 
        Args:
            delay: (float): loop delay in frames
         
        """
    def set_gain(self, gain: float) -> int: 
        """
        Set the gain
 
        Args:
            gain: (float): loop gain
         
        """
    def set_open_loop(self, status: int, rst: bool = True) -> int: 
        """
        Open (1) or close (0) the loop
 
        Args:
            status: (int): open loop status
 
            rst: (bool): reset integrator if True
         
        """
    def set_perturb_voltage(self, name: str, perturb: numpy.ndarray[numpy.float32], N: int) -> int: 
        """
        Set an existing perturbation voltage buffer
 
        Args:
            name: (str): name of the buffer
 
            perturb: (np.array[ndim=2,dtype=np.float32]): perturbation voltage to set
 
            N: (int): Number of perturb voltage vectors in the buffer
         
        """
    def set_val_max(self, val_max: float) -> int: 
        """
        Set the val_max value for command conversion
 
        Args:
            val_max: (float): val_max value for conversion
         
        """
    def set_volt_max(self, volt_max: float) -> int: 
        """
        Set the volt_max value for command clipping
 
        Args:
            volt_max: (float): volt_max value for clipping
         
        """
    @property
    def centro_idx(self) -> typing.List[int]:
        """
        Indices of the handled centroiders
 
        :type: typing.List[int]
        """
    @property
    def comRange(self) -> typing.Tuple[float, float]:
        """
        :type: typing.Tuple[float, float]
        """
    @property
    def context(self) -> carmaWrap.context:
        """
        GPU context
 
        :type: carmaWrap.context
        """
    @property
    def d_centroids(self) -> carmaWrap.obj_float:
        """
        Slopes vector
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_circularComs0(self) -> carmaWrap.obj_float:
        """
        Oldest command vector in the circular buffer
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_circularComs1(self) -> carmaWrap.obj_float:
        """
        Second oldest Command vector in the circular buffer
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_com(self) -> carmaWrap.obj_float:
        """
        Current command vector
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_com1(self) -> carmaWrap.obj_float:
        """
        Command vector at iteration k-1
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_com_clipped(self) -> carmaWrap.obj_float:
        """
        Delayed commands
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_dmseen(self) -> typing.List[Dm]:
        """
        Vector of SutraDm commanded
 
        :type: typing.List[Dm]
        """
    @property
    def d_perturb_map(self) -> typing.Dict[str, typing.Tuple[carmaWrap.obj_float, int, bool]]:
        """
        Perturbation voltage buffers
 
        :type: typing.Dict[str, typing.Tuple[carmaWrap.obj_float, int, bool]]
        """
    @property
    def d_voltage(self) -> carmaWrap.obj_uint16:
        """
        Total voltage to apply on the DMs
 
        :type: carmaWrap.obj_uint16
        """
    @property
    def delay(self) -> float:
        """
        Loop delay
 
        :type: float
        """
    @property
    def device(self) -> int:
        """
        GPU device index
 
        :type: int
        """
    @property
    def gain(self) -> float:
        """
        Controller gain
 
        :type: float
        """
    @property
    def nactu(self) -> int:
        """
        Number of actuators to control
 
        :type: int
        """
    @property
    def nslope(self) -> int:
        """
        Number of slopes
 
        :type: int
        """
    @property
    def open_loop(self) -> int:
        """
        Open loop flag
 
        :type: int
        """
    @property
    def type(self) -> str:
        """
        Controller type
 
        :type: str
        """
    @property
    def val_max(self) -> int:
        """
        Maximum value for d_voltage (ADU). Only used if output is expected in uint16
 
        :type: int
        """
    pass
class ControllerGENERICLINEAR_FF(Controller_FF):
    def set_iir_a(self, M: numpy.ndarray[numpy.float32], i: int) -> int: 
        """
        Set a single iir 'a' vector within list (combined with iir outputs)
 
        Args:
          M:  (np.array[ndim=1,dtype=np.float32]): Vector to be set
          i:  (int): index of list to slice vector
        """
    def set_iir_b(self, M: numpy.ndarray[numpy.float32], i: int) -> int: 
        """
        Set a single iir 'b' vector within list (combined with iir inputs)
 
        Args:
          M:  (np.array[ndim=1,dtype=np.float32]): Vector to be set
          i:  (int): index of list to slice vector
        """
    def set_matA(self, M: numpy.ndarray[numpy.float32], i: int) -> int: 
        """
        Set a single A matrix within the list of A matrices (state recursions)
 
        Args:
          M:  (np.array[ndim=2,dtype=np.float32]): Matrix to be sliced
          i:  (int): index of list to slice matrix
        """
    def set_matD(self, M: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set D matrix (interaction matrix)
 
        Args:
          M:  (np.array[ndim=2,dtype=np.float32]): Matrix to be set
        """
    def set_matF(self, M: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set F matrix (mode to actuator voltage projection)
 
        Args:
          M:  (np.array[ndim=2,dtype=np.float32]): Matrix to be set
        """
    def set_matK(self, M: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set K matrix (state to mode projection)
 
        Args:
          M:  (np.array[ndim=2,dtype=np.float32]): Matrix to be set
        """
    def set_matL(self, M: numpy.ndarray[numpy.float32], i: int) -> int: 
        """
        Set a single L matrix within the list of L matrices (innovations)
 
        Args:
          M:  (np.array[ndim=2,dtype=np.float32]): Matrix to be sliced
          i:  (int): index of list to slice matrix
        """
    def set_polc(self, polc: bool) -> int: 
        """
        Set the POLC flag
 
        Args:
          polc: (bool): POLC flag
        """
    @property
    def d_centroids(self) -> carmaWrap.obj_float:
        """
        centroid/slope vector
                  (see compass.io details on the generic linear controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_circular_coms(self) -> typing.List[carmaWrap.obj_float]:
        """
        circular command buffer
                  (see compass.io details on the generic linear controller)
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_circular_s(self) -> typing.List[carmaWrap.obj_float]:
        """
        circular slope buffer
                  (see compass.io details on the generic linear controller)
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_circular_u_in(self) -> typing.List[carmaWrap.obj_float]:
        """
        circular buffer of iir inputs
                  (see compass.io details on the generic linear controller)
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_circular_u_out(self) -> typing.List[carmaWrap.obj_float]:
        """
        circular buffer of iir outputs
                  (see compass.io details on the generic linear controller)
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_circular_x(self) -> typing.List[carmaWrap.obj_float]:
        """
        circular state buffer
                  (see compass.io details on the generic linear controller)
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_com(self) -> carmaWrap.obj_float:
        """
        command vector
                  (see compass.io details on the generic linear controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_iir_a(self) -> typing.List[carmaWrap.obj_float]:
        """
        List of iir coefficient vectors for outputs
                  (see compass.io details on the generic linear controller)
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_iir_b(self) -> typing.List[carmaWrap.obj_float]:
        """
        List of iir coefficient vectors for inputs
                  (see compass.io details on the generic linear controller)
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_imat(self) -> carmaWrap.obj_float:
        """
        D matrix, typically set to the interaction matrix
                  (see compass.io details on the generic linear controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_matA(self) -> typing.List[carmaWrap.obj_float]:
        """
        List of A matrices used for state recursion
                  (see compass.io details on the generic linear controller)
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_matD(self) -> carmaWrap.obj_float:
        """
        D matrix, typically set to the interaction matrix
                  (see compass.io details on the generic linear controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_matF(self) -> carmaWrap.obj_float:
        """
        F matrix, used to project from modes to actuator voltages
                  (see compass.io details on the generic linear controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_matK(self) -> carmaWrap.obj_float:
        """
        K matrix, used for projection from state to modes
                  (see compass.io details on the generic linear controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_matL(self) -> typing.List[carmaWrap.obj_float]:
        """
        List of L matrices used for innovation from measurements
                  (see compass.io details on the generic linear controller)
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_s_now(self) -> carmaWrap.obj_float:
        """
        temporary slope vector used for control calcs
                  (see compass.io details on the generic linear controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_u_now(self) -> carmaWrap.obj_float:
        """
        temporary command vector used for control calcs
                  (see compass.io details on the generic linear controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_x_now(self) -> carmaWrap.obj_float:
        """
        temporary state vector used for control calcs
                  (see compass.io details on the generic linear controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def modal(self) -> bool:
        """
        modal flag
                  (see compass.io details on the generic linear controller)
 
        :type: bool
        """
    @property
    def n_iir_in(self) -> int:
        """
        number of iir inputs to use
                  (see compass.io details on the generic linear controller)
 
        :type: int
        """
    @property
    def n_iir_out(self) -> int:
        """
        number of iir outputs to use
                  (see compass.io details on the generic linear controller)
 
        :type: int
        """
    @property
    def n_modes(self) -> int:
        """
        number of modes in mode vector
                  (see compass.io details on the generic linear controller)
 
        :type: int
        """
    @property
    def n_slope_buffers(self) -> int:
        """
        number of slope vectors to store in buffer
                  (see compass.io details on the generic linear controller)
 
        :type: int
        """
    @property
    def n_state_buffers(self) -> int:
        """
        number of state vectors to store in buffer
                  (see compass.io details on the generic linear controller)
 
        :type: int
        """
    @property
    def n_states(self) -> int:
        """
        number of states in state vector
                  (see compass.io details on the generic linear controller)
 
        :type: int
        """
    @property
    def polc(self) -> bool:
        """
        polc flag
                  (see compass.io details on the generic linear controller)
 
        :type: bool
        """
    pass
class ControllerGENERICLINEAR_FU(Controller_FU):
    def set_iir_a(self, M: numpy.ndarray[numpy.float32], i: int) -> int: 
        """
        Set a single iir 'a' vector within list (combined with iir outputs)
 
        Args:
          M:  (np.array[ndim=1,dtype=np.float32]): Vector to be set
          i:  (int): index of list to slice vector
        """
    def set_iir_b(self, M: numpy.ndarray[numpy.float32], i: int) -> int: 
        """
        Set a single iir 'b' vector within list (combined with iir inputs)
 
        Args:
          M:  (np.array[ndim=1,dtype=np.float32]): Vector to be set
          i:  (int): index of list to slice vector
        """
    def set_matA(self, M: numpy.ndarray[numpy.float32], i: int) -> int: 
        """
        Set a single A matrix within the list of A matrices (state recursions)
 
        Args:
          M:  (np.array[ndim=2,dtype=np.float32]): Matrix to be sliced
          i:  (int): index of list to slice matrix
        """
    def set_matD(self, M: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set D matrix (interaction matrix)
 
        Args:
          M:  (np.array[ndim=2,dtype=np.float32]): Matrix to be set
        """
    def set_matF(self, M: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set F matrix (mode to actuator voltage projection)
 
        Args:
          M:  (np.array[ndim=2,dtype=np.float32]): Matrix to be set
        """
    def set_matK(self, M: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set K matrix (state to mode projection)
 
        Args:
          M:  (np.array[ndim=2,dtype=np.float32]): Matrix to be set
        """
    def set_matL(self, M: numpy.ndarray[numpy.float32], i: int) -> int: 
        """
        Set a single L matrix within the list of L matrices (innovations)
 
        Args:
          M:  (np.array[ndim=2,dtype=np.float32]): Matrix to be sliced
          i:  (int): index of list to slice matrix
        """
    def set_polc(self, polc: bool) -> int: 
        """
        Set the POLC flag
 
        Args:
          polc: (bool): POLC flag
        """
    @property
    def d_centroids(self) -> carmaWrap.obj_float:
        """
        centroid/slope vector
                  (see compass.io details on the generic linear controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_circular_coms(self) -> typing.List[carmaWrap.obj_float]:
        """
        circular command buffer
                  (see compass.io details on the generic linear controller)
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_circular_s(self) -> typing.List[carmaWrap.obj_float]:
        """
        circular slope buffer
                  (see compass.io details on the generic linear controller)
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_circular_u_in(self) -> typing.List[carmaWrap.obj_float]:
        """
        circular buffer of iir inputs
                  (see compass.io details on the generic linear controller)
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_circular_u_out(self) -> typing.List[carmaWrap.obj_float]:
        """
        circular buffer of iir outputs
                  (see compass.io details on the generic linear controller)
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_circular_x(self) -> typing.List[carmaWrap.obj_float]:
        """
        circular state buffer
                  (see compass.io details on the generic linear controller)
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_com(self) -> carmaWrap.obj_float:
        """
        command vector
                  (see compass.io details on the generic linear controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_iir_a(self) -> typing.List[carmaWrap.obj_float]:
        """
        List of iir coefficient vectors for outputs
                  (see compass.io details on the generic linear controller)
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_iir_b(self) -> typing.List[carmaWrap.obj_float]:
        """
        List of iir coefficient vectors for inputs
                  (see compass.io details on the generic linear controller)
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_imat(self) -> carmaWrap.obj_float:
        """
        D matrix, typically set to the interaction matrix
                  (see compass.io details on the generic linear controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_matA(self) -> typing.List[carmaWrap.obj_float]:
        """
        List of A matrices used for state recursion
                  (see compass.io details on the generic linear controller)
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_matD(self) -> carmaWrap.obj_float:
        """
        D matrix, typically set to the interaction matrix
                  (see compass.io details on the generic linear controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_matF(self) -> carmaWrap.obj_float:
        """
        F matrix, used to project from modes to actuator voltages
                  (see compass.io details on the generic linear controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_matK(self) -> carmaWrap.obj_float:
        """
        K matrix, used for projection from state to modes
                  (see compass.io details on the generic linear controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_matL(self) -> typing.List[carmaWrap.obj_float]:
        """
        List of L matrices used for innovation from measurements
                  (see compass.io details on the generic linear controller)
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_s_now(self) -> carmaWrap.obj_float:
        """
        temporary slope vector used for control calcs
                  (see compass.io details on the generic linear controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_u_now(self) -> carmaWrap.obj_float:
        """
        temporary command vector used for control calcs
                  (see compass.io details on the generic linear controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_x_now(self) -> carmaWrap.obj_float:
        """
        temporary state vector used for control calcs
                  (see compass.io details on the generic linear controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def modal(self) -> bool:
        """
        modal flag
                  (see compass.io details on the generic linear controller)
 
        :type: bool
        """
    @property
    def n_iir_in(self) -> int:
        """
        number of iir inputs to use
                  (see compass.io details on the generic linear controller)
 
        :type: int
        """
    @property
    def n_iir_out(self) -> int:
        """
        number of iir outputs to use
                  (see compass.io details on the generic linear controller)
 
        :type: int
        """
    @property
    def n_modes(self) -> int:
        """
        number of modes in mode vector
                  (see compass.io details on the generic linear controller)
 
        :type: int
        """
    @property
    def n_slope_buffers(self) -> int:
        """
        number of slope vectors to store in buffer
                  (see compass.io details on the generic linear controller)
 
        :type: int
        """
    @property
    def n_state_buffers(self) -> int:
        """
        number of state vectors to store in buffer
                  (see compass.io details on the generic linear controller)
 
        :type: int
        """
    @property
    def n_states(self) -> int:
        """
        number of states in state vector
                  (see compass.io details on the generic linear controller)
 
        :type: int
        """
    @property
    def polc(self) -> bool:
        """
        polc flag
                  (see compass.io details on the generic linear controller)
 
        :type: bool
        """
    pass
class ControllerGENERIC_FF(Controller_FF):
    def set_cmat(self, cmat: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the command matrix
 
        Args:
          cmat: (np.array[ndim=2,dtype=np.float32]): command matrix to set
        """
    def set_commandlaw(self, commandlaw: str) -> int: 
        """
        Set the command law to use
 
        Args:
          commandlaw: (str): command law "integrator", "modal_integrator" or "2matrices"
        """
    def set_decayFactor(self, decayFactor: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the decay factor vector
 
        Args:
          decayFactor: (np.array[ndim=1,dtype=np.float32]): decay factor
        """
    def set_imat(self, imat: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the interaction matrix
 
        Args:
          imat: (np.array[ndim=2,dtype=np.float32]): interaction matrix to set
        """
    def set_matE(self, E: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the E matrix
 
        Args:
          E: (np.array[ndim=2,dtype=np.float32]): E matrix to set
        """
    def set_modal_gains(self, mgain: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the controller modal gains
 
        Args:
          mgain: (np.array[ndim=1,dtype=np.float32]): modal gains to set
        """
    def set_polc(self, polc: bool) -> int: 
        """
        Set the polc flag
 
        Args:
          polc: (bool): polc flag
        """
    @property
    def command_law(self) -> str:
        """
        Command law currently used
 
        :type: str
        """
    @property
    def d_cmat(self) -> carmaWrap.obj_float:
        """
        Control matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_compbuff(self) -> carmaWrap.obj_float:
        """
        Computation buffer buffer
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_decayFactor(self) -> carmaWrap.obj_float:
        """
        decayFactor vector (see compass.io details on generic controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_err_ngpu(self) -> typing.List[carmaWrap.obj_float]:
        """
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_gain(self) -> carmaWrap.obj_float:
        """
        vector of modal gains
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_imat(self) -> carmaWrap.obj_float:
        """
        Control matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_matE(self) -> carmaWrap.obj_float:
        """
        E matrix (see compass.io details on generic controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def polc(self) -> bool:
        """
        POLC flag
 
        :type: bool
        """
    pass
class ControllerGENERIC_FU(Controller_FU):
    def set_cmat(self, cmat: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the command matrix
 
        Args:
          cmat: (np.array[ndim=2,dtype=np.float32]): command matrix to set
        """
    def set_commandlaw(self, commandlaw: str) -> int: 
        """
        Set the command law to use
 
        Args:
          commandlaw: (str): command law "integrator", "modal_integrator" or "2matrices"
        """
    def set_decayFactor(self, decayFactor: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the decay factor vector
 
        Args:
          decayFactor: (np.array[ndim=1,dtype=np.float32]): decay factor
        """
    def set_imat(self, imat: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the interaction matrix
 
        Args:
          imat: (np.array[ndim=2,dtype=np.float32]): interaction matrix to set
        """
    def set_matE(self, E: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the E matrix
 
        Args:
          E: (np.array[ndim=2,dtype=np.float32]): E matrix to set
        """
    def set_modal_gains(self, mgain: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the controller modal gains
 
        Args:
          mgain: (np.array[ndim=1,dtype=np.float32]): modal gains to set
        """
    def set_polc(self, polc: bool) -> int: 
        """
        Set the polc flag
 
        Args:
          polc: (bool): polc flag
        """
    @property
    def command_law(self) -> str:
        """
        Command law currently used
 
        :type: str
        """
    @property
    def d_cmat(self) -> carmaWrap.obj_float:
        """
        Control matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_compbuff(self) -> carmaWrap.obj_float:
        """
        Computation buffer buffer
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_decayFactor(self) -> carmaWrap.obj_float:
        """
        decayFactor vector (see compass.io details on generic controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_err_ngpu(self) -> typing.List[carmaWrap.obj_float]:
        """
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def d_gain(self) -> carmaWrap.obj_float:
        """
        vector of modal gains
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_imat(self) -> carmaWrap.obj_float:
        """
        Control matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_matE(self) -> carmaWrap.obj_float:
        """
        E matrix (see compass.io details on generic controller)
 
        :type: carmaWrap.obj_float
        """
    @property
    def polc(self) -> bool:
        """
        POLC flag
 
        :type: bool
        """
    pass
class ControllerGEO_FF(Controller_FF):
    def comp_dphi(self, source: Source, wfs_direction: bool) -> int: 
        """
        Get the pupil phase and remove piston before projection
 
        Args:
          source: (SutraSource): Phase source
 
          wfs_direction: (bool): Must be True if the source is a WFS GS
        """
    def init_proj_sparse(self, dms: Dms, indx_dm: numpy.ndarray[numpy.int32], unitpervolt: numpy.ndarray[numpy.float32], indx_pup: numpy.ndarray[numpy.int32], indx_mpup: numpy.ndarray[numpy.int32], roket: bool) -> int: 
        """
        Initializes projection matrices
 
        Args:
            dms: (SutraDms): SutraDms object
 
            indx_dm: (np.array[ndim=1,dtype=np.int64]): Indices of valid pixels of the pupil in the DM support
            unitpervolt: (np.array[ndim=1,dtype=np.float32]): Unit per volt of each DM
 
            indx_pup: (np.array[ndim=1,dtype=np.int64]): Indices of valid pixels of the small pupil
 
            indx_mpup: (np.array[ndim=1,dtype=np.int64]): Indices of valid pixels of the medium pupil
 
            roket: (bool): ROKET flag
        """
    def load_Btt(self, Btt_pzt: numpy.ndarray[numpy.float32], Btt_tt: numpy.ndarray[numpy.float32]) -> int: 
        """
        Load the Btt modal basis in the geo controller for ROKET
 
        Args:
            Btt_pzt: (np.array[ndim=2,dtype=np.float32]) : PZT DM component
 
            Btt_tt: (np.array[ndim=2,dtype=np.float32]) : TT mirror component
            
        """
    def load_mgain(self, mgain: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the controller modal gains
 
        Args:
          mgain: (np.array[ndim1,dtype=np.float32]): modal gains to set
        """
    @property
    def Nphi(self) -> int:
        """
        Number of points in the pupil
 
        :type: int
        """
    @property
    def Ntt(self) -> int:
        """
        Number of tip-tilt mirror
 
        :type: int
        """
    @property
    def d_IFsparse(self) -> carmaWrap.sparse_obj_double:
        """
        Influence functions in the pupil (sparse representation
 
        :type: carmaWrap.sparse_obj_double
        """
    @property
    def d_TT(self) -> carmaWrap.obj_float:
        """
        Tip-tilt influence functions
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_compdouble(self) -> carmaWrap.obj_double:
        """
        Buffer for computation (double precision)
 
        :type: carmaWrap.obj_double
        """
    @property
    def d_compfloat(self) -> carmaWrap.obj_float:
        """
        Buffer for computation (simple precision)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_gain(self) -> carmaWrap.obj_float:
        """
        vector of modal gains
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_geocov(self) -> carmaWrap.obj_float:
        """
        Geometric covariance matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_geocovTT(self) -> carmaWrap.obj_float:
        """
        Geometric covariance matrix for TT mirror
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_indx_mpup(self) -> carmaWrap.obj_int:
        """
        Indices of the valid pixels in mpupil
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_indx_pup(self) -> carmaWrap.obj_int:
        """
        Indices of the valid pixels in spupil
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_phi(self) -> carmaWrap.obj_double:
        """
        Phase in the pupil without piston (double)
 
        :type: carmaWrap.obj_double
        """
    @property
    def d_phif(self) -> carmaWrap.obj_float:
        """
        Phase in the pupil without piston (float)
 
        :type: carmaWrap.obj_float
        """
    pass
class ControllerGEO_FU(Controller_FU):
    def comp_dphi(self, source: Source, wfs_direction: bool) -> int: 
        """
        Get the pupil phase and remove piston before projection
 
        Args:
          source: (SutraSource): Phase source
 
          wfs_direction: (bool): Must be True if the source is a WFS GS
        """
    def init_proj_sparse(self, dms: Dms, indx_dm: numpy.ndarray[numpy.int32], unitpervolt: numpy.ndarray[numpy.float32], indx_pup: numpy.ndarray[numpy.int32], indx_mpup: numpy.ndarray[numpy.int32], roket: bool) -> int: 
        """
        Initializes projection matrices
 
        Args:
            dms: (SutraDms): SutraDms object
 
            indx_dm: (np.array[ndim=1,dtype=np.int64]): Indices of valid pixels of the pupil in the DM support
            unitpervolt: (np.array[ndim=1,dtype=np.float32]): Unit per volt of each DM
 
            indx_pup: (np.array[ndim=1,dtype=np.int64]): Indices of valid pixels of the small pupil
 
            indx_mpup: (np.array[ndim=1,dtype=np.int64]): Indices of valid pixels of the medium pupil
 
            roket: (bool): ROKET flag
        """
    def load_Btt(self, Btt_pzt: numpy.ndarray[numpy.float32], Btt_tt: numpy.ndarray[numpy.float32]) -> int: 
        """
        Load the Btt modal basis in the geo controller for ROKET
 
        Args:
            Btt_pzt: (np.array[ndim=2,dtype=np.float32]) : PZT DM component
 
            Btt_tt: (np.array[ndim=2,dtype=np.float32]) : TT mirror component
            
        """
    def load_mgain(self, mgain: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the controller modal gains
 
        Args:
          mgain: (np.array[ndim1,dtype=np.float32]): modal gains to set
        """
    @property
    def Nphi(self) -> int:
        """
        Number of points in the pupil
 
        :type: int
        """
    @property
    def Ntt(self) -> int:
        """
        Number of tip-tilt mirror
 
        :type: int
        """
    @property
    def d_IFsparse(self) -> carmaWrap.sparse_obj_double:
        """
        Influence functions in the pupil (sparse representation
 
        :type: carmaWrap.sparse_obj_double
        """
    @property
    def d_TT(self) -> carmaWrap.obj_float:
        """
        Tip-tilt influence functions
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_compdouble(self) -> carmaWrap.obj_double:
        """
        Buffer for computation (double precision)
 
        :type: carmaWrap.obj_double
        """
    @property
    def d_compfloat(self) -> carmaWrap.obj_float:
        """
        Buffer for computation (simple precision)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_gain(self) -> carmaWrap.obj_float:
        """
        vector of modal gains
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_geocov(self) -> carmaWrap.obj_float:
        """
        Geometric covariance matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_geocovTT(self) -> carmaWrap.obj_float:
        """
        Geometric covariance matrix for TT mirror
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_indx_mpup(self) -> carmaWrap.obj_int:
        """
        Indices of the valid pixels in mpupil
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_indx_pup(self) -> carmaWrap.obj_int:
        """
        Indices of the valid pixels in spupil
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_phi(self) -> carmaWrap.obj_double:
        """
        Phase in the pupil without piston (double)
 
        :type: carmaWrap.obj_double
        """
    @property
    def d_phif(self) -> carmaWrap.obj_float:
        """
        Phase in the pupil without piston (float)
 
        :type: carmaWrap.obj_float
        """
    pass
class ControllerLS_FF(Controller_FF):
    def build_cmat(self, nfilt: int) -> int: 
        """
        Computes the command matrix after imat SVD
 
        Args:
            nfilt: (int): number of modes to filter
        """
    def init_modalOpti(self, nmodes: int, nrec: int, M2V: numpy.ndarray[numpy.float32], gmin: float, gmax: float, ngain: int, Fs: float) -> int: 
        """
        Initialize modal optimization control
 
        Args:
          nmodes: (int): number of modes to control
 
          nrec: (int): number of open loop slopes to consider
 
          M2V: (np.array[ndim=2,dtype=np.float32]): Modes to Volt matrix
 
          gmin: (float): Minimal gain
 
          gmax: (float): Maximal gain
 
          ngain: (int): Number of gain values to test between gmin and gmax
 
          Fs: (float): Sampling frequency [Hz]
        """
    def loadopen_loopSlp(self, slopes: numpy.ndarray[numpy.float32]) -> int: 
        """
        Load recorded open loop slopes for modal optimization initialization
 
        Args:
          slopes: (np.array[ndim=2,dtype=np.float32]): Open loop slopes
        """
    def modalControlOptimization(self) -> int: 
        """
        TODO: docstring
        """
    def set_cmat(self, cmat: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the command matrix
 
        Args:
          cmat: (np.array[ndim=2,dtype=np.float32]): command matrix to set
        """
    def set_imat(self, imat: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the interaction matrix
 
        Args:
          imat: (np.array[ndim=2,dtype=np.float32]): interaction matrix to set
        """
    def set_modal_gains(self, mgain: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the controller modal gains
 
        Args:
          mgain: (np.array[ndim1,dtype=np.float32]): modal gains to set
        """
    def svdec_imat(self) -> int: 
        """
        Performs interaction matrix SVD
        """
    @property
    def Fs(self) -> float:
        """
        Sampling frequency for modal optimization
 
        :type: float
        """
    @property
    def cpt_rec(self) -> int:
        """
        Counter for modal gains refresh
 
        :type: int
        """
    @property
    def d_Hcor(self) -> carmaWrap.obj_float:
        """
        Transfer function for modal optimization
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_M2V(self) -> carmaWrap.obj_float:
        """
        Modes to volt matrix for modal optimization
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_S2M(self) -> carmaWrap.obj_float:
        """
        Slopes to modes matrix for modal optimization
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_U(self) -> carmaWrap.obj_float:
        """
        Eigen modes of the imat
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_cenbuff(self) -> carmaWrap.obj_float:
        """
        Centroids circular buffer
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_cmat(self) -> carmaWrap.obj_float:
        """
        Control matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_compbuff(self) -> carmaWrap.obj_float:
        """
        Buffer for POLC computation
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_compbuff2(self) -> carmaWrap.obj_float:
        """
        Buffer for POLC computation
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_eigenvals(self) -> carmaWrap.obj_float:
        """
        Eigen values of the imat
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_err(self) -> carmaWrap.obj_float:
        """
        Current increment on the command
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_gain(self) -> carmaWrap.obj_float:
        """
        vector of modal gains
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_imat(self) -> carmaWrap.obj_float:
        """
        Interaction matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_slpol(self) -> carmaWrap.obj_float:
        """
        Open loop slopes for modal optimization
 
        :type: carmaWrap.obj_float
        """
    @property
    def gmax(self) -> float:
        """
        Maximal gain for modal optimization
 
        :type: float
        """
    @property
    def gmin(self) -> float:
        """
        Minimal gain for modal optimization
 
        :type: float
        """
    @property
    def is_modopti(self) -> int:
        """
        Falg for modal optimization
 
        :type: int
        """
    @property
    def ngain(self) -> int:
        """
        Number of gain values to test between gmin and gmax for modal optimization
 
        :type: int
        """
    @property
    def nmodes(self) -> int:
        """
        Number of modes for modal optimization
 
        :type: int
        """
    @property
    def nrec(self) -> int:
        """
        Number of open loop slopes to take for modal optimization
 
        :type: int
        """
    pass
class ControllerLS_FU(Controller_FU):
    def build_cmat(self, nfilt: int) -> int: 
        """
        Computes the command matrix after imat SVD
 
        Args:
            nfilt: (int): number of modes to filter
        """
    def init_modalOpti(self, nmodes: int, nrec: int, M2V: numpy.ndarray[numpy.float32], gmin: float, gmax: float, ngain: int, Fs: float) -> int: 
        """
        Initialize modal optimization control
 
        Args:
          nmodes: (int): number of modes to control
 
          nrec: (int): number of open loop slopes to consider
 
          M2V: (np.array[ndim=2,dtype=np.float32]): Modes to Volt matrix
 
          gmin: (float): Minimal gain
 
          gmax: (float): Maximal gain
 
          ngain: (int): Number of gain values to test between gmin and gmax
 
          Fs: (float): Sampling frequency [Hz]
        """
    def loadopen_loopSlp(self, slopes: numpy.ndarray[numpy.float32]) -> int: 
        """
        Load recorded open loop slopes for modal optimization initialization
 
        Args:
          slopes: (np.array[ndim=2,dtype=np.float32]): Open loop slopes
        """
    def modalControlOptimization(self) -> int: 
        """
        TODO: docstring
        """
    def set_cmat(self, cmat: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the command matrix
 
        Args:
          cmat: (np.array[ndim=2,dtype=np.float32]): command matrix to set
        """
    def set_imat(self, imat: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the interaction matrix
 
        Args:
          imat: (np.array[ndim=2,dtype=np.float32]): interaction matrix to set
        """
    def set_modal_gains(self, mgain: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the controller modal gains
 
        Args:
          mgain: (np.array[ndim1,dtype=np.float32]): modal gains to set
        """
    def svdec_imat(self) -> int: 
        """
        Performs interaction matrix SVD
        """
    @property
    def Fs(self) -> float:
        """
        Sampling frequency for modal optimization
 
        :type: float
        """
    @property
    def cpt_rec(self) -> int:
        """
        Counter for modal gains refresh
 
        :type: int
        """
    @property
    def d_Hcor(self) -> carmaWrap.obj_float:
        """
        Transfer function for modal optimization
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_M2V(self) -> carmaWrap.obj_float:
        """
        Modes to volt matrix for modal optimization
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_S2M(self) -> carmaWrap.obj_float:
        """
        Slopes to modes matrix for modal optimization
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_U(self) -> carmaWrap.obj_float:
        """
        Eigen modes of the imat
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_cenbuff(self) -> carmaWrap.obj_float:
        """
        Centroids circular buffer
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_cmat(self) -> carmaWrap.obj_float:
        """
        Control matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_compbuff(self) -> carmaWrap.obj_float:
        """
        Buffer for POLC computation
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_compbuff2(self) -> carmaWrap.obj_float:
        """
        Buffer for POLC computation
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_eigenvals(self) -> carmaWrap.obj_float:
        """
        Eigen values of the imat
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_err(self) -> carmaWrap.obj_float:
        """
        Current increment on the command
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_gain(self) -> carmaWrap.obj_float:
        """
        vector of modal gains
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_imat(self) -> carmaWrap.obj_float:
        """
        Interaction matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_slpol(self) -> carmaWrap.obj_float:
        """
        Open loop slopes for modal optimization
 
        :type: carmaWrap.obj_float
        """
    @property
    def gmax(self) -> float:
        """
        Maximal gain for modal optimization
 
        :type: float
        """
    @property
    def gmin(self) -> float:
        """
        Minimal gain for modal optimization
 
        :type: float
        """
    @property
    def is_modopti(self) -> int:
        """
        Falg for modal optimization
 
        :type: int
        """
    @property
    def ngain(self) -> int:
        """
        Number of gain values to test between gmin and gmax for modal optimization
 
        :type: int
        """
    @property
    def nmodes(self) -> int:
        """
        Number of modes for modal optimization
 
        :type: int
        """
    @property
    def nrec(self) -> int:
        """
        Number of open loop slopes to take for modal optimization
 
        :type: int
        """
    pass
class ControllerMV_FF(Controller_FF):
    def build_cmat(self, cond: float) -> int: 
        """
        Computes the command matrix
 
        Args:
            cond: (float): Conditioning number for inversion
        """
    def compute_Cmm(self, atmos: Atmos, sensors: Sensors, LO: numpy.ndarray[numpy.float64], Cn2: numpy.ndarray[numpy.float64], alphaX: numpy.ndarray[numpy.float64], alphaY: numpy.ndarray[numpy.float64], diamTel: float, cobs: float) -> int: 
        """
        Compute the Cmm matrix
 
        Args:
            atmos : (SutraAtmos): SutraAtmos object
 
            sensors: (SutraSensors): SutraSensors object
 
            LO: (np.array[ndim=1,dtype=np.float64]): outer scale of each layer
 
            Cn2: (np.array[ndim=1,dtype=np.float64]): Cn2 profile
 
            alphaX: (np.array[ndim=1,dtype=np.float64]): X position of each WFS
 
            alphaY: (np.array[ndim=1,dtype=np.float64]): Y position of each WFS
 
            diamTel: (double): Telescope diameter
 
            cobs: (double): Central obstruction ratio
        """
    def compute_Cphim(self, atmos: Atmos, sensors: Sensors, dms: Dms, LO: numpy.ndarray[numpy.float64], Cn2: numpy.ndarray[numpy.float64], alphaX: numpy.ndarray[numpy.float64], alphaY: numpy.ndarray[numpy.float64], X: numpy.ndarray[numpy.float64], Y: numpy.ndarray[numpy.float64], xactu: numpy.ndarray[numpy.float64], yactu: numpy.ndarray[numpy.float64], diamTel: float, k2: numpy.ndarray[numpy.float64], NlayerDm: numpy.ndarray[numpy.int64], indLayerDm: numpy.ndarray[numpy.int64], FoV: float, pitch: numpy.ndarray[numpy.float64], alt_dm: numpy.ndarray[numpy.float64]) -> int: 
        """
        Compute the Cphim matrix
 
        Args:
            atmos : (SutraAtmos): SutraAtmos object
 
            sensors: (SutraSensors): SutraSensors object
 
            dms: (SutraDms): SutraDms object
 
            LO: (np.array[ndim=1,dtype=np.float64]): outer scale of each layer
 
            Cn2: (np.array[ndim=1,dtype=np.float64]): Cn2 profile
 
            alphaX: (np.array[ndim=1,dtype=np.float64]): X position of each WFS
 
            alphaY: (np.array[ndim=1,dtype=np.float64]): Y position of each WFS
 
            X: (np.array[ndim=1,dtype=np.float64]): X position of each subaperture
 
            Y: (np.array[ndim=1,dtype=np.float64]): Y position of each subaperture
 
            xactu: (np.array[ndim=1,dtype=np.float64]): X position of each actuators
 
            yactu: (np.array[ndim=1,dtype=np.float64]): Y position of each actuators
 
            diamTel: (double): Telescope diameter
 
            k2: (np.array[ndim=1,dtype=np.float64]): scales
 
            NlayerDm: (np.array[ndim=1,dtype=np.int64]): Number of layers handled by each DM
 
            indLayerDm: (np.array[ndim=1,dtype=np.int64]): Indices of layers handled by each DM
 
            FoV: (double): Field of view
 
            pitch: (np.array[ndim=1,dtype=np.int64]): Pitch of each DM
 
            alt_dm: (np.array[ndim=1,dtype=np.int64]): Altitude of each DM
        """
    def filter_cmat(self, cond: float) -> int: 
        """
        Filter command matrix from TT
 
        Args:
            cond: (float): TODO: docstring
        """
    def filter_cphim(self, F: numpy.ndarray[numpy.float32], Nact: numpy.ndarray[numpy.float32]) -> int: 
        """
        Filter Cphim from piston and apply coupling
 
        Args:
            F: (np.array[ndim=2,dtype=np.float32]): Piston filter matrix
 
            Nact: (np.array[ndim=2,dtype=np.float32]): Coupling matrix
        """
    def load_noisemat(self, noisemat: numpy.ndarray[numpy.float32]) -> int: 
        """
        Load the noise covariance matrix
 
        Args:
            noisemat: (float): noise covariance marix
        """
    def set_cmat(self, cmat: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the command matrix
 
        Args:
          cmat: (np.array[ndim=2,dtype=np.float32]): command matrix to set
        """
    def set_imat(self, imat: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the interaction matrix
 
        Args:
          imat: (np.array[ndim=2,dtype=np.float32]): command matrix to set
        """
    def set_modal_gains(self, mgain: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the controller modal gains
 
        Args:
          mgain: (np.array[ndim1,dtype=np.float32]): modal gains to set
        """
    @property
    def d_Cmm(self) -> carmaWrap.obj_float:
        """
        Slope covariance matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_Cphim(self) -> carmaWrap.obj_float:
        """
        Actuators-Slopes covariance marix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_KLbasis(self) -> carmaWrap.obj_float:
        """
        KL basis
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_cenbuff(self) -> carmaWrap.obj_float:
        """
        Centroids circular buffer
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_cmat(self) -> carmaWrap.obj_float:
        """
        Control matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_com1(self) -> carmaWrap.obj_float:
        """
        Commands at iteration k-1 (for POLC)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_covmat(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_err(self) -> carmaWrap.obj_float:
        """
        Increment error
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_gain(self) -> carmaWrap.obj_float:
        """
        vector of modal gains
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_imat(self) -> carmaWrap.obj_float:
        """
        Interaction matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_noisemat(self) -> carmaWrap.obj_float:
        """
        Noise on WFS measurements matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_olmeas(self) -> carmaWrap.obj_float:
        """
        Reconstructed open loop measurement
 
        :type: carmaWrap.obj_float
        """
    @property
    def h_Cmmeigenvals(self) -> carmaWrap.host_obj_float:
        """
        Cmm eigenvalues
 
        :type: carmaWrap.host_obj_float
        """
    @property
    def h_eigenvals(self) -> carmaWrap.host_obj_float:
        """
        Eigen values
 
        :type: carmaWrap.host_obj_float
        """
    pass
class ControllerMV_FU(Controller_FU):
    def build_cmat(self, cond: float) -> int: 
        """
        Computes the command matrix
 
        Args:
            cond: (float): Conditioning number for inversion
        """
    def compute_Cmm(self, atmos: Atmos, sensors: Sensors, LO: numpy.ndarray[numpy.float64], Cn2: numpy.ndarray[numpy.float64], alphaX: numpy.ndarray[numpy.float64], alphaY: numpy.ndarray[numpy.float64], diamTel: float, cobs: float) -> int: 
        """
        Compute the Cmm matrix
 
        Args:
            atmos : (SutraAtmos): SutraAtmos object
 
            sensors: (SutraSensors): SutraSensors object
 
            LO: (np.array[ndim=1,dtype=np.float64]): outer scale of each layer
 
            Cn2: (np.array[ndim=1,dtype=np.float64]): Cn2 profile
 
            alphaX: (np.array[ndim=1,dtype=np.float64]): X position of each WFS
 
            alphaY: (np.array[ndim=1,dtype=np.float64]): Y position of each WFS
 
            diamTel: (double): Telescope diameter
 
            cobs: (double): Central obstruction ratio
        """
    def compute_Cphim(self, atmos: Atmos, sensors: Sensors, dms: Dms, LO: numpy.ndarray[numpy.float64], Cn2: numpy.ndarray[numpy.float64], alphaX: numpy.ndarray[numpy.float64], alphaY: numpy.ndarray[numpy.float64], X: numpy.ndarray[numpy.float64], Y: numpy.ndarray[numpy.float64], xactu: numpy.ndarray[numpy.float64], yactu: numpy.ndarray[numpy.float64], diamTel: float, k2: numpy.ndarray[numpy.float64], NlayerDm: numpy.ndarray[numpy.int64], indLayerDm: numpy.ndarray[numpy.int64], FoV: float, pitch: numpy.ndarray[numpy.float64], alt_dm: numpy.ndarray[numpy.float64]) -> int: 
        """
        Compute the Cphim matrix
 
        Args:
            atmos : (SutraAtmos): SutraAtmos object
 
            sensors: (SutraSensors): SutraSensors object
 
            dms: (SutraDms): SutraDms object
 
            LO: (np.array[ndim=1,dtype=np.float64]): outer scale of each layer
 
            Cn2: (np.array[ndim=1,dtype=np.float64]): Cn2 profile
 
            alphaX: (np.array[ndim=1,dtype=np.float64]): X position of each WFS
 
            alphaY: (np.array[ndim=1,dtype=np.float64]): Y position of each WFS
 
            X: (np.array[ndim=1,dtype=np.float64]): X position of each subaperture
 
            Y: (np.array[ndim=1,dtype=np.float64]): Y position of each subaperture
 
            xactu: (np.array[ndim=1,dtype=np.float64]): X position of each actuators
 
            yactu: (np.array[ndim=1,dtype=np.float64]): Y position of each actuators
 
            diamTel: (double): Telescope diameter
 
            k2: (np.array[ndim=1,dtype=np.float64]): scales
 
            NlayerDm: (np.array[ndim=1,dtype=np.int64]): Number of layers handled by each DM
 
            indLayerDm: (np.array[ndim=1,dtype=np.int64]): Indices of layers handled by each DM
 
            FoV: (double): Field of view
 
            pitch: (np.array[ndim=1,dtype=np.int64]): Pitch of each DM
 
            alt_dm: (np.array[ndim=1,dtype=np.int64]): Altitude of each DM
        """
    def filter_cmat(self, cond: float) -> int: 
        """
        Filter command matrix from TT
 
        Args:
            cond: (float): TODO: docstring
        """
    def filter_cphim(self, F: numpy.ndarray[numpy.float32], Nact: numpy.ndarray[numpy.float32]) -> int: 
        """
        Filter Cphim from piston and apply coupling
 
        Args:
            F: (np.array[ndim=2,dtype=np.float32]): Piston filter matrix
 
            Nact: (np.array[ndim=2,dtype=np.float32]): Coupling matrix
        """
    def load_noisemat(self, noisemat: numpy.ndarray[numpy.float32]) -> int: 
        """
        Load the noise covariance matrix
 
        Args:
            noisemat: (float): noise covariance marix
        """
    def set_cmat(self, cmat: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the command matrix
 
        Args:
          cmat: (np.array[ndim=2,dtype=np.float32]): command matrix to set
        """
    def set_imat(self, imat: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the interaction matrix
 
        Args:
          imat: (np.array[ndim=2,dtype=np.float32]): command matrix to set
        """
    def set_modal_gains(self, mgain: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the controller modal gains
 
        Args:
          mgain: (np.array[ndim1,dtype=np.float32]): modal gains to set
        """
    @property
    def d_Cmm(self) -> carmaWrap.obj_float:
        """
        Slope covariance matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_Cphim(self) -> carmaWrap.obj_float:
        """
        Actuators-Slopes covariance marix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_KLbasis(self) -> carmaWrap.obj_float:
        """
        KL basis
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_cenbuff(self) -> carmaWrap.obj_float:
        """
        Centroids circular buffer
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_cmat(self) -> carmaWrap.obj_float:
        """
        Control matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_com1(self) -> carmaWrap.obj_float:
        """
        Commands at iteration k-1 (for POLC)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_covmat(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_err(self) -> carmaWrap.obj_float:
        """
        Increment error
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_gain(self) -> carmaWrap.obj_float:
        """
        vector of modal gains
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_imat(self) -> carmaWrap.obj_float:
        """
        Interaction matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_noisemat(self) -> carmaWrap.obj_float:
        """
        Noise on WFS measurements matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_olmeas(self) -> carmaWrap.obj_float:
        """
        Reconstructed open loop measurement
 
        :type: carmaWrap.obj_float
        """
    @property
    def h_Cmmeigenvals(self) -> carmaWrap.host_obj_float:
        """
        Cmm eigenvalues
 
        :type: carmaWrap.host_obj_float
        """
    @property
    def h_eigenvals(self) -> carmaWrap.host_obj_float:
        """
        Eigen values
 
        :type: carmaWrap.host_obj_float
        """
    pass
class ControllerCURED_FF(Controller_FF):
    def init_cured(self, nxsub: int, isvalid: numpy.ndarray[numpy.int32], ndivs: int, tt: int) -> int: 
        """
        Initialize CURED
 
        Args:
            nxsub: (int): TODO: docstring
 
            isvalid:
 
            ndivs: (int):
 
            tt: (int):
        """
    @property
    def d_cenbuff(self) -> carmaWrap.obj_float:
        """
        Centroids circular buffer
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_err(self) -> carmaWrap.obj_float:
        """
        Increment error
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_imat(self) -> carmaWrap.obj_float:
        """
        Interaction matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def h_centroids(self) -> carmaWrap.host_obj_float:
        """
        Centroids
 
        :type: carmaWrap.host_obj_float
        """
    @property
    def h_err(self) -> carmaWrap.host_obj_float:
        """
        Increment error
 
        :type: carmaWrap.host_obj_float
        """
    @property
    def ndivs(self) -> int:
        """
        Number of subdivision levels
 
        :type: int
        """
    @property
    def tt_flag(self) -> bool:
        """
        Flag to separate TT
 
        :type: bool
        """
    pass
class ControllerCURED_FU(Controller_FU):
    def init_cured(self, nxsub: int, isvalid: numpy.ndarray[numpy.int32], ndivs: int, tt: int) -> int: 
        """
        Initialize CURED
 
        Args:
            nxsub: (int): TODO: docstring
 
            isvalid:
 
            ndivs: (int):
 
            tt: (int):
        """
    @property
    def d_cenbuff(self) -> carmaWrap.obj_float:
        """
        Centroids circular buffer
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_err(self) -> carmaWrap.obj_float:
        """
        Increment error
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_imat(self) -> carmaWrap.obj_float:
        """
        Interaction matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def h_centroids(self) -> carmaWrap.host_obj_float:
        """
        Centroids
 
        :type: carmaWrap.host_obj_float
        """
    @property
    def h_err(self) -> carmaWrap.host_obj_float:
        """
        Increment error
 
        :type: carmaWrap.host_obj_float
        """
    @property
    def ndivs(self) -> int:
        """
        Number of subdivision levels
 
        :type: int
        """
    @property
    def tt_flag(self) -> bool:
        """
        Flag to separate TT
 
        :type: bool
        """
    pass
class Coronagraph():
    def compute_electric_field(self, arg0: int) -> int: 
        """
        Computes the electric field from the specified wavelength
 
        Args:
            wavelengthIndex: (int): Index of the wavelength to use 
        """
    def compute_image(self, accumulate: bool = True) -> int: 
        """
        Computes the coronagraphic image from the source phase screen
 
        Args:
            accumulate: (bool, optionnal): If True (default), accumulate the short exposure image in the long exposure one
        """
    def compute_psf(self, accumulate: bool = True) -> int: 
        """
        Computes the psf from the source phase screen
 
        Args:
            accumulate: (bool, optionnal): If True (default), accumulate the short exposure psf in the long exposure one
        """
    def reset(self) -> int: 
        """
        Reset long exposure image and counter
        """
    def set_amplitude(self, arg0: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the electric field amplitude
 
        Args:
            amplitude: (np.ndarray[ndim=3, dtype=np.float32]): electric field amplitude
        """
    @property
    def amplitude(self) -> typing.List[carmaWrap.obj_float]:
        """
        Electric field amplitude in the pupil
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def cntImg(self) -> int:
        """
        Accumulation counter of coronagraphic images
 
        :type: int
        """
    @property
    def cntPsf(self) -> int:
        """
        Accumulation counter of psf
 
        :type: int
        """
    @property
    def d_complex_image(self) -> carmaWrap.obj_float_complex:
        """
        Complex coronagraphic image
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_electric_field(self) -> carmaWrap.obj_float_complex:
        """
        Electric field in the pupil
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_image_le(self) -> carmaWrap.obj_float:
        """
        Long exposure coronagraphic image
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_image_se(self) -> carmaWrap.obj_float:
        """
        Short exposure coronagraphic image
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_psf_le(self) -> carmaWrap.obj_float:
        """
        Long exposure coronagraphic psf
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_psf_se(self) -> carmaWrap.obj_float:
        """
        Short exposure coronagraphic psf
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_pupil(self) -> carmaWrap.obj_float:
        """
        Telescope pupil
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_source(self) -> Source:
        """
        SutraSource used as OPD input
 
        :type: Source
        """
    @property
    def device(self) -> int:
        """
        GPU device index
 
        :type: int
        """
    @property
    def imageDimx(self) -> int:
        """
        Coronagraphic image dimension along X-axis
 
        :type: int
        """
    @property
    def imageDimy(self) -> int:
        """
        Coronagraphic image dimension along Y-axis
 
        :type: int
        """
    @property
    def pupDimx(self) -> int:
        """
        Pupil dimension along X-axis
 
        :type: int
        """
    @property
    def pupDimy(self) -> int:
        """
        Pupil dimension along Y-axis
 
        :type: int
        """
    @property
    def type(self) -> str:
        """
        Coronagraph type
 
        :type: str
        """
    @property
    def wavelength(self) -> typing.List[float]:
        """
        Vector of wavelength used to compute coronagraphic image
 
        :type: typing.List[float]
        """
    pass
class Dm():
    def __str__(self) -> str: ...
    def comp_oneactu(self, nactu: int, ampli: float) -> int: 
        """
        Push the specified actuator and computes the corresponding DM shape
 
        Args:
            nactu: (int): Actuator index
 
            ampli: (float): Volt to apply to this actuator
          
        """
    @typing.overload
    def comp_shape(self) -> int: 
        """
            Compute the DM shape according to commands d_com
          
 
 
        Compute the DM shape according to given commands
 
        Args:
            com: (np.ndarray[ndim=1,dtype=np.float32_t]): commands to apply
 
          
 
 
        Compute the DM shape according to given commands
 
        Args:
            com: (np.ndarray[ndim=1,dtype=np.uint16_t]): commands to apply
 
          
        """
    @typing.overload
    def comp_shape(self, com: numpy.ndarray[numpy.float32]) -> int: ...
    @typing.overload
    def comp_shape(self, com: numpy.ndarray[numpy.uint16]) -> int: ...
    def compute_KLbasis(self, xpos: numpy.ndarray[numpy.float32], ypos: numpy.ndarray[numpy.float32], indx_pup: numpy.ndarray[numpy.int32], dim: int, norm: float, ampli: float) -> int: 
        """
        Computes the KL to volt matrix by double diagonalisation (cf. Gendron thesis)
            - compute the phase covariance matrix on the actuators using Kolmogorov
            - compute the geometric covariance matrix
            - double diagonalisation to obtain KL basis
 
        Args:
            xpos: (np.ndarray[ndim=1,dtype=np.float32_t]) : x-position of actuators
 
            ypos: (np.ndarray[ndim=1,dtype=np.float32_t]) : y-position of actuators
 
            indx_pup: (np.ndarray[ndim=1,dtype=np.int32_t]) : indices of pupil points
 
            dim: (long) : number of points in the pupil
 
            norm: (float) : normalization factor
 
            ampli: (float) : amplitude
          
        """
    def kl_loadarrays(self, rabas: numpy.ndarray[numpy.float32], azbas: numpy.ndarray[numpy.float32], ords: numpy.ndarray[numpy.int32], cr: numpy.ndarray[numpy.float32], cp: numpy.ndarray[numpy.float32]) -> int: 
        """
        Load all the arrays computed during the initialization for a kl DM in a SutraDm object
 
        Args:
            rabas: (np.ndarray[ndim=1,dtype=np.float32_t]): TODO docstring
 
            azbas: (np.ndarray[ndim=1,dtype=np.float32_t]):
 
            ords: (np.ndarray[ndim=1,dtype=np.int32_t]):
 
            cr: (np.ndarray[ndim=1,dtype=np.float32_t]):
 
            cp: (np.ndarray[ndim=1,dtype=np.float32_t]):
            
        """
    def pzt_loadarrays(self, influ: numpy.ndarray[numpy.float32], influpos: numpy.ndarray[numpy.int32], npoints: numpy.ndarray[numpy.int32], istart: numpy.ndarray[numpy.int32], xoff: numpy.ndarray[numpy.int32], yoff: numpy.ndarray[numpy.int32]) -> int: 
        """
        Load all the arrays computed during the initialization for a pzt DM in a SutraDm object
 
        Args:
            influ: (np.ndarray[ndim=3,dtype=np.float32_t]) : influence functions cube
 
            influ2:
 
            influ3:
 
            influpos: (np.ndarray[ndim=1,dtype=np.int32_t]) : positions of the IF in the pupil
 
            influpos2:
 
            npoints: (np.ndarray[ndim=1,dtype=np.int32_t]) : for each pixel on the DM screen, the number of IF which impact on this pixel
 
            istart: (np.ndarray[ndim=1,dtype=np.int32_t]) :
 
            xoff: (np.ndarray[ndim=1,dtype=np.int32_t]) : x-offset for shape computation
 
            yoff: (np.ndarray[ndim=1,dtype=np.int32_t]) : y-offset or shape computation
            
        """
    def reset_shape(self) -> int: 
        """
        Reset the DM shape to zeros (flat)
        """
    def set_com(self, com: numpy.ndarray[numpy.float32], shape_dm: bool = True) -> None: 
        """
        Set the command vector of a SutraDm, and computes the DM shape
 
        Args:
            com: (np.array(ndim=1, dtype=np.float32)): Command vector
 
            shape_dm: (bool): (optionnal, default=True)  Computes the DM shape
          
        """
    def set_registration(self, dx: float, dy: float, theta: float, G: float) -> int: 
        """
        Set the registration parameters : dx, dy, theta and G
 
        Args:
            dx: (float): X axis misregistration [pixels]
 
            dy: (float): Y axis misregistration [pixels]
 
            theta: (float): Rotation angle misregistration [radians]
 
            G: (float): Magnification factor
          
        """
    def tt_loadarrays(self, influ: numpy.ndarray[numpy.float32]) -> int: 
        """
        Load all the arrays computed during the initialization for a tt DM in a SutraDm object
 
        Args:
            influ: (np.ndarray[ndim=3,dtype=np.float32_t]) : influence functions cube
            
        """
    @property
    def G(self) -> float:
        """
        Magnification factor registration in pixels
 
        :type: float
        """
    @property
    def altitude(self) -> float:
        """
        DM conjugaison altitude
 
        :type: float
        """
    @property
    def d_KLbasis(self) -> carmaWrap.obj_float:
        """
        KL to volts matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_com(self) -> carmaWrap.obj_float:
        """
        Current commands of the DM
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_influ(self) -> carmaWrap.obj_float:
        """
        Cube of influence functions
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_influpos(self) -> carmaWrap.obj_int:
        """
        Influence functions positions in the pupil
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_istart(self) -> carmaWrap.obj_int:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_kl(self) -> SutraKL:
        """
        SutraKL DM
 
        :type: SutraKL
        """
    @property
    def d_npoints(self) -> carmaWrap.obj_int:
        """
        Number of IF that impact each pixel of the pupil
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_shape(self) -> carmaWrap.obj_float:
        """
        DM shape
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_xoff(self) -> carmaWrap.obj_int:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_yoff(self) -> carmaWrap.obj_int:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_int
        """
    @property
    def device(self) -> int:
        """
        Device index
 
        :type: int
        """
    @property
    def dim(self) -> int:
        """
        DM support size
 
        :type: int
        """
    @property
    def dx(self) -> float:
        """
        X registration in pixels
 
        :type: float
        """
    @property
    def dy(self) -> float:
        """
        Y registration in pixels
 
        :type: float
        """
    @property
    def influsize(self) -> int:
        """
        Influence function support size
 
        :type: int
        """
    @property
    def nactus(self) -> int:
        """
        Number of actuators
 
        :type: int
        """
    @property
    def push4imat(self) -> float:
        """
        Voltage to apply for imat computation
 
        :type: float
        """
    @property
    def thetaML(self) -> float:
        """
        thetaML registration in radians
 
        :type: float
        """
    @property
    def type(self) -> str:
        """
        DM type
 
        :type: str
        """
    pass
class Dms():
    def __init__(self) -> None: 
        """
        Create a void DMS object
        """
    def __str__(self) -> str: ...
    @typing.overload
    def add_dm(self, context: carmaWrap.context, type: str, alt: float, dim: int, nactus: int, influsize: int, ninflupos: int, n_npoints: int, push4imat: float, nord: int, dx: float, dy: float, thetaML: float, G: float, device: int) -> int: 
        """
        Add a SutraDm in the SutraDms vector
 
        Args:
          context: (CarmaContext) : current carma context
 
          type: (str): DM type ("pzt", "kl", or "tt")
 
          alt: (float): Conjugaison altitude in meters
 
          dim: (long): Support dimension
 
          nactus: (long): Number of actuators
 
          influsize: (long): Influenction function support size
 
          ninflupos: (long): Size of _influpos array
 
          n_npoints: (long): Size of _ninflu array
 
          push4imat: (float): Voltage to apply for imat computation
 
          nord: (long): Number of radial order for kl dm (0 if not kl)
 
          dx: (float): X axis misregistration [pixels]
 
          dy: (float): Y axis misregistration [pixels]
 
          theta: (float): Rotation angle misregistration [radians]
 
          G: (float): Magnification factor
 
          device: (int): Device index
          
 
 
        Add a SutraDm in the SutraDms vector
 
        Args:
          context: (CarmaContext) : current carma context
 
          type: (str): DM type ("pzt", "kl", or "tt")
 
          alt: (float): Conjugaison altitude in meters
 
          dim: (long): Support dimension
 
          nactus: (long): Number of actuators
 
          influsize: (long): Influenction function support size
 
          ninflupos: (long): Size of _influpos array
 
          n_npoints: (long): Size of _ninflu array
 
          push4imat: (float): Voltage to apply for imat computation
 
          nord: (long): Number of radial order for kl dm (0 if not kl)
 
          device: (int): Device index
            
        """
    @typing.overload
    def add_dm(self, context: carmaWrap.context, type: str, alt: float, dim: int, nactus: int, influsize: int, ninflupos: int, n_npoints: int, push4imat: float, nord: int, device: int) -> int: ...
    def insert_dm(self, context: carmaWrap.context, type: str, alt: float, dim: int, nactus: int, influsize: int, ninflupos: int, n_npoints: int, push4imat: float, nord: int, dx: float, dy: float, theta: float, G: float, device: int, idx: int) -> int: 
        """
        Add a SutraDm in the SutraDms vector at the specified index
 
        Args:
          context: (CarmaContext) : current carma context
 
          type: (str): DM type ("pzt", "kl", or "tt")
 
          alt: (float): Conjugaison altitude in meters
 
          dim: (long): Support dimension
 
          nactus: (long): Number of actuators
 
          influsize: (long): Influenction function support size
 
          ninflupos: (long): Size of _influpos array
 
          n_npoints: (long): Size of _ninflu array
 
          push4imat: (float): Voltage to apply for imat computation
 
          nord: (long): Number of radial order for kl dm (0 if not kl)
 
          dx: (float): X axis misregistration [pixels]
 
          dy: (float): Y axis misregistration [pixels]
 
          theta: (float): Rotation angle misregistration [radians]
 
          G: (float): Magnification factor
 
          device: (int): Device index
 
          idx: (int) : DM index in the vector dms
          
        """
    def remove_dm(self, idx: int) -> int: 
        """
        Remove and delete the selected DM from SutraDms
 
        Args:
          idx: (int): index of DM
          
        """
    def set_full_com(self, com: numpy.ndarray[numpy.float32], shape_dm: bool = True) -> None: 
        """
        Set the command vector of all DM in SutraDms, and computes the DMs shapes
 
        Args:
            com: (np.array(ndim=1, dtype=np.float32)): Concatened command vectors
 
            shape_dm: (bool): (optionnal, default=True)  Computes the DM shape
          
        """
    @property
    def d_dms(self) -> typing.List[SutraDm]:
        """
        Vector of SutraDm
 
        :type: typing.List[SutraDm]
        """
    @property
    def nact_total(self) -> int:
        """
        Total number of actuators in SutraDms
 
        :type: int
        """
    @property
    def ndm(self) -> int:
        """
        Number of SutraDm in SutraDms
 
        :type: int
        """
    pass
class Gamora():
    def __init__(self, context: carmaWrap.context, device: int, type: str, nactus: int, nmodes: int, niter: int, IFvalue: numpy.ndarray[numpy.float32], IFrowind: numpy.ndarray[numpy.int32], IFcolind: numpy.ndarray[numpy.int32], IFnz: int, TT: numpy.ndarray[numpy.float32], spupil: numpy.ndarray[numpy.float32], size: int, Npts: int, scale: float, Btt: numpy.ndarray[numpy.float32], covmodes: numpy.ndarray[numpy.float32]) -> None: 
        """
        Initializes Gamora
 
        Args:
              context: (CarmaContext): context
 
              device: (int): context active device
 
              type : (str) : reconstruction method used ("roket" or "Vii")
 
              nactus : (int) : number of actuators
 
              nmodes (int) : number of modes
 
              niter : (int) : number of iterations performed with roket
 
              IFvalue : (np.ndarray[ndim=1,dtype=float32_t]) : Non zeros values of pzt influence function matrix
 
              IFrowind : (np.ndarray[ndim=1,dtype=int32_t]) : Row indices of nnz values (csr sparse format)
 
              IFcolind : (np.ndarray[ndim=1,dtype=int32_t]) : Column indices of nnz values (csr sparse format)
 
              IFnz: (int): number of non zero element in IF
 
              TT : (np.ndarray[ndim=1,dtype=float32_t])np.ndarray[ndim=1,dtype=float32_t]) : Tip-tilt influence functions
 
              spupil : (np.ndarray[ndim=2,dtype=float32_t]) : Small pupil
 
              size: (int): pupil size
 
              Npts: (int): number of points in the pupil
 
              scale : (float) : 2*pi/lambda_target with lambda_target expressed in microns
 
              Btt : (np.ndarray[ndim=2, dtype=np.float32_t]) : Volts to Btt modes matrix
 
              covmodes : (np.ndarray[ndim=2, dtype=np.float32_t]) : error covariance matrix expressed in a modal basis
               
        """
    def psf_rec_Vii(self) -> int: 
        """
        Vii PSF reconstruction
        """
    def psf_rec_roket(self, err: numpy.ndarray[numpy.float32]) -> int: 
        """
        Reconstruct the PSF from ROKET error buffer
 
        Args:
            err: (np.array[ndim=2,dtype=np.float32]): ROKET error buffer
        """
    @property
    def Npts(self) -> int:
        """
        number of points in the pupil
 
        :type: int
        """
    @property
    def d_Btt(self) -> carmaWrap.obj_float:
        """
        Btt modal basis
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_Dphi(self) -> carmaWrap.obj_float_complex:
        """
        Structure function
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_IF(self) -> carmaWrap.sparse_obj_float:
        """
        sparse IF matrix
 
        :type: carmaWrap.sparse_obj_float
        """
    @property
    def d_TT(self) -> carmaWrap.obj_float:
        """
        tip-tilt IF matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_amplipup(self) -> carmaWrap.obj_float_complex:
        """
        Complex amplitude in the pupil
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_covmodes(self) -> carmaWrap.obj_float:
        """
        error covariance marix on the modes
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_eigenvals(self) -> carmaWrap.obj_float:
        """
        Eigenvalues of Vii diago
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_err(self) -> carmaWrap.obj_float:
        """
        Error buffer
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_mask(self) -> carmaWrap.obj_float:
        """
        Mask
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_newmodek(self) -> carmaWrap.obj_float_complex:
        """
        Mode k from Vii
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_otfVii(self) -> carmaWrap.obj_float:
        """
        OTF reconstructed from Vii
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_otftel(self) -> carmaWrap.obj_float:
        """
        OTF of the telescope
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_phase(self) -> carmaWrap.obj_float:
        """
        Residual phase
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_psf(self) -> carmaWrap.obj_float:
        """
        Reconstructed PSF
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_pupfft(self) -> carmaWrap.obj_float_complex:
        """
        FFT of the pupil
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_term1(self) -> carmaWrap.obj_float:
        """
        Buffer for Vii computation
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_term2(self) -> carmaWrap.obj_float:
        """
        Buffer for Vii computation
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_wherephase(self) -> carmaWrap.obj_int:
        """
        index of valid point
 
        :type: carmaWrap.obj_int
        """
    @property
    def device(self) -> int:
        """
        GPU device
 
        :type: int
        """
    @property
    def nactus(self) -> int:
        """
        Number of actuators
 
        :type: int
        """
    @property
    def niter(self) -> int:
        """
        number of iterations
 
        :type: int
        """
    @property
    def nmodes(self) -> int:
        """
        number of modes
 
        :type: int
        """
    @property
    def scale(self) -> float:
        """
        Scale factor
 
        :type: float
        """
    @property
    def size(self) -> int:
        """
        Pupil support size
 
        :type: int
        """
    pass
class Groot():
    @typing.overload
    def __init__(self, context: carmaWrap.context, device: int, nssp: int, nlayers: int, gsangle: float, vdt: numpy.ndarray[numpy.float32], Htheta: numpy.ndarray[numpy.float32], L0: numpy.ndarray[numpy.float32], winddir: numpy.ndarray[numpy.float32], scale: numpy.ndarray[numpy.float32], pzt2tt: numpy.ndarray[numpy.float32], TTPfilter: numpy.ndarray[numpy.float32], Nact: numpy.ndarray[numpy.float32], xpos: numpy.ndarray[numpy.float32], ypos: numpy.ndarray[numpy.float32], fc: float) -> None: 
        """
        Initializes Groot to compute aniso and bandwidth model
 
        Args:
              context: (CarmaContext): context
 
              device: (int): context active device
 
              nssp : (str) :
 
              nlayers:
 
              gsangle:
 
              vdt:
 
              Htheta:
 
              L0:
 
              winddir:
 
              scale:
 
              pzt2tt:
 
              TTPfilter:
 
              Nact:
 
              xpos:
 
              ypos:
 
              fc:
               
 
 
        Initializes Groot to compute aliasing model
 
        Args:
              context: (CarmaContext): context
 
              device: (int): context active device
 
              nssp : (str) :
 
              weights:
 
              scale:
 
              xpos:
 
              ypos:
 
              fc:
 
              d:
 
              npts:
               
        """
    @typing.overload
    def __init__(self, context: carmaWrap.context, device: int, nssp: int, weights: numpy.ndarray[numpy.float32], scale: float, xpos: numpy.ndarray[numpy.float32], ypos: numpy.ndarray[numpy.float32], fc: float, d: float, npts: int) -> None: ...
    def compute_Calias(self) -> int: 
        """
        Computes the aliasing error covariance matrix
        """
    def compute_Cerr(self) -> int: 
        """
        Computes the aniso and bandwidth error covariance matrix
        """
    @property
    def d(self) -> float:
        """
        DM pitch
 
        :type: float
        """
    @property
    def d_CaXX(self) -> carmaWrap.obj_float:
        """
        XX component of the aliasing model
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_CaYY(self) -> carmaWrap.obj_float:
        """
        YY component of the aliasing model
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_Cerr(self) -> carmaWrap.obj_float:
        """
        Model of aniso and bandwidth covariance error matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_Nact(self) -> carmaWrap.obj_float:
        """
        Coupling matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_TT(self) -> carmaWrap.obj_float:
        """
        tip-tilt IF matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_TTPfilter(self) -> carmaWrap.obj_float:
        """
        Tip-tilt and piston filter matrix (= Btt.dot(P))
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_pzt2tt(self) -> carmaWrap.obj_float:
        """
        pzt to TT matrix
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_tab_int_x(self) -> carmaWrap.obj_float:
        """
        Tabulated integral
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_tab_int_y(self) -> carmaWrap.obj_float:
        """
        Tabulated integral
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_xpos(self) -> carmaWrap.obj_float:
        """
        X-positions of DM actuators or ssp [m]
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_ypos(self) -> carmaWrap.obj_float:
        """
        Y-positions of DM actuators or ssp [m]
 
        :type: carmaWrap.obj_float
        """
    @property
    def device(self) -> int:
        """
        GPU device
 
        :type: int
        """
    @property
    def fc(self) -> float:
        """
        DM cut-off frequency [m]
 
        :type: float
        """
    @property
    def gsangle(self) -> float:
        """
        Guide star angle [rad]
 
        :type: float
        """
    @property
    def nactus(self) -> int:
        """
        Number of actuators
 
        :type: int
        """
    @property
    def nlayers(self) -> int:
        """
        number of turbulent layers
 
        :type: int
        """
    @property
    def npts(self) -> int:
        """
        number of samples for aliasig computation
 
        :type: int
        """
    @property
    def nssp(self) -> int:
        """
        number of subap
 
        :type: int
        """
    @property
    def scale(self) -> float:
        """
        Scale factor
 
        :type: float
        """
    pass
class LGS():
    def lgs_init(self, nprof: int, hg: float, h0: float, deltah: float, pixsize: float, doffaxis: numpy.ndarray[numpy.float32], prof1d: numpy.ndarray[numpy.float32], profcum: numpy.ndarray[numpy.float32], beam: numpy.ndarray[numpy.float32], ftbeam: numpy.ndarray[numpy.complex64], azimuth: numpy.ndarray[numpy.float32]) -> int: 
        """
        Initialize LGS object
 
        Args:
            nprof: (int): TODO: docstring
 
            hg: (float):
 
            h0: (float):
 
            deltah: (float):
 
            pixsize: (float):
 
            doffaxis:(np.array[ndim= , dtype=np.float32]):
 
            prof1d:(np.array[ndim= , dtype=np.float32]):
 
            profcum:(np.array[ndim= , dtype=np.float32]):
 
            beam:(np.array[ndim= , dtype=np.float32]):
 
            ftbeam:(np.array[ndim= , dtype=np.complex64]):
 
            azimuth:(np.array[ndim= , dtype=np.float32]):
        """
    @property
    def d_azimuth(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_beam(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_doffaxis(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_ftbeam(self) -> carmaWrap.obj_float_complex:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_ftlgskern(self) -> carmaWrap.obj_float_complex:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_lgskern(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_prof1d(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_prof2d(self) -> carmaWrap.obj_float_complex:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_profcum(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def deltah(self) -> float:
        """
        TODO: docstring
 
        :type: float
        """
    @property
    def device(self) -> int:
        """
        GPU device index
 
        :type: int
        """
    @property
    def h0(self) -> float:
        """
        TODO: docstring
 
        :type: float
        """
    @property
    def hg(self) -> float:
        """
        TODO: docstring
 
        :type: float
        """
    @property
    def nmaxhr(self) -> int:
        """
        Size of HR support
 
        :type: int
        """
    @property
    def npix(self) -> int:
        """
        TODO: docstring
 
        :type: int
        """
    @property
    def nprof(self) -> int:
        """
        TODO: docstring
 
        :type: int
        """
    @property
    def nvalid(self) -> int:
        """
        TODO: docstring
 
        :type: int
        """
    @property
    def pixsize(self) -> float:
        """
        Pixel size on sky[arcsec]
 
        :type: float
        """
    pass
class Wfs():
    def comp_image(self, noise: bool = True) -> int: 
        """
        Computes the WFS image from the WFS phase
 
        Args:
            noise: (bool): take noise into account or not
        """
    def fill_binimage(self, arg0: int) -> int: 
        """
        Fill d_binimg from d_bincube
        """
    def set_binimg(self, binimg: numpy.ndarray[numpy.float32], nElem: int) -> int: 
        """
        Set the binimg of the SH WFS
 
        Args:
            binimg: (np.array[ndim=3, dtype=np.float32]) : cube of subap. images
 
            nElem: (int): Number of elements in binimg
          
        """
    def set_dark(self, dark: numpy.ndarray[numpy.float32], nElem: int) -> int: 
        """
        Set the dark of the SH WFS
 
        Args:
            dark: (np.array[ndim=2, dtype=np.float32]) : dark image
 
            nElem: (int): Number of elements in dark
          
        """
    def set_fakecam(self, fakecam: bool) -> int: 
        """
        Enable or disable uint16 computation for the WFS
 
        Args:
            fakecam: (bool): fakecam flag
            
        """
    def set_flat(self, flat: numpy.ndarray[numpy.float32], nElem: int) -> int: 
        """
        Set the flat of the SH WFS
 
        Args:
            flat: (np.array[ndim=2, dtype=np.float32]) : flat image
 
            nElem: (int): Number of elements in flat
          
        """
    def set_max_flux_per_pix(self, max_flux_per_pix: int) -> int: 
        """
        Set the maximum number of photons allowed before pixel saturation
 
        Args:
            max_flux_per_pix: (int): maximum number of photons allowed before pixel saturation
            
        """
    def set_max_pix_value(self, max_pix_value: int) -> int: 
        """
        Set the maximum number of ADU allowed in the uint16 image
 
        Args:
            max_pix_value: (int): maximum number of ADU allowed in the uint16 image
            
        """
    def set_noise(self, noise: float, seed: int) -> int: 
        """
        Set the noise of the WFS
 
        Args:
            noise: (float): desired noise (< 0 = no noise
                                            0 = photon only
                                            > 0 = photon + ron in e-)
            seed: (int): seed for the RNG
            
        """
    def set_pupil(self, pupil: numpy.ndarray[numpy.float32]) -> None: 
        """
        Set the pupil seen by the WFS
 
        Args:
            pupil: (np.array(ndim=2,dtype=np.float32)): pupil to set
        """
    @typing.overload
    def slopes_geom(self, type: int = 0) -> int: 
        """
        Computes theoretical slopes in wfs.d_slopes
 
        Args:
            type: (int): method to use (0: reduce, 1: derive)
 
 
 
        Computes theoretical slopes in given array
 
        Args:
            slopes: (np.array(ndim=1, dtype=np.float32)):
 
            type: (int): method to use (0: reduce, 1: derive)
        """
    @typing.overload
    def slopes_geom(self, slopes: numpy.ndarray[numpy.float32], type: int = 0) -> int: ...
    @property
    def d_bincube(self) -> carmaWrap.obj_float:
        """
        WFS spots as a 3D array
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_binimg(self) -> carmaWrap.obj_float:
        """
        WFS image
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_binimg_notnoisy(self) -> carmaWrap.obj_float:
        """
        WFS image without noise (ROKET only)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_camimg(self) -> carmaWrap.obj_uint16:
        """
        uint16 WFS image
 
        :type: carmaWrap.obj_uint16
        """
    @property
    def d_camplifoc(self) -> carmaWrap.obj_float_complex:
        """
        Complex amplitude in the focal plane
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_camplipup(self) -> carmaWrap.obj_float_complex:
        """
        Complex amplitude in the pupil
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_dark(self) -> carmaWrap.obj_float:
        """
        Dark WFS frame
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_flat(self) -> carmaWrap.obj_float:
        """
        Flat WFS frame
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_fluxPerSub(self) -> carmaWrap.obj_float:
        """
        Normalized flux per ssp
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_fttotim(self) -> carmaWrap.obj_float_complex:
        """
        Buffer for FFT computation
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_gs(self) -> Source:
        """
        WGS GS (SutraSource object)
 
        :type: Source
        """
    @property
    def d_hrmap(self) -> carmaWrap.obj_int:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_intensities(self) -> carmaWrap.obj_float:
        """
        Sum of intensities in each ssp
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_offsets(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_phasemap(self) -> carmaWrap.obj_int:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_pupil(self) -> carmaWrap.obj_float:
        """
        Pupil
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_sincar(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_slopes(self) -> carmaWrap.obj_float:
        """
        Slopes vector
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_submask(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_ttprojmat(self) -> carmaWrap.obj_float:
        """
        TT projection matrix from subap phase to slopes (geom wfs type 2)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_ttprojvec(self) -> carmaWrap.obj_float:
        """
        Input vector for TT projection from subap phase to slopes (geom wfs type 2)
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_validsubsx(self) -> carmaWrap.obj_int:
        """
        X-position of valid ssp
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_validsubsy(self) -> carmaWrap.obj_int:
        """
        Y-position of valid ssp
 
        :type: carmaWrap.obj_int
        """
    @property
    def device(self) -> int:
        """
        GPU device index
 
        :type: int
        """
    @property
    def fakecam(self) -> bool:
        """
        Flag for uint16 image
 
        :type: bool
        """
    @property
    def is_low_order(self) -> bool:
        """
        Flag for low order WFS
 
        :type: bool
        """
    @property
    def kernconv(self) -> bool:
        """
        Convolution kernel for spot computation
 
        :type: bool
        """
    @property
    def lgs(self) -> bool:
        """
        Is the WFS a LGS one ?
 
        :type: bool
        """
    @property
    def max_flux_per_pix(self) -> int:
        """
        Maximum number of photons allowed before pixel saturation
 
        :type: int
        """
    @property
    def max_pix_value(self) -> int:
        """
        Maximum number of ADU allowed in the uint16 image
 
        :type: int
        """
    @property
    def nfft(self) -> int:
        """
        FFT support size
 
        :type: int
        """
    @property
    def nffthr(self) -> int:
        """
        TODO: docstring
 
        :type: int
        """
    @property
    def nmaxhr(self) -> int:
        """
        TODO: docstring
 
        :type: int
        """
    @property
    def noise(self) -> float:
        """
        WFS noise [e-]
 
        :type: float
        """
    @property
    def nphase(self) -> int:
        """
        Number of phase point per ssp
 
        :type: int
        """
    @property
    def nphot(self) -> float:
        """
        Number of photons/ssp/iter
 
        :type: float
        """
    @property
    def nphot4imat(self) -> float:
        """
        Number of photons/ssp/iter used for imat computation
 
        :type: float
        """
    @property
    def npix(self) -> int:
        """
        Pixels per ssp
 
        :type: int
        """
    @property
    def npup(self) -> int:
        """
        Pupil support size
 
        :type: int
        """
    @property
    def nrebin(self) -> int:
        """
        Rebin factor
 
        :type: int
        """
    @property
    def ntot(self) -> int:
        """
        HR support size
 
        :type: int
        """
    @property
    def nvalid(self) -> int:
        """
        Number of valid ssp
 
        :type: int
        """
    @property
    def nxsub(self) -> int:
        """
        Number of ssp in the diameter
 
        :type: int
        """
    @property
    def roket(self) -> bool:
        """
        Is the WFS a LGS one ?
 
        :type: bool
        """
    @property
    def subapd(self) -> float:
        """
        ssp diameter in pixels
 
        :type: float
        """
    @property
    def type(self) -> str:
        """
        WFS type
 
        :type: str
        """
    pass
class PerfectCoronagraph(Coronagraph):
    def __init__(self, context: carmaWrap.context, d_source: Source, im_dimx: int, im_dimy: int, wavelength: numpy.ndarray[numpy.float32], nWavelength: int, device: int) -> None: 
        """
        Instantiates a PerfectCoronagraph object
 
        Args:
            context: (CarmaContext): context
 
            d_source: (SutraSource): Coronagraph source input
 
            im_dimx: (int): Coronagraphic image dimension along x axis
 
            im_dimy: (int): Coronagraphic image dimension along y axis
 
            wavelength: (np.ndarray[ndim=1, dtype=np.float32]): vector of wavelengths
 
            nWavelength: (int): number of wavelength
 
            device: (int): GPU device index
        """
    def set_mft(self, A: numpy.ndarray[numpy.complex64], B: numpy.ndarray[numpy.complex64], norm: numpy.ndarray[numpy.float32], mft_type: str) -> int: 
        """
        Set MFT matrices for coronagraphic image computation
 
        Args:
            A : (np.ndarray[dtype=np.complex32, ndims=3]): A MFT matrix for each wavelength
 
            B : (np.ndarray[dtype=np.complex32, ndims=3]): B MFT matrix for each wavelength
 
            norm : (np.ndarray[dtype=np.complex32, ndims=3]): MFT normalization for each wavelength
 
            mft_type : (str): MFT matrices to set, i.e. "img" or "psf"
        """
    @property
    def AA(self) -> typing.Dict[str, typing.List[carmaWrap.obj_float_complex]]:
        """
        A MFT matrix
 
        :type: typing.Dict[str, typing.List[carmaWrap.obj_float_complex]]
        """
    @property
    def BB(self) -> typing.Dict[str, typing.List[carmaWrap.obj_float_complex]]:
        """
        B MFT matrix
 
        :type: typing.Dict[str, typing.List[carmaWrap.obj_float_complex]]
        """
    @property
    def norm(self) -> typing.Dict[str, typing.List[float]]:
        """
        MFT normalization
 
        :type: typing.Dict[str, typing.List[float]]
        """
    pass
class Rtc_FFF():
    def __init__(self) -> None: 
        """
        Initialize a void rtc object
        """
    @typing.overload
    def add_centroider(self, context: carmaWrap.context, nvalid: int, offset: float, scale: float, filter_TT: bool, device: int, typec: str, wfs: Wfs) -> int: 
        """
         Add a SutraCentroider object in the RTC
 
        Args:
            context: (CarmaContext): carma context
 
            nvalid:(int): Number of WFS valid ssp
 
            offset: (float): offset for centroiding computation
 
            scale: (float): scale factor to get the right unit, ie. arcsec
 
            filt_TT: (bool): flag to control TT filtering
 
            device: (int): GPU device index
 
            typec: (str): Centroider type
 
            wfs: (SutraWfs): SutraWfs handled by the centroider
 
 
 
 
         Add a SutraCentroider object in the RTC
 
        Args:
            context: (CarmaContext): carma context
 
            nvalid:(int): Number of WFS valid ssp
 
            offset: (float): offset for centroiding computation
 
            scale: (float): scale factor to get the right unit, ie. arcsec
 
            filt_TT: (bool): flag to control TT filtering
 
            device: (int): GPU device index
 
            typec: (str): Centroider type
        """
    @typing.overload
    def add_centroider(self, context: carmaWrap.context, nvalid: int, offset: float, scale: float, filter_TT: bool, device: int, typec: str) -> int: ...
    @typing.overload
    def add_controller(self, context: carmaWrap.context, typec: str, device: int, delay: float, nslope: int, nactu: int, nslope_buffers: int = 0, nstates: int = 0, nstate_buffers: int = 0, nmodes: int = 0, niir_in: int = 0, niir_out: int = 0, polc: bool = False, is_modal: bool = False, dms: Dms = None, idx_dms: numpy.ndarray[numpy.int32] = [], ndm: int = 0, idx_centro: numpy.ndarray[numpy.int32] = [], ncentro: int = 0, Nphi: int = 0, wfs_direction: bool = False) -> int: 
        """
         Add a SutraController object in the RTC
 
        Args:
            context: (CarmaContext): carma context
 
            typec: (str): Controller type
 
            device: (int): GPU device index
 
            delay: (float): Loop delay [frames]
 
            nslope: (int): Number of slopes
 
            nactu:(int): Number of actuators to command
 
        Kwargs:
 
            nslope_buffers: (int) : Number of historic slopes vectors to use
 
            nstates       : (int)        : Number of states in state vector
 
            nstate_buffers: (int)        : Number of historic state vectors to use
 
            nmodes        : (int)        : Number of modes in mode vector
 
            niir_in       : (int)        : Number of input mode vectors for iir filter
 
            niir_out      : (int)        : Number of output mode vectors for iir filter
 
            polc          : (bool)       : Activate the Pseudo Open Loop Control if available
 
            is_modal      : (bool)       : Activate projection from modes to actu if available
 
            dms           : (SutraDms)  : SutraDms object
 
            idx_dms       : (np.array[ndim=1,dtype=np.int64]) : index of DM in SutraDms to command
 
            ndm           : (int)        : Number of DM to command
 
            idx_centro    : (np.array[ndim=1,dtype=np.int64]): (optional) Index of centoiders in sutra_rtc.d_centro to handle
 
            ncentro       : (int)        : Number of centroiders handled
 
            Nphi          : (int)        : umber of pixels in the pupil
 
            wfs_direction : (bool)       : Flag for ROKET
 
            
 
 
         Add a SutraController object in the RTC
 
        Args:
            context: (CarmaContext): carma context
 
            typec: (str): Controller type
 
            device: (int): GPU device index
 
            delay: (float): Loop delay [frames]
 
            nslope: (int): Number of slopes
 
            nactu:(int): Number of actuators to command
 
        Kwargs:
            nslope_buffers: (int) : Number of historic slopes vectors to use
 
            nstates       : (int)        : Number of states in state vector
 
            nstate_buffers: (int)        : Number of historic state vectors to use
 
            nmodes        : (int)        : Number of modes in mode vector
 
            niir_in       : (int)        : Number of input mode vectors for iir filter
 
            niir_out      : (int)        : Number of output mode vectors for iir filter
 
            polc          : (bool)       : Activate the Pseudo Open Loop Control if available
 
            is_modal      : (bool)       : Activate projection from modes to actu if available
 
            dms           : (SutraDms)  : SutraDms object
 
            idx_dms       : (np.array[ndim=1,dtype=np.int64]) : index of DM in SutraDms to command
 
            ndm           : (int)        : Number of DM to command
 
            idx_centro    : (np.array[ndim=1,dtype=np.int64]): (optional) Index of centoiders in sutra_rtc.d_centro to handle
 
            ncentro       : (int)        : Number of centroiders handled
 
            Nphi          : (int)        : umber of pixels in the pupil
 
            wfs_direction : (bool)       : Flag for ROKET
 
            
        """
    @typing.overload
    def add_controller(self, context: carmaWrap.context, typec: str, device: int, delay: float, nslope: int, nactu: int, nslope_buffers: int = 0, nstates: int = 0, nstate_buffers: int = 0, nmodes: int = 0, niir_in: int = 0, niir_out: int = 0, polc: bool = False, is_modal: bool = False) -> None: ...
    def apply_control(self, ncontrol: int, compVoltage: bool = True) -> int: 
        """
        Apply the commands on the DM and shape it
 
        Args:
           ncontrol: (int): Index of the controller
 
           compVoltage: (bool): if True (default), computes delay and perturb voltages. Else, applies just the vector command
        """
    def build_cmat(self, ncontrol: int, nfilt: int, filt_tt: bool = False) -> None: 
        """
        Computes cmat
 
        Args:
             ncontrol : (int): controller index
 
             nfilt: (int): number of modes to filter
 
             filt_tt: (bool): Flag for TT filter
        """
    def comp_voltage(self, ncontrol: int) -> int: 
        """
        Compute the commands on the DM
 
        Args:
           ncontrol: (int): Index of the controller
        """
    def do_calibrate_img(self, ncontrol: int) -> int: 
        """
        Computes the calibrated image
 
        Args:
           ncontrol: (int): Index of the controller
        """
    def do_centroids(self, ncontrol: int) -> int: 
        """
        Computes the centroids
 
        Args:
           ncontrol: (int): Index of the controller
        """
    def do_centroids_geom(self, ncontrol: int, type: int = 0) -> int: 
        """
        Computes the centroids geom
 
        Args:
           ncontrol: (int): Index of the controller
           type: (int): Centroiding method of geom wfs
        """
    def do_centroids_ref(self, ncontrol: int) -> int: 
        """
        Computes the centroids ref
 
        Args:
          ncontrol: (int): Index of the controller
        """
    def do_clipping(self, ncontrol: int) -> int: 
        """
        Clip the command to apply on the DMs on a SutraController object
 
        Args:
           ncontrol: (int) : controller index
        """
    def do_control(self, ncontrol: int) -> int: 
        """
        Computes the commands
 
        Args:
          ncontrol: (int): Index of the controller
        """
    def do_imat(self, ncontrol: int, dms: Dms, kernconv: int) -> int: 
        """
        Computes interaction matrix
 
        Args:
           ncontrol: (int): Index of the controller
 
           dms: (SutraDms): SutraDms object
 
           kernconv : (bool) : Flag for WFS spot convolution
        """
    def do_imat_basis(self, ncontrol: int, dms: Dms, nModes: int, m2v: numpy.ndarray[numpy.float32], pushAmpl: numpy.ndarray[numpy.float32], kernconv: int) -> int: 
        """
        Computes a modal interaction matrix
 
        Args:
             ncontrol: (int): Index of the controller
 
             dms: (SutraDms): SutraDms object
 
             nModes: (int): number of modes in the basis
 
             m2v: (np.array[ndim=2,dtype=np.float32]): modeToActu matrix
 
             pushAmpl: (np.array[ndim=1,dtype=np.float32]): pushpull strength in mode units
 
             kernconv : (bool) : Flag for WFS spot convolution
           
        """
    def imat_svd(self, ncontrol: int) -> None: 
        """
        Computes imat svd
 
        Args:
           ncontrol : (int): controller index
        """
    def remove_centroider(self, ncentro: int) -> int: 
        """
        Remove the specified centroider from the RTC
 
        Args:
             ncentro : (int): index of the centroider to remove
        """
    def remove_controller(self, ncontrol: int) -> int: 
        """
        Remove the specified controller from the RTC
 
        Args:
             ncontrol : (int): index of the controller to remove
        """
    def set_centroids_ref(self, centroidsRef: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the reference centroids
 
        Args:
             centroids_ref : (np.array(ndim=1, dtype=np.float32)): ref centroids
        """
    def set_gain(self, ncontrol: int, gain: float) -> None: 
        """
        Set the loop gain in the controller
 
        Args:
           ncontrol: (int): controller index
 
           gain: (float): gain to set
        """
    def set_modal_gains(self, ncontrol: int, mgain: numpy.ndarray[numpy.float32]) -> None: 
        """
        Set the modal gain in the controller
 
        Args:
           ncontrol: (int): controller index
 
           mgain: (np.array[ndim=1,dtype=np.float32]): modal gains to set
        """
    @property
    def d_centro(self) -> typing.List[Centroider_FF]:
        """
        Vector of centroiders
 
        :type: typing.List[Centroider_FF]
        """
    @property
    def d_control(self) -> typing.List[Controller_FF]:
        """
        Vector of controllers
 
        :type: typing.List[Controller_FF]
        """
    pass
class Rtc_FFU():
    def __init__(self) -> None: 
        """
        Initialize a void rtc object
        """
    @typing.overload
    def add_centroider(self, context: carmaWrap.context, nvalid: int, offset: float, scale: float, filter_TT: bool, device: int, typec: str, wfs: Wfs) -> int: 
        """
         Add a SutraCentroider object in the RTC
 
        Args:
            context: (CarmaContext): carma context
 
            nvalid:(int): Number of WFS valid ssp
 
            offset: (float): offset for centroiding computation
 
            scale: (float): scale factor to get the right unit, ie. arcsec
 
            filt_TT: (bool): flag to control TT filtering
 
            device: (int): GPU device index
 
            typec: (str): Centroider type
 
            wfs: (SutraWfs): SutraWfs handled by the centroider
 
 
 
 
         Add a SutraCentroider object in the RTC
 
        Args:
            context: (CarmaContext): carma context
 
            nvalid:(int): Number of WFS valid ssp
 
            offset: (float): offset for centroiding computation
 
            scale: (float): scale factor to get the right unit, ie. arcsec
 
            filt_TT: (bool): flag to control TT filtering
 
            device: (int): GPU device index
 
            typec: (str): Centroider type
        """
    @typing.overload
    def add_centroider(self, context: carmaWrap.context, nvalid: int, offset: float, scale: float, filter_TT: bool, device: int, typec: str) -> int: ...
    @typing.overload
    def add_controller(self, context: carmaWrap.context, typec: str, device: int, delay: float, nslope: int, nactu: int, nslope_buffers: int = 0, nstates: int = 0, nstate_buffers: int = 0, nmodes: int = 0, niir_in: int = 0, niir_out: int = 0, polc: bool = False, is_modal: bool = False, dms: Dms = None, idx_dms: numpy.ndarray[numpy.int32] = [], ndm: int = 0, idx_centro: numpy.ndarray[numpy.int32] = [], ncentro: int = 0, Nphi: int = 0, wfs_direction: bool = False) -> int: 
        """
         Add a SutraController object in the RTC
 
        Args:
            context: (CarmaContext): carma context
 
            typec: (str): Controller type
 
            device: (int): GPU device index
 
            delay: (float): Loop delay [frames]
 
            nslope: (int): Number of slopes
 
            nactu:(int): Number of actuators to command
 
        Kwargs:
 
            nslope_buffers: (int) : Number of historic slopes vectors to use
 
            nstates       : (int)        : Number of states in state vector
 
            nstate_buffers: (int)        : Number of historic state vectors to use
 
            nmodes        : (int)        : Number of modes in mode vector
 
            niir_in       : (int)        : Number of input mode vectors for iir filter
 
            niir_out      : (int)        : Number of output mode vectors for iir filter
 
            polc          : (bool)       : Activate the Pseudo Open Loop Control if available
 
            is_modal      : (bool)       : Activate projection from modes to actu if available
 
            dms           : (SutraDms)  : SutraDms object
 
            idx_dms       : (np.array[ndim=1,dtype=np.int64]) : index of DM in SutraDms to command
 
            ndm           : (int)        : Number of DM to command
 
            idx_centro    : (np.array[ndim=1,dtype=np.int64]): (optional) Index of centoiders in sutra_rtc.d_centro to handle
 
            ncentro       : (int)        : Number of centroiders handled
 
            Nphi          : (int)        : umber of pixels in the pupil
 
            wfs_direction : (bool)       : Flag for ROKET
 
            
 
 
         Add a SutraController object in the RTC
 
        Args:
            context: (CarmaContext): carma context
 
            typec: (str): Controller type
 
            device: (int): GPU device index
 
            delay: (float): Loop delay [frames]
 
            nslope: (int): Number of slopes
 
            nactu:(int): Number of actuators to command
 
        Kwargs:
            nslope_buffers: (int) : Number of historic slopes vectors to use
 
            nstates       : (int)        : Number of states in state vector
 
            nstate_buffers: (int)        : Number of historic state vectors to use
 
            nmodes        : (int)        : Number of modes in mode vector
 
            niir_in       : (int)        : Number of input mode vectors for iir filter
 
            niir_out      : (int)        : Number of output mode vectors for iir filter
 
            polc          : (bool)       : Activate the Pseudo Open Loop Control if available
 
            is_modal      : (bool)       : Activate projection from modes to actu if available
 
            dms           : (SutraDms)  : SutraDms object
 
            idx_dms       : (np.array[ndim=1,dtype=np.int64]) : index of DM in SutraDms to command
 
            ndm           : (int)        : Number of DM to command
 
            idx_centro    : (np.array[ndim=1,dtype=np.int64]): (optional) Index of centoiders in sutra_rtc.d_centro to handle
 
            ncentro       : (int)        : Number of centroiders handled
 
            Nphi          : (int)        : umber of pixels in the pupil
 
            wfs_direction : (bool)       : Flag for ROKET
 
            
        """
    @typing.overload
    def add_controller(self, context: carmaWrap.context, typec: str, device: int, delay: float, nslope: int, nactu: int, nslope_buffers: int = 0, nstates: int = 0, nstate_buffers: int = 0, nmodes: int = 0, niir_in: int = 0, niir_out: int = 0, polc: bool = False, is_modal: bool = False) -> None: ...
    def apply_control(self, ncontrol: int, compVoltage: bool = True) -> int: 
        """
        Apply the commands on the DM and shape it
 
        Args:
           ncontrol: (int): Index of the controller
 
           compVoltage: (bool): if True (default), computes delay and perturb voltages. Else, applies just the vector command
        """
    def build_cmat(self, ncontrol: int, nfilt: int, filt_tt: bool = False) -> None: 
        """
        Computes cmat
 
        Args:
             ncontrol : (int): controller index
 
             nfilt: (int): number of modes to filter
 
             filt_tt: (bool): Flag for TT filter
        """
    def comp_voltage(self, ncontrol: int) -> int: 
        """
        Compute the commands on the DM
 
        Args:
           ncontrol: (int): Index of the controller
        """
    def do_calibrate_img(self, ncontrol: int) -> int: 
        """
        Computes the calibrated image
 
        Args:
           ncontrol: (int): Index of the controller
        """
    def do_centroids(self, ncontrol: int) -> int: 
        """
        Computes the centroids
 
        Args:
           ncontrol: (int): Index of the controller
        """
    def do_centroids_geom(self, ncontrol: int, type: int = 0) -> int: 
        """
        Computes the centroids geom
 
        Args:
           ncontrol: (int): Index of the controller
           type: (int): Centroiding method of geom wfs
        """
    def do_centroids_ref(self, ncontrol: int) -> int: 
        """
        Computes the centroids ref
 
        Args:
          ncontrol: (int): Index of the controller
        """
    def do_clipping(self, ncontrol: int) -> int: 
        """
        Clip the command to apply on the DMs on a SutraController object
 
        Args:
           ncontrol: (int) : controller index
        """
    def do_control(self, ncontrol: int) -> int: 
        """
        Computes the commands
 
        Args:
          ncontrol: (int): Index of the controller
        """
    def do_imat(self, ncontrol: int, dms: Dms, kernconv: int) -> int: 
        """
        Computes interaction matrix
 
        Args:
           ncontrol: (int): Index of the controller
 
           dms: (SutraDms): SutraDms object
 
           kernconv : (bool) : Flag for WFS spot convolution
        """
    def do_imat_basis(self, ncontrol: int, dms: Dms, nModes: int, m2v: numpy.ndarray[numpy.float32], pushAmpl: numpy.ndarray[numpy.float32], kernconv: int) -> int: 
        """
        Computes a modal interaction matrix
 
        Args:
             ncontrol: (int): Index of the controller
 
             dms: (SutraDms): SutraDms object
 
             nModes: (int): number of modes in the basis
 
             m2v: (np.array[ndim=2,dtype=np.float32]): modeToActu matrix
 
             pushAmpl: (np.array[ndim=1,dtype=np.float32]): pushpull strength in mode units
 
             kernconv : (bool) : Flag for WFS spot convolution
           
        """
    def imat_svd(self, ncontrol: int) -> None: 
        """
        Computes imat svd
 
        Args:
           ncontrol : (int): controller index
        """
    def remove_centroider(self, ncentro: int) -> int: 
        """
        Remove the specified centroider from the RTC
 
        Args:
             ncentro : (int): index of the centroider to remove
        """
    def remove_controller(self, ncontrol: int) -> int: 
        """
        Remove the specified controller from the RTC
 
        Args:
             ncontrol : (int): index of the controller to remove
        """
    def set_centroids_ref(self, centroidsRef: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the reference centroids
 
        Args:
             centroids_ref : (np.array(ndim=1, dtype=np.float32)): ref centroids
        """
    def set_gain(self, ncontrol: int, gain: float) -> None: 
        """
        Set the loop gain in the controller
 
        Args:
           ncontrol: (int): controller index
 
           gain: (float): gain to set
        """
    def set_modal_gains(self, ncontrol: int, mgain: numpy.ndarray[numpy.float32]) -> None: 
        """
        Set the modal gain in the controller
 
        Args:
           ncontrol: (int): controller index
 
           mgain: (np.array[ndim=1,dtype=np.float32]): modal gains to set
        """
    @property
    def d_centro(self) -> typing.List[Centroider_FF]:
        """
        Vector of centroiders
 
        :type: typing.List[Centroider_FF]
        """
    @property
    def d_control(self) -> typing.List[Controller_FU]:
        """
        Vector of controllers
 
        :type: typing.List[Controller_FU]
        """
    pass
class Rtc_UFF():
    def __init__(self) -> None: 
        """
        Initialize a void rtc object
        """
    @typing.overload
    def add_centroider(self, context: carmaWrap.context, nvalid: int, offset: float, scale: float, filter_TT: bool, device: int, typec: str, wfs: Wfs) -> int: 
        """
         Add a SutraCentroider object in the RTC
 
        Args:
            context: (CarmaContext): carma context
 
            nvalid:(int): Number of WFS valid ssp
 
            offset: (float): offset for centroiding computation
 
            scale: (float): scale factor to get the right unit, ie. arcsec
 
            filt_TT: (bool): flag to control TT filtering
 
            device: (int): GPU device index
 
            typec: (str): Centroider type
 
            wfs: (SutraWfs): SutraWfs handled by the centroider
 
 
 
 
         Add a SutraCentroider object in the RTC
 
        Args:
            context: (CarmaContext): carma context
 
            nvalid:(int): Number of WFS valid ssp
 
            offset: (float): offset for centroiding computation
 
            scale: (float): scale factor to get the right unit, ie. arcsec
 
            filt_TT: (bool): flag to control TT filtering
 
            device: (int): GPU device index
 
            typec: (str): Centroider type
        """
    @typing.overload
    def add_centroider(self, context: carmaWrap.context, nvalid: int, offset: float, scale: float, filter_TT: bool, device: int, typec: str) -> int: ...
    @typing.overload
    def add_controller(self, context: carmaWrap.context, typec: str, device: int, delay: float, nslope: int, nactu: int, nslope_buffers: int = 0, nstates: int = 0, nstate_buffers: int = 0, nmodes: int = 0, niir_in: int = 0, niir_out: int = 0, polc: bool = False, is_modal: bool = False, dms: Dms = None, idx_dms: numpy.ndarray[numpy.int32] = [], ndm: int = 0, idx_centro: numpy.ndarray[numpy.int32] = [], ncentro: int = 0, Nphi: int = 0, wfs_direction: bool = False) -> int: 
        """
         Add a SutraController object in the RTC
 
        Args:
            context: (CarmaContext): carma context
 
            typec: (str): Controller type
 
            device: (int): GPU device index
 
            delay: (float): Loop delay [frames]
 
            nslope: (int): Number of slopes
 
            nactu:(int): Number of actuators to command
 
        Kwargs:
 
            nslope_buffers: (int) : Number of historic slopes vectors to use
 
            nstates       : (int)        : Number of states in state vector
 
            nstate_buffers: (int)        : Number of historic state vectors to use
 
            nmodes        : (int)        : Number of modes in mode vector
 
            niir_in       : (int)        : Number of input mode vectors for iir filter
 
            niir_out      : (int)        : Number of output mode vectors for iir filter
 
            polc          : (bool)       : Activate the Pseudo Open Loop Control if available
 
            is_modal      : (bool)       : Activate projection from modes to actu if available
 
            dms           : (SutraDms)  : SutraDms object
 
            idx_dms       : (np.array[ndim=1,dtype=np.int64]) : index of DM in SutraDms to command
 
            ndm           : (int)        : Number of DM to command
 
            idx_centro    : (np.array[ndim=1,dtype=np.int64]): (optional) Index of centoiders in sutra_rtc.d_centro to handle
 
            ncentro       : (int)        : Number of centroiders handled
 
            Nphi          : (int)        : umber of pixels in the pupil
 
            wfs_direction : (bool)       : Flag for ROKET
 
            
 
 
         Add a SutraController object in the RTC
 
        Args:
            context: (CarmaContext): carma context
 
            typec: (str): Controller type
 
            device: (int): GPU device index
 
            delay: (float): Loop delay [frames]
 
            nslope: (int): Number of slopes
 
            nactu:(int): Number of actuators to command
 
        Kwargs:
            nslope_buffers: (int) : Number of historic slopes vectors to use
 
            nstates       : (int)        : Number of states in state vector
 
            nstate_buffers: (int)        : Number of historic state vectors to use
 
            nmodes        : (int)        : Number of modes in mode vector
 
            niir_in       : (int)        : Number of input mode vectors for iir filter
 
            niir_out      : (int)        : Number of output mode vectors for iir filter
 
            polc          : (bool)       : Activate the Pseudo Open Loop Control if available
 
            is_modal      : (bool)       : Activate projection from modes to actu if available
 
            dms           : (SutraDms)  : SutraDms object
 
            idx_dms       : (np.array[ndim=1,dtype=np.int64]) : index of DM in SutraDms to command
 
            ndm           : (int)        : Number of DM to command
 
            idx_centro    : (np.array[ndim=1,dtype=np.int64]): (optional) Index of centoiders in sutra_rtc.d_centro to handle
 
            ncentro       : (int)        : Number of centroiders handled
 
            Nphi          : (int)        : umber of pixels in the pupil
 
            wfs_direction : (bool)       : Flag for ROKET
 
            
        """
    @typing.overload
    def add_controller(self, context: carmaWrap.context, typec: str, device: int, delay: float, nslope: int, nactu: int, nslope_buffers: int = 0, nstates: int = 0, nstate_buffers: int = 0, nmodes: int = 0, niir_in: int = 0, niir_out: int = 0, polc: bool = False, is_modal: bool = False) -> None: ...
    def apply_control(self, ncontrol: int, compVoltage: bool = True) -> int: 
        """
        Apply the commands on the DM and shape it
 
        Args:
           ncontrol: (int): Index of the controller
 
           compVoltage: (bool): if True (default), computes delay and perturb voltages. Else, applies just the vector command
        """
    def build_cmat(self, ncontrol: int, nfilt: int, filt_tt: bool = False) -> None: 
        """
        Computes cmat
 
        Args:
             ncontrol : (int): controller index
 
             nfilt: (int): number of modes to filter
 
             filt_tt: (bool): Flag for TT filter
        """
    def comp_voltage(self, ncontrol: int) -> int: 
        """
        Compute the commands on the DM
 
        Args:
           ncontrol: (int): Index of the controller
        """
    def do_calibrate_img(self, ncontrol: int) -> int: 
        """
        Computes the calibrated image
 
        Args:
           ncontrol: (int): Index of the controller
        """
    def do_centroids(self, ncontrol: int) -> int: 
        """
        Computes the centroids
 
        Args:
           ncontrol: (int): Index of the controller
        """
    def do_centroids_geom(self, ncontrol: int, type: int = 0) -> int: 
        """
        Computes the centroids geom
 
        Args:
           ncontrol: (int): Index of the controller
           type: (int): Centroiding method of geom wfs
        """
    def do_centroids_ref(self, ncontrol: int) -> int: 
        """
        Computes the centroids ref
 
        Args:
          ncontrol: (int): Index of the controller
        """
    def do_clipping(self, ncontrol: int) -> int: 
        """
        Clip the command to apply on the DMs on a SutraController object
 
        Args:
           ncontrol: (int) : controller index
        """
    def do_control(self, ncontrol: int) -> int: 
        """
        Computes the commands
 
        Args:
          ncontrol: (int): Index of the controller
        """
    def do_imat(self, ncontrol: int, dms: Dms, kernconv: int) -> int: 
        """
        Computes interaction matrix
 
        Args:
           ncontrol: (int): Index of the controller
 
           dms: (SutraDms): SutraDms object
 
           kernconv : (bool) : Flag for WFS spot convolution
        """
    def do_imat_basis(self, ncontrol: int, dms: Dms, nModes: int, m2v: numpy.ndarray[numpy.float32], pushAmpl: numpy.ndarray[numpy.float32], kernconv: int) -> int: 
        """
        Computes a modal interaction matrix
 
        Args:
             ncontrol: (int): Index of the controller
 
             dms: (SutraDms): SutraDms object
 
             nModes: (int): number of modes in the basis
 
             m2v: (np.array[ndim=2,dtype=np.float32]): modeToActu matrix
 
             pushAmpl: (np.array[ndim=1,dtype=np.float32]): pushpull strength in mode units
 
             kernconv : (bool) : Flag for WFS spot convolution
           
        """
    def imat_svd(self, ncontrol: int) -> None: 
        """
        Computes imat svd
 
        Args:
           ncontrol : (int): controller index
        """
    def remove_centroider(self, ncentro: int) -> int: 
        """
        Remove the specified centroider from the RTC
 
        Args:
             ncentro : (int): index of the centroider to remove
        """
    def remove_controller(self, ncontrol: int) -> int: 
        """
        Remove the specified controller from the RTC
 
        Args:
             ncontrol : (int): index of the controller to remove
        """
    def set_centroids_ref(self, centroidsRef: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the reference centroids
 
        Args:
             centroids_ref : (np.array(ndim=1, dtype=np.float32)): ref centroids
        """
    def set_gain(self, ncontrol: int, gain: float) -> None: 
        """
        Set the loop gain in the controller
 
        Args:
           ncontrol: (int): controller index
 
           gain: (float): gain to set
        """
    def set_modal_gains(self, ncontrol: int, mgain: numpy.ndarray[numpy.float32]) -> None: 
        """
        Set the modal gain in the controller
 
        Args:
           ncontrol: (int): controller index
 
           mgain: (np.array[ndim=1,dtype=np.float32]): modal gains to set
        """
    @property
    def d_centro(self) -> typing.List[Centroider_UF]:
        """
        Vector of centroiders
 
        :type: typing.List[Centroider_UF]
        """
    @property
    def d_control(self) -> typing.List[Controller_FF]:
        """
        Vector of controllers
 
        :type: typing.List[Controller_FF]
        """
    pass
class Rtc_UFU():
    def __init__(self) -> None: 
        """
        Initialize a void rtc object
        """
    @typing.overload
    def add_centroider(self, context: carmaWrap.context, nvalid: int, offset: float, scale: float, filter_TT: bool, device: int, typec: str, wfs: Wfs) -> int: 
        """
         Add a SutraCentroider object in the RTC
 
        Args:
            context: (CarmaContext): carma context
 
            nvalid:(int): Number of WFS valid ssp
 
            offset: (float): offset for centroiding computation
 
            scale: (float): scale factor to get the right unit, ie. arcsec
 
            filt_TT: (bool): flag to control TT filtering
 
            device: (int): GPU device index
 
            typec: (str): Centroider type
 
            wfs: (SutraWfs): SutraWfs handled by the centroider
 
 
 
 
         Add a SutraCentroider object in the RTC
 
        Args:
            context: (CarmaContext): carma context
 
            nvalid:(int): Number of WFS valid ssp
 
            offset: (float): offset for centroiding computation
 
            scale: (float): scale factor to get the right unit, ie. arcsec
 
            filt_TT: (bool): flag to control TT filtering
 
            device: (int): GPU device index
 
            typec: (str): Centroider type
        """
    @typing.overload
    def add_centroider(self, context: carmaWrap.context, nvalid: int, offset: float, scale: float, filter_TT: bool, device: int, typec: str) -> int: ...
    @typing.overload
    def add_controller(self, context: carmaWrap.context, typec: str, device: int, delay: float, nslope: int, nactu: int, nslope_buffers: int = 0, nstates: int = 0, nstate_buffers: int = 0, nmodes: int = 0, niir_in: int = 0, niir_out: int = 0, polc: bool = False, is_modal: bool = False, dms: Dms = None, idx_dms: numpy.ndarray[numpy.int32] = [], ndm: int = 0, idx_centro: numpy.ndarray[numpy.int32] = [], ncentro: int = 0, Nphi: int = 0, wfs_direction: bool = False) -> int: 
        """
         Add a SutraController object in the RTC
 
        Args:
            context: (CarmaContext): carma context
 
            typec: (str): Controller type
 
            device: (int): GPU device index
 
            delay: (float): Loop delay [frames]
 
            nslope: (int): Number of slopes
 
            nactu:(int): Number of actuators to command
 
        Kwargs:
 
            nslope_buffers: (int) : Number of historic slopes vectors to use
 
            nstates       : (int)        : Number of states in state vector
 
            nstate_buffers: (int)        : Number of historic state vectors to use
 
            nmodes        : (int)        : Number of modes in mode vector
 
            niir_in       : (int)        : Number of input mode vectors for iir filter
 
            niir_out      : (int)        : Number of output mode vectors for iir filter
 
            polc          : (bool)       : Activate the Pseudo Open Loop Control if available
 
            is_modal      : (bool)       : Activate projection from modes to actu if available
 
            dms           : (SutraDms)  : SutraDms object
 
            idx_dms       : (np.array[ndim=1,dtype=np.int64]) : index of DM in SutraDms to command
 
            ndm           : (int)        : Number of DM to command
 
            idx_centro    : (np.array[ndim=1,dtype=np.int64]): (optional) Index of centoiders in sutra_rtc.d_centro to handle
 
            ncentro       : (int)        : Number of centroiders handled
 
            Nphi          : (int)        : umber of pixels in the pupil
 
            wfs_direction : (bool)       : Flag for ROKET
 
            
 
 
         Add a SutraController object in the RTC
 
        Args:
            context: (CarmaContext): carma context
 
            typec: (str): Controller type
 
            device: (int): GPU device index
 
            delay: (float): Loop delay [frames]
 
            nslope: (int): Number of slopes
 
            nactu:(int): Number of actuators to command
 
        Kwargs:
            nslope_buffers: (int) : Number of historic slopes vectors to use
 
            nstates       : (int)        : Number of states in state vector
 
            nstate_buffers: (int)        : Number of historic state vectors to use
 
            nmodes        : (int)        : Number of modes in mode vector
 
            niir_in       : (int)        : Number of input mode vectors for iir filter
 
            niir_out      : (int)        : Number of output mode vectors for iir filter
 
            polc          : (bool)       : Activate the Pseudo Open Loop Control if available
 
            is_modal      : (bool)       : Activate projection from modes to actu if available
 
            dms           : (SutraDms)  : SutraDms object
 
            idx_dms       : (np.array[ndim=1,dtype=np.int64]) : index of DM in SutraDms to command
 
            ndm           : (int)        : Number of DM to command
 
            idx_centro    : (np.array[ndim=1,dtype=np.int64]): (optional) Index of centoiders in sutra_rtc.d_centro to handle
 
            ncentro       : (int)        : Number of centroiders handled
 
            Nphi          : (int)        : umber of pixels in the pupil
 
            wfs_direction : (bool)       : Flag for ROKET
 
            
        """
    @typing.overload
    def add_controller(self, context: carmaWrap.context, typec: str, device: int, delay: float, nslope: int, nactu: int, nslope_buffers: int = 0, nstates: int = 0, nstate_buffers: int = 0, nmodes: int = 0, niir_in: int = 0, niir_out: int = 0, polc: bool = False, is_modal: bool = False) -> None: ...
    def apply_control(self, ncontrol: int, compVoltage: bool = True) -> int: 
        """
        Apply the commands on the DM and shape it
 
        Args:
           ncontrol: (int): Index of the controller
 
           compVoltage: (bool): if True (default), computes delay and perturb voltages. Else, applies just the vector command
        """
    def build_cmat(self, ncontrol: int, nfilt: int, filt_tt: bool = False) -> None: 
        """
        Computes cmat
 
        Args:
             ncontrol : (int): controller index
 
             nfilt: (int): number of modes to filter
 
             filt_tt: (bool): Flag for TT filter
        """
    def comp_voltage(self, ncontrol: int) -> int: 
        """
        Compute the commands on the DM
 
        Args:
           ncontrol: (int): Index of the controller
        """
    def do_calibrate_img(self, ncontrol: int) -> int: 
        """
        Computes the calibrated image
 
        Args:
           ncontrol: (int): Index of the controller
        """
    def do_centroids(self, ncontrol: int) -> int: 
        """
        Computes the centroids
 
        Args:
           ncontrol: (int): Index of the controller
        """
    def do_centroids_geom(self, ncontrol: int, type: int = 0) -> int: 
        """
        Computes the centroids geom
 
        Args:
           ncontrol: (int): Index of the controller
           type: (int): Centroiding method of geom wfs
        """
    def do_centroids_ref(self, ncontrol: int) -> int: 
        """
        Computes the centroids ref
 
        Args:
          ncontrol: (int): Index of the controller
        """
    def do_clipping(self, ncontrol: int) -> int: 
        """
        Clip the command to apply on the DMs on a SutraController object
 
        Args:
           ncontrol: (int) : controller index
        """
    def do_control(self, ncontrol: int) -> int: 
        """
        Computes the commands
 
        Args:
          ncontrol: (int): Index of the controller
        """
    def do_imat(self, ncontrol: int, dms: Dms, kernconv: int) -> int: 
        """
        Computes interaction matrix
 
        Args:
           ncontrol: (int): Index of the controller
 
           dms: (SutraDms): SutraDms object
 
           kernconv : (bool) : Flag for WFS spot convolution
        """
    def do_imat_basis(self, ncontrol: int, dms: Dms, nModes: int, m2v: numpy.ndarray[numpy.float32], pushAmpl: numpy.ndarray[numpy.float32], kernconv: int) -> int: 
        """
        Computes a modal interaction matrix
 
        Args:
             ncontrol: (int): Index of the controller
 
             dms: (SutraDms): SutraDms object
 
             nModes: (int): number of modes in the basis
 
             m2v: (np.array[ndim=2,dtype=np.float32]): modeToActu matrix
 
             pushAmpl: (np.array[ndim=1,dtype=np.float32]): pushpull strength in mode units
 
             kernconv : (bool) : Flag for WFS spot convolution
           
        """
    def imat_svd(self, ncontrol: int) -> None: 
        """
        Computes imat svd
 
        Args:
           ncontrol : (int): controller index
        """
    def remove_centroider(self, ncentro: int) -> int: 
        """
        Remove the specified centroider from the RTC
 
        Args:
             ncentro : (int): index of the centroider to remove
        """
    def remove_controller(self, ncontrol: int) -> int: 
        """
        Remove the specified controller from the RTC
 
        Args:
             ncontrol : (int): index of the controller to remove
        """
    def set_centroids_ref(self, centroidsRef: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the reference centroids
 
        Args:
             centroids_ref : (np.array(ndim=1, dtype=np.float32)): ref centroids
        """
    def set_gain(self, ncontrol: int, gain: float) -> None: 
        """
        Set the loop gain in the controller
 
        Args:
           ncontrol: (int): controller index
 
           gain: (float): gain to set
        """
    def set_modal_gains(self, ncontrol: int, mgain: numpy.ndarray[numpy.float32]) -> None: 
        """
        Set the modal gain in the controller
 
        Args:
           ncontrol: (int): controller index
 
           mgain: (np.array[ndim=1,dtype=np.float32]): modal gains to set
        """
    @property
    def d_centro(self) -> typing.List[Centroider_UF]:
        """
        Vector of centroiders
 
        :type: typing.List[Centroider_UF]
        """
    @property
    def d_control(self) -> typing.List[Controller_FU]:
        """
        Vector of controllers
 
        :type: typing.List[Controller_FU]
        """
    pass
class SHWFS(Wfs):
    def comp_nphot(self, ittime: float, optthroughput: float, diam: float, nxsub: int, zerop: float = 0, gsmag: float = 0, lgsreturnperwatt: float = 0, laserpower: float = 0) -> int: 
        """
        Compute the currect number of photons for a given system
 
        Args:
          ittime: (float): 1/loop frequency [s].
 
          optthroughput: (float): wfs global throughput.
 
          diam: (float):  telescope diameter.
 
          nxsub: (float): linear number of subaps.
 
          zerop: (float): (optional for LGS)  detector zero point expressed in ph/m**2/s in the bandwidth of the WFS.
 
          gsmag: (float): (optional for LGS)  magnitude of guide star.
 
          lgsreturnperwatt: (float): (optional for NGS) return per watt factor (high season : 10 ph/cm2/s/W).
 
          laserpower: (float): (optional for NGS) laser power in W.
        """
    def load_arrays(self, phasemap: numpy.ndarray[numpy.int32], hrmap: numpy.ndarray[numpy.int32], binmap: numpy.ndarray[numpy.int32], offsets: numpy.ndarray[numpy.float32], fluxPerSub: numpy.ndarray[numpy.float32], validsubsx: numpy.ndarray[numpy.int32], validsubsy: numpy.ndarray[numpy.int32], istart: numpy.ndarray[numpy.int32], jstart: numpy.ndarray[numpy.int32], ttprojmat: numpy.ndarray[numpy.float32], kernel: numpy.ndarray[numpy.complex64]) -> int: 
        """
        Load SH WFS arrays
 
        Args:
          phasemap: TODO: docstring
 
          hrmap:
 
          binmap:
 
          offsets:
 
          fluxPerSub: (np.array[ndim=2,dtype=np.float32]): Normalized flux per ssp
 
          validsubsx: (np.array[ndim=1, dtype=np.int64]): X position of each valid ssp
 
          validsubsy: (np.array[ndim=1, dtype=np.int64]): Y position of each valid ssp
 
          istart:
 
          jstart:
 
          ttprojmat: (np.array[ndim=2, dtype=np.float32]): slope projection matrix
                     for geom wfs.
 
          kernel:
        """
    def set_bincube(self, bincube: numpy.ndarray[numpy.float32], nElem: int) -> int: 
        """
        Set the bincube of the SH WFS
 
        Args:
            bincube: (np.array[ndim=3, dtype=np.float32]) : cube of subap. images
 
            nElem: (int): Number of elements in bincube
          
        """
    @property
    def d_binmap(self) -> carmaWrap.obj_int:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_fsamplifoc(self) -> carmaWrap.obj_float_complex:
        """
        Focal plane with field stop
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_fsamplipup(self) -> carmaWrap.obj_float_complex:
        """
        Complex amplitude in the pupil in the field stop array size
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_validpuppixx(self) -> carmaWrap.obj_int:
        """
        X position of the bottom left corner of each ssp
 
        :type: carmaWrap.obj_int
        """
    @property
    def d_validpuppixy(self) -> carmaWrap.obj_int:
        """
        Y position of the bottom left corner of each ssp
 
        :type: carmaWrap.obj_int
        """
    pass
class Sensors():
    def __init__(self, context: carmaWrap.context, d_tel: Telescope, type: typing.List[str], nwfs: int, nxsub: numpy.ndarray[numpy.int64], nvalid: numpy.ndarray[numpy.int64], npupils: numpy.ndarray[numpy.int64], npix: numpy.ndarray[numpy.int64], nphase: numpy.ndarray[numpy.int64], nrebin: numpy.ndarray[numpy.int64], nfft: numpy.ndarray[numpy.int64], ntot: numpy.ndarray[numpy.int64], npup: numpy.ndarray[numpy.int64], pdiam: numpy.ndarray[numpy.float32], nphot: numpy.ndarray[numpy.float32], nphot4imat: numpy.ndarray[numpy.float32], lgs: numpy.ndarray[numpy.int32], fakecam: numpy.ndarray[bool], max_flux_per_pix: numpy.ndarray[numpy.int32], max_pix_value: numpy.ndarray[numpy.int32], device: int, roket: bool) -> None: 
        """
            Create and initialise a sensors object
 
        Args:
            context: (CarmaContext) : current carma context
 
            d_tel: (SutraTelescope) : SutraTelescope object
 
            type: (list of string): WFS types
 
            nwfs: (int) : number of WFS
 
            nxsub: (np.ndarray[ndim=1, dtype=np.int64]) : number of ssp in the diameter for each WFS
 
            nvalid: (np.ndarray[ndim=1, dtype=np.int64]) : number of valid ssp for each WFS
 
            npupils: (np.ndarray[ndim=1, dtype=np.int64]) : number of pupil images for each WFS
 
            npix: (np.ndarray[ndim=1,dtype=np.int64]) : number of pix per ssp for each WFS
 
            nphase: (np.ndarray[ndim=1,dtype=np.int64]) : number of phase points per ssp for each WFS
 
            nrebin: (np.ndarray[ndim=1,dtype=np.int64]) : rebin factor for each WFS
 
            nfft: (np.ndarray[ndim=1,dtype=np.int64]) : FFT support size for each WFS
 
            ntot: (np.ndarray[ndim=1,dtype=np.int64]) : HR support size for each WFS
 
            npup: (np.ndarray[ndim=1,dtype=np.int64]) : Pupil support size for each WFS
 
            pdiam: (np.ndarray[ndim=1,dtype=np.float32]) : ssp diameter in pixels for each WFS
 
            nphot: (np.ndarray[ndim=1,dtype=np.float32]) : photons per subap per iter for each WFS
 
            nphot4imat: (np.ndarray[ndim=1,dtype=np.float32]) : photons per subap per iter for each WFS (for imat computation only)
 
            lgs: (np.ndarray[ndim=1,dtype=np.int64]) : LGS flag for each WFS
 
            fakecam: (bool): if True, image is computed in uint16
 
            max_flux_per_pix: (np.ndarray[ndim=1, dtype=np.int32]): maximum number of photons a pixel can handle before saturation
 
            max_pix_value: (np.ndarray[ndim=1, dtype=np.int32]): maximum number of ADU possible in the uint16 image
 
            device: (int): GPU device index
 
            roket : (bool): flag for enabling ROKET
            
        """
    def initgs(self, xpos: numpy.ndarray[numpy.float32], ypos: numpy.ndarray[numpy.float32], lambda_um: numpy.ndarray[numpy.float32], mag: numpy.ndarray[numpy.float32], zerop: float, sizes: numpy.ndarray[numpy.int64], noise: numpy.ndarray[numpy.float32], seeds: numpy.ndarray[numpy.int64], G: numpy.ndarray[numpy.float32], thetaML: numpy.ndarray[numpy.float32], dx: numpy.ndarray[numpy.float32], dy: numpy.ndarray[numpy.float32]) -> int: 
        """
        Initializes the guide stars of all WFS
 
        Args:
            xpos: (np.array(ndim=1,dtype=np.float32)): X position of the GSs [arcsec]
 
            ypos: (np.array(ndim=1,dtype=np.float32)): Y position of the GSs [arcsec]
 
            lambda_um: (np.array(ndim=1,dtype=np.float32)): Wavelength of the GSs [µm]
 
            mag: (np.array(ndim=1,dtype=np.float32)): Magnitude of the GSs
 
            zerop: (float): Flux at magnitude 0
 
            sizes: (np.array(ndim=1,dtype=np.int64)): Support size of the GSs
 
            noise: (np.array(ndim=1,dtype=np.float32)): Noise of the WFS [e-]
 
            seeds: (np.array(ndim=1,dtype=np.int64)): seeds for noise generation
 
            G: (np.array(ndim=1,dtype=np.float32)): Magnification factors for WFS misalignment
 
            thetaML: (np.array(ndim=1,dtype=np.float32)): Pupil rotation angle for WFS misalignment
 
            dx: (np.array(ndim=1,dtype=np.float32)): X axis misalignment for WFS
 
            dy: (np.array(ndim=1,dtype=np.float32)): Y axis misalignment for WFS
            
        """
    def set_field_stop(self, nwfs: int, field_stop: numpy.ndarray[numpy.float32], N: int) -> int: 
        """
        Set new field stop for the specified SH WFS
 
        Args:
            nwfs: (int): WFS index
 
            field_stop: (np.array(ndim=2,dtype=np.float32)): Field stop to use
 
            N : (int): Size of the field stop array along one axis
        """
    @property
    def d_camplifoc(self) -> carmaWrap.obj_float_complex:
        """
        Complex amplitude in the focal plane
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_camplipup(self) -> carmaWrap.obj_float_complex:
        """
        Complex amplitude in the pupil
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_ftlgskern(self) -> carmaWrap.obj_float_complex:
        """
        Convolution kernel for LGS spot
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_fttotim(self) -> carmaWrap.obj_float_complex:
        """
        Buffer for FFT computation
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_lgskern(self) -> carmaWrap.obj_float:
        """
        LGS spot
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_wfs(self) -> typing.List[SutraWfs]:
        """
        Vector of WFS
 
        :type: typing.List[SutraWfs]
        """
    @property
    def device(self) -> int:
        """
        GPU device index
 
        :type: int
        """
    @property
    def nsensors(self) -> int:
        """
        Number of WFS
 
        :type: int
        """
    @property
    def roket(self) -> bool:
        """
        ROKET flag
 
        :type: bool
        """
    pass
class Source():
    def __str__(self) -> str: ...
    def add_layer(self, context: str, type: int, xoff: float, yoff: float) -> int: 
        """
        Add a phase screen "dm" or "atmos" as layers to consider for raytracing
 
        Args:
            context: (CarmaContext) : carma or carmaWrap context
 
            type: (str) : "atmos" or "dm"
 
            xoff: (float) : x-offset for raytracing
 
            yoff: (float) : y-offset for raytracing
            
        """
    def comp_image(self, puponly: int = 0, comp_le: bool = True) -> int: 
        """
        Compute short and long exposure images
 
        Args:
            puponly: (int) : Airy computation
 
            comp_le: (bool) : Flag for computing LE image
            
        """
    def comp_strehl(self, do_fit: bool = True) -> int: 
        """
        Compute Strehl ratio
        """
    def init_strehlmeter(self) -> int: 
        """
        Initialize Strehl ratio computation
        """
    @typing.overload
    def raytrace(self, rst: bool = False) -> int: 
        """
        Raytrace through ncpa layers
 
        Args:
            rst: (bool): reset screen phase before raytracing
 
 
 
        Raytrace through telescope aberrations
 
        Args:
            tel: (SutraTelescope): SutraTelescope object
 
            rst: (bool): reset screen phase before raytracing
 
 
 
        Raytrace through turbulent layers. Calling this function will automatically reset the screen phase before raytracing.
 
        Args:
            atmos: (SutraAtmos): SutraAtmos object
 
            do_async: (bool): asynchronous mode
 
 
 
        Raytrace through DMs
 
        Args:
            dms: (SutraDms): SutraDms object
 
            rst: (bool): reset phase screen before raytracing
 
            do_phase_var: (bool): compute the residual phase variance
 
            do_async: (bool): asynchronous mode
 
 
 
        Raytrace through all layers (turbu, dms, telescope, ncpa)
 
        Args:
            tel: (sutra_tel): SutraTelescope object
 
            atm: (SutraAtmos): SutraAtmos object
 
            dms: (SutraDms): SutraDms object
 
            do_phase_var: (bool): compute the residual phase variance
 
            do_async: (bool): asynchronous mode
        """
    @typing.overload
    def raytrace(self, tel: Telescope, rst: bool = False) -> int: ...
    @typing.overload
    def raytrace(self, atmos: Atmos, do_async: bool = False) -> int: ...
    @typing.overload
    def raytrace(self, dms: Dms, rst: bool = False, do_phase_var: bool = True, do_async: bool = False) -> int: ...
    @typing.overload
    def raytrace(self, dms: Telescope, atm: Atmos, tel: Dms, do_phase_var: bool = True, do_async: bool = False) -> int: ...
    def remove_layer(self, type: str, idx: int) -> int: 
        """
        Remove a phase screen for raytracing
 
        Args:
            type: (str) : "atmos" or "dm"
 
            idx: (int) : index of the DM or turbulent layer to remove
            
        """
    def reset_phase(self) -> int: 
        """
        Reset the phase screen
        """
    def reset_strehlmeter(self) -> int: 
        """
        Reset Strehl ratio
        """
    def set_ncpa(self, data: numpy.ndarray[numpy.float32]) -> None: 
        """
        Set the NCPA phase
 
        Args:
            data: (np.array(ndim=2,dtype=np.float32)): NCPA phase to set
                      
        """
    def set_phase(self, data: numpy.ndarray[numpy.float32]) -> None: 
        """
        Set the target screen phase
 
        Args:
            data: (np.array(ndim=2,dtype=np.float32)): target phase to set
        """
    @property
    def G(self) -> float:
        """
        Magnifying factor for WFS misalignment
 
        :type: float
        """
    @property
    def block_size(self) -> int:
        """
        Optimum block size of device
 
        :type: int
        """
    @property
    def d_amplipup(self) -> carmaWrap.obj_float_complex:
        """
        Complex amplitude in the pupil plane
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_image_le(self) -> carmaWrap.obj_float:
        """
        Long exposure image of the source
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_image_se(self) -> carmaWrap.obj_float:
        """
        Short exposure image of the source
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_lgs(self) -> SutraLGS:
        """
        LGS structure of WFS
 
        :type: SutraLGS
        """
    @property
    def d_ncpa_phase(self) -> carmaWrap.obj_float:
        """
        NCPA phase
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_phase(self) -> carmaWrap.obj_float:
        """
        Phase screen of the source
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_phasepts(self) -> carmaWrap.obj_float:
        """
        Phase on the valid pixels of the pupil plane
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_pupil(self) -> carmaWrap.obj_float:
        """
        Pupil mask
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_wherephase(self) -> carmaWrap.obj_int:
        """
        Indices of the valid pixels of the pupil
 
        :type: carmaWrap.obj_int
        """
    @property
    def device(self) -> int:
        """
        GPU device index
 
        :type: int
        """
    @property
    def dx(self) -> float:
        """
        X axis WFS misalignment [pixels]
 
        :type: float
        """
    @property
    def dy(self) -> float:
        """
        Y axis WFS misalignment [pixels]
 
        :type: float
        """
    @property
    def lambda_um(self) -> float:
        """
        Wavelength of the source in µm
 
        :type: float
        """
    @property
    def lgs(self) -> bool:
        """
        Boolean for LGS
 
        :type: bool
        """
    @property
    def mag(self) -> float:
        """
        Magnitude of the source
 
        :type: float
        """
    @property
    def npts(self) -> int:
        """
        Number of points in the pupil
 
        :type: int
        """
    @property
    def phase_telemetry(self) -> carmaWrap.host_obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.host_obj_float
        """
    @property
    def phase_var(self) -> float:
        """
        Short exposure variance in the pupil [µm²]
 
        :type: float
        """
    @property
    def phase_var_avg(self) -> float:
        """
        Long exposure variance in the pupil [µm²]
 
        :type: float
        """
    @property
    def phase_var_count(self) -> int:
        """
        Counter fo long exposure variance computation
 
        :type: int
        """
    @property
    def posx(self) -> float:
        """
        X position of the source
 
        :type: float
        """
    @property
    def posy(self) -> float:
        """
        Y position of the source
 
        :type: float
        """
    @property
    def ref_strehl(self) -> float:
        """
        reference for Strehl computation (Airy)
 
        :type: float
        """
    @property
    def scale(self) -> float:
        """
        Phase scale factor (2*pi/lambda)
 
        :type: float
        """
    @property
    def strehl_counter(self) -> int:
        """
        Counter for LE Strehl computation
 
        :type: int
        """
    @property
    def strehl_le(self) -> float:
        """
        Long exposure Strehl ratio
 
        :type: float
        """
    @property
    def strehl_se(self) -> float:
        """
        Short exposure Strehl ratio
 
        :type: float
        """
    @property
    def thetaML(self) -> float:
        """
        Pupil rotation angle for WFS misalignment
 
        :type: float
        """
    @property
    def type(self) -> str:
        """
        Type of source (Target or WFS GS)
 
        :type: str
        """
    @property
    def xoff(self) -> typing.Dict[typing.Tuple[str, int], float]:
        """
        X offset for raytracing
 
        :type: typing.Dict[typing.Tuple[str, int], float]
        """
    @property
    def yoff(self) -> typing.Dict[typing.Tuple[str, int], float]:
        """
        Y offset for raytracing
 
        :type: typing.Dict[typing.Tuple[str, int], float]
        """
    @property
    def zp(self) -> float:
        """
        Flux at magnitude 0
 
        :type: float
        """
    pass
class StellarCoronagraph(Coronagraph):
    def __init__(self, context: carmaWrap.context, d_source: Source, im_dimx: int, im_dimy: int, fpm_dimx: int, fpm_dimy: int, wavelength: numpy.ndarray[numpy.float32], nWavelength: int, babinet: int, device: int) -> None: 
        """
        Instantiates a StellarCoronagraph object
 
        Args:
            context: (CarmaContext): context
 
            d_source: (SutraSource): Coronagraph source input
 
            im_dimx: (int): Coronagraphic image dimension along x axis
 
            im_dimy: (int): Coronagraphic image dimension along y axis
 
            fpm_dimx: (int): Focal plane dimension along x axis
 
            fpm_dimy: (int): Focal plane dimension along y axis
 
            wavelength: (np.ndarray[ndim=1, dtype=np.float32]): vector of wavelengths
 
            nWavelength: (int): number of wavelength
 
            babinet: (bool): Flag to enable Babinet trick
 
            device: (int): GPU device index
        """
    def compute_image_normalization(self) -> int: 
        """
        Compute image for normalization
            
        """
    def set_apodizer(self, mask: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set apodizer for coronagraphic image computation
 
        Args:
            mask: (np.ndarray[ndim=2, dtype=np.float32]): apodizer 
        """
    def set_focal_plane_mask(self, mask: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set focal plane mask for coronagraphic image computation
 
        Args:
            mask: (np.ndarray[ndim=3, dtype=np.float32]): Focal plane mask for each wavelength
        """
    def set_lyot_stop(self, mask: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set lyot_stop for coronagraphic image computation
 
        Args:
            mask: (np.ndarray[ndim=2, dtype=np.float32]): lyot_stop 
        """
    def set_mft(self, A: numpy.ndarray[numpy.complex64], B: numpy.ndarray[numpy.complex64], norm: numpy.ndarray[numpy.float32], mft_type: str) -> int: 
        """
        Set MFT matrices for coronagraphic image computation
 
        Args:
            A : (np.ndarray[dtype=np.complex32, ndims=3]): A MFT matrix for each wavelength
 
            B : (np.ndarray[dtype=np.complex32, ndims=3]): B MFT matrix for each wavelength
 
            norm : (np.ndarray[dtype=np.complex32, ndims=3]): MFT normalization for each wavelength
 
            mft_type : (str): MFT matrices to set, i.e. "img" or "psf"
        """
    @property
    def AA(self) -> typing.Dict[str, typing.Tuple[typing.List[carmaWrap.obj_float_complex], typing.List[int]]]:
        """
        A MFT matrices
 
        :type: typing.Dict[str, typing.Tuple[typing.List[carmaWrap.obj_float_complex], typing.List[int]]]
        """
    @property
    def BB(self) -> typing.Dict[str, typing.Tuple[typing.List[carmaWrap.obj_float_complex], typing.List[int]]]:
        """
        B MFT matrices
 
        :type: typing.Dict[str, typing.Tuple[typing.List[carmaWrap.obj_float_complex], typing.List[int]]]
        """
    @property
    def babinet(self) -> bool:
        """
        Babinet trick flag
 
        :type: bool
        """
    @property
    def d_apodizer(self) -> carmaWrap.obj_float:
        """
        Apodizer
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_lyot_stop(self) -> carmaWrap.obj_float:
        """
        Lyot stop
 
        :type: carmaWrap.obj_float
        """
    @property
    def focal_plane_mask(self) -> typing.List[carmaWrap.obj_float]:
        """
        Focal plane mask
 
        :type: typing.List[carmaWrap.obj_float]
        """
    @property
    def fpmDimx(self) -> int:
        """
        Focal plane dimension
 
        :type: int
        """
    @property
    def fpmDimy(self) -> int:
        """
        Focal plane dimension
 
        :type: int
        """
    @property
    def norm(self) -> typing.Dict[str, typing.List[float]]:
        """
        MFT normalization
 
        :type: typing.Dict[str, typing.List[float]]
        """
    pass
class Target():
    def __init__(self, context: carmaWrap.context, d_tel: Telescope, ntargets: int, xpos: numpy.ndarray[numpy.float32], ypos: numpy.ndarray[numpy.float32], lambda_um: numpy.ndarray[numpy.float32], mag: numpy.ndarray[numpy.float32], zerop: float, sizes: numpy.ndarray[numpy.int64], Npts: int, device: int) -> None: 
        """
        Create and initialise an target object
 
        Args:
            context: (CarmaContext) : current carma context
 
            d_tel: (SutraTelescope) : SutraTelescope object
 
            ntargets: (int): number of targets
 
            xpos: (np.ndarray[ndim=1,dtype=np.float32_t]) : X positions of each target in arcsec
 
            ypos: (np.ndarray[ndim=1,dtype=np.float32_t]) : Y positions of each target in arcsec
 
            lambda_um: (np.ndarray[ndim=1,dtype=np.float32_t]) : Wavelength of each target in µm
 
            mag: (np.ndarray[ndim=1,dtype=np.float32_t]) : magnitude of each target
 
            zerop: (float) : Flux at magnitude 0 in photons/m²/s
 
            sizes: (np.ndarray[ndim=1,dtype=np.int64_t]) : Support size of each target
 
            Npts : (int): number of points in the pupil
 
            device: (int): GPU device index
            
        """
    def __str__(self) -> str: ...
    @property
    def d_targets(self) -> typing.List[Source]:
        """
        Vector of targets
 
        :type: typing.List[Source]
        """
    @property
    def ntargets(self) -> int:
        """
        Number of targets
 
        :type: int
        """
    pass
class Telescope():
    def __init__(self, context: carmaWrap.context, n_pup: int, npos: int, pupil: numpy.ndarray[numpy.float32], n_pup_m: int, pupil_m: numpy.ndarray[numpy.float32]) -> None: 
        """
        Create and initialise a Telescope object
 
        Args:
            context: (CarmaContext) : current carma context
 
            n_pup: (long) : spupil size
 
            npos : (long): number of points in the pupil
 
            pupil: (np.ndarray[ndim=2, dtype=np.float32_t]) : spupil
 
            n_pup_m: (long) : mpupil size
 
            pupil_m: (np.ndarray[ndim=2, dtype=np.float32_t]) : mpupil
            
        """
    def reset_input_phase(self) -> int: 
        """
        Reset circular buffer d_input_phase
        """
    def set_input_phase(self, phase_ab: numpy.ndarray[numpy.float32]) -> int: 
        """
            Set a 3D cube of phase screens to be played. Each phase screen is shown to sources as an additional layer to be raytraced. Each phase screen must have the same dimensions as m_pupil
 
        Args:
            input_hase: (np.ndarray[ndim=3,dtype=np.float32_t]) : Cube of input phase screens
          
        """
    def set_phase_ab_M1(self, phase_ab: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the M1 phase aberration in the small pupil
 
        Args:
            phase_ab: (np.ndarray[ndim=2,dtype=np.float32_t]) : M1 phase aberration in the small pupil
          
        """
    def set_phase_ab_M1_m(self, phase_ab: numpy.ndarray[numpy.float32]) -> int: 
        """
        Set the M1 phase aberration in the medium pupil
 
        Args:
            phase_ab: (np.ndarray[ndim=2,dtype=np.float32_t]) : M1 phase aberration in the medium pupil
          
        """
    def set_pupil(self, pup: numpy.ndarray[numpy.float32]) -> None: 
        """
        Set the small pupil
 
        Args:
            pup: (np.ndarray[ndim=2,dtype=np.float32_t]) :  small pupil
          
        """
    def set_pupil_m(self, pup: numpy.ndarray[numpy.float32]) -> None: 
        """
        Set the medium pupil
 
        Args:
            pup: (np.ndarray[ndim=2,dtype=np.float32_t]) :  medium pupil
          
        """
    def update_input_phase(self) -> int: 
        """
        Update input_phase_counter to take the next phase screen in the circular buffer d_input_phase
        """
    @property
    def d_input_phase(self) -> carmaWrap.obj_float:
        """
        Cube of user-defined input phase screens
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_phase_ab_M1(self) -> carmaWrap.obj_float:
        """
        M1 aberrations on the small pupil
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_phase_ab_M1_m(self) -> carmaWrap.obj_float:
        """
        M1 aberrations on the medium pupil
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_pupil(self) -> carmaWrap.obj_float:
        """
        Small pupil of the Telescope
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_pupil_m(self) -> carmaWrap.obj_float:
        """
        Medium pupil of the Telescope
 
        :type: carmaWrap.obj_float
        """
    @property
    def device(self) -> int:
        """
        Device number
 
        :type: int
        """
    @property
    def input_phase_counter(self) -> int:
        """
        Index of the current phase screen in the cube d_input_phase
 
        :type: int
        """
    @property
    def num_eleme_pup(self) -> int:
        """
        number of points in the pupil
 
        :type: int
        """
    @property
    def pup_size(self) -> int:
        """
        Small Pupil size
 
        :type: int
        """
    @property
    def pup_size_m(self) -> int:
        """
        Medium Pupil size
 
        :type: int
        """
    pass
class Tscreen():
    def set_deltax(self, deltax: float) -> int: 
        """
        Set the screen movement along the X-axis at each iteration in pixels
 
        Args:
            deltax: (float) :  Number of columns to add at each iteration
          
        """
    def set_deltay(self, deltay: float) -> int: 
        """
        Set the screen movement along the Y-axis at each iteration in pixels
 
        Args:
                deltay: (float) :  Number of lines to add at each iteration
          
        """
    def set_istencilx(self, stencil: numpy.ndarray[numpy.uint32]) -> int: 
        """
        Set the stencil along the X-Axis
 
        Args:
                stencil: (np.array) :  Stencil along the X-axis
          
        """
    def set_istencily(self, stencil: numpy.ndarray[numpy.uint32]) -> int: 
        """
        Set the stencil along the Y-Axis
 
        Args:
                stencil: (np.array) :  Stencil along the Y-axis
          
        """
    @property
    def accumx(self) -> float:
        """
        accumulate columns to extrude
 
        :type: float
        """
    @property
    def accumy(self) -> float:
        """
        accumulate rows to extrude
 
        :type: float
        """
    @property
    def altitude(self) -> float:
        """
        altitude of the phase screen
 
        :type: float
        """
    @property
    def amplitude(self) -> float:
        """
        amplitude for extrusion (r0**(-5/6)
 
        :type: float
        """
    @property
    def d_istencilx(self) -> carmaWrap.obj_uint:
        """
        stencil for row extrusion
 
        :type: carmaWrap.obj_uint
        """
    @property
    def d_istencily(self) -> carmaWrap.obj_uint:
        """
        stencil for column extrusion
 
        :type: carmaWrap.obj_uint
        """
    @property
    def d_mat_a(self) -> carmaWrap.obj_float:
        """
        A matrix for extrusion
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_mat_b(self) -> carmaWrap.obj_float:
        """
        B matrix for extrusion
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_noise(self) -> carmaWrap.obj_float:
        """
        random numbers for extrusion
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_screen(self) -> carmaWrap.obj_float:
        """
        Turbulent phase screen
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_ytmp(self) -> carmaWrap.obj_float:
        """
        contains the extrude update
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_z(self) -> carmaWrap.obj_float:
        """
        tmp array for extrusion process
 
        :type: carmaWrap.obj_float
        """
    @property
    def deltax(self) -> float:
        """
        number of columns to extrude per iteration
 
        :type: float
        """
    @property
    def deltay(self) -> float:
        """
        number of rows to extrude per iteration
 
        :type: float
        """
    @property
    def device(self) -> int:
        """
        Device index
 
        :type: int
        """
    @property
    def r0(self) -> float:
        """
        layer r0 in pixels
 
        :type: float
        """
    @property
    def screen_size(self) -> int:
        """
        size of phase screen
 
        :type: int
        """
    @property
    def winddir(self) -> float:
        """
        wind direction of phase screen
 
        :type: float
        """
    @property
    def windspeed(self) -> float:
        """
        wind speed of phase screen
 
        :type: float
        """
    pass
class PYRWFS(Wfs):
    def comp_nphot(self, ittime: float, optthroughput: float, diam: float, cobs: float, zerop: float = 0, gsmag: float = 0) -> int: 
        """
        Compute the currect number of photons for a given system
 
        Args:
          ittime: (float): 1/loop frequency [s].
 
          optthroughput: (float): wfs global throughput.
 
          diam: (float): telescope diameter.
 
          cobs: (float): telescope central obstruction.
 
          zerop: (float): (optional for LGS)  detector zero point expressed in ph/m**2/s in the bandwidth of the WFS.
 
          gsmag: (float): (optional for LGS)  magnitude of guide star.
        """
    def copy_valid_pix(self, data: numpy.ndarray[numpy.float32], validx: numpy.ndarray[numpy.int32], validy: numpy.ndarray[numpy.int32], dim: int) -> int: 
        """
        Copy the given pixels on the right place in the binimg of PWFS
 
        Args:
            data:
 
            validx:
 
            validy:
 
            dim:
          
        """
    def load_arrays(self, halfxy: numpy.ndarray[numpy.complex64], cx: numpy.ndarray[numpy.float32], cy: numpy.ndarray[numpy.float32], weights: numpy.ndarray[numpy.float32], sincar: numpy.ndarray[numpy.float32], submask: numpy.ndarray[numpy.float32], validsubsx: numpy.ndarray[numpy.int32], validsubsy: numpy.ndarray[numpy.int32], phasemap: numpy.ndarray[numpy.int32], fluxPerSub: numpy.ndarray[numpy.float32], ttprojmat: numpy.ndarray[numpy.float32]) -> int: 
        """
        Load PYRHR WFS arrays
 
        Args:
            halfxy:
 
            cx:
 
            cy:
 
            weights:
 
            sincar:
 
            submask:
 
            validsubsx:
 
            validsubsy:
 
            phasemap:
 
            fluxPerSub:
            
            ttprojmat: (np.array[ndim=2, dtype=np.float32]): slope projection matrix
                       for geom wfs.
 
          
        """
    def set_phalfxy(self, phalfxy: numpy.ndarray[numpy.complex64]) -> int: 
        """
        Set the pyramid mask for each modulation point
 
        Args:
            phalfxy: (np.ndarray[ndim=2, dtype=np.complex64]): pyramid mask for each modulation point
          
        """
    def set_pyr_mod_weights(self, weights: numpy.ndarray[numpy.float32], npts: int) -> int: 
        """
        Set the modulation points weights of a PWFS
 
        Args:
            weights: (np.ndarray[ndim=1, dtype=np.float32_t]): modulation points weights ponderation
 
            npts: (int): number of modulation points
          
        """
    @typing.overload
    def set_pyr_modulation_points(self, cx: numpy.ndarray[numpy.float32], cy: numpy.ndarray[numpy.float32], npts: int) -> int: 
        """
        Set the modulation points of a PWFS
 
        Args:
            cx: (np.ndarray[ndim=1, dtype=np.float32_t]): X position of modulation points
 
            cy: (np.ndarray[ndim=1, dtype=np.float32_t]): Y position of modulation points
 
            npts: (int): number of modulation points
          
 
 
        Set the modulation points and weights of a PWFS
 
        Args:
            cx: (np.ndarray[ndim=1, dtype=np.float32_t]): X position of modulation points
 
            cy: (np.ndarray[ndim=1, dtype=np.float32_t]): Y position of modulation points
 
            weights: (np.ndarray[ndim=1, dtype=np.float32_t]): modulation points weights ponderation
 
            npts: (int): number of modulation points
          
        """
    @typing.overload
    def set_pyr_modulation_points(self, cx: numpy.ndarray[numpy.float32], cy: numpy.ndarray[numpy.float32], weights: numpy.ndarray[numpy.float32], npts: int) -> int: ...
    def set_pyrimg(self, img: numpy.ndarray[numpy.float32]) -> None: 
        """
        Set the image of the PWFS
 
        Args:
            img: (np.array[ndim=2,dtype=np.float32]): new image to set
          
        """
    def set_submask(self, mask: numpy.ndarray[numpy.float32]) -> None: 
        """
        Set the field stop of the PWFS
 
        Args:
            mask: (np.array[ndim=2,dtype=np.float32]): new field stop to set
          
        """
    def set_validpix(self, datax: numpy.ndarray[numpy.int32], datay: numpy.ndarray[numpy.int32]) -> None: 
        """
        Set the valid pixels of the PWFS
 
        Args:
            datax: (np.array[ndim=2,dtype=np.float32]): new X positions of valid pixels
 
            datay: (np.array[ndim=2,dtype=np.float32]): new Y positions of valid pixels
          
        """
    @property
    def compute_pyrfocalplane(self) -> bool:
        """
        TODO: docstring
 
        :type: bool
        """
    @compute_pyrfocalplane.setter
    def compute_pyrfocalplane(self, arg0: bool) -> None:
        """
        TODO: docstring
        """
    @property
    def d_hrimg(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_phalfxy(self) -> carmaWrap.obj_float_complex:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_poffsets(self) -> carmaWrap.obj_float_complex:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float_complex
        """
    @property
    def d_psum(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def d_pyrfocalplane(self) -> carmaWrap.obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.obj_float
        """
    @property
    def npupils(self) -> int:
        """
        Number of pupil images
 
        :type: int
        """
    @property
    def pyr_cx(self) -> carmaWrap.host_obj_float:
        """
        TODO: docstring
 
        :type: carmaWrap.host_obj_float
        """
    @property
    def pyr_cy(self) -> carmaWrap.host_obj_float:
        """
        Modulation points X-positions
 
        :type: carmaWrap.host_obj_float
        """
    @property
    def pyr_mod_weights(self) -> carmaWrap.host_obj_float:
        """
        Ponderation weights for each modulation points
 
        :type: carmaWrap.host_obj_float
        """
    pass
__version__ = '5.4.4'