Initialization of a Rtc object. More...

Functions
def	rtc_init (carmaWrap_context context, Telescope tel, Sensors wfs, Dms dms, Atmos atmos, list p_wfss, conf.Param_tel p_tel, conf.Param_geom p_geom, conf.Param_atmos p_atmos, float ittime, p_centroiders=None, p_controllers=None, p_dms=None, do_refslp=False, brahma=False, cacao=False, tar=None, dataBase={}, use_DB=False)
	Initialize all the SutraRtc objects : centroiders and controllers. More...

Rtc	rtc_standalone (carmaWrap_context context, int nwfs, list nvalid, int nactu, list centroider_type, list delay, list offset, list scale, bool brahma=False, bool fp16=False, bool cacao=False)
	TODO docstring. More...

def	init_centroider (context, int nwfs, conf.Param_wfs p_wfs, conf.Param_centroider p_centroider, conf.Param_tel p_tel, conf.Param_atmos p_atmos, Sensors wfs, Rtc rtc)
	Initialize a centroider object in Rtc. More...

def	comp_weights (conf.Param_centroider p_centroider, conf.Param_wfs p_wfs, int npix)
	Compute the weights used by centroider wcog and corr. More...

def	init_controller (context, int i, conf.Param_controller p_controller, list p_wfss, conf.Param_geom p_geom, list p_dms, conf.Param_atmos p_atmos, float ittime, conf.Param_tel p_tel, Rtc rtc, Dms dms, Sensors wfs, Telescope tel, Atmos atmos, List[conf.Param_centroider] p_centroiders, do_refslp=False, dataBase={}, use_DB=False)
	Initialize the controller part of rtc. More...

def	init_controller_geo (int i, Rtc rtc, Dms dms, conf.Param_geom p_geom, conf.Param_controller p_controller, list p_dms, roket=False)
	Initialize geometric controller. More...

def	init_controller_ls (int i, conf.Param_controller p_controller, list p_wfss, conf.Param_geom p_geom, list p_dms, conf.Param_atmos p_atmos, float ittime, conf.Param_tel p_tel, Rtc rtc, Dms dms, Sensors wfs, Telescope tel, Atmos atmos, dict dataBase={}, bool use_DB=False)

def	init_controller_cured (int i, Rtc rtc, conf.Param_controller p_controller, list p_dms, list p_wfss)

def	init_controller_mv (int i, conf.Param_controller p_controller, list p_wfss, conf.Param_geom p_geom, list p_dms, conf.Param_atmos p_atmos, conf.Param_tel p_tel, Rtc rtc, Dms dms, Sensors wfs, Atmos atmos)
	Initialize the MV controller. More...

def	init_controller_generic (int i, conf.Param_controller p_controller, list p_dms, Rtc rtc)
	Initialize the generic controller. More...

Detailed Description

Initialization of a Rtc object.

Author: COMPASS Team https://github.com/ANR-COMPASS

Version: 5.0.0

Date: 2020/05/18

Copyright: GNU Lesser General Public License

This file is part of COMPASS https://anr-compass.github.io/compass/

COMPASS is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or any later version.

COMPASS: End-to-end AO simulation tool using GPU acceleration The COMPASS platform was designed to meet the need of high-performance for the simulation of AO systems.

The final product includes a software package for simulating all the critical subcomponents of AO, particularly in the context of the ELT and a real-time core based on several control approaches, with performances consistent with its integration into an instrument. Taking advantage of the specific hardware architecture of the GPU, the COMPASS tool allows to achieve adequate execution speeds to conduct large simulation campaigns called to the ELT.

The COMPASS platform can be used to carry a wide variety of simulations to both testspecific components of AO of the E-ELT (such as wavefront analysis device with a pyramid or elongated Laser star), and various systems configurations such as multi-conjugate AO.

COMPASS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with COMPASS. If not, see https://www.gnu.org/licenses/lgpl-3.0.txt.

Function Documentation

◆ comp_weights()

def shesha.init.rtc_init.comp_weights	(	conf.Param_centroider	p_centroider,
		conf.Param_wfs	p_wfs,
		int	npix
	)

Compute the weights used by centroider wcog and corr.

:parameters: p_centroider (Param_centroider) : centroider settings p_wfs (Param_wfs) : wfs settings npix (int):

Definition at line 279 of file rtc_init.py.

     """
     if (p_centroider.type_fct == scons.CentroiderFctType.MODEL):
  
         if (p_wfs.gsalt > 0):
             tmp = p_wfs._lgskern
             tmp2 = utilities.makegaussian(tmp.shape[1],
                                           npix * p_wfs._nrebin).astype(np.float32)
             tmp3 = np.zeros((tmp.shape[1], tmp.shape[1], p_wfs._nvalid),
                             dtype=np.float32)
  
             for j in range(p_wfs._nvalid):
                 tmp3[:, :, j] = np.fft.ifft2(
                         np.fft.fft2(tmp[:, :, j]) * np.fft.fft2(tmp2.T)).real
                 tmp3[:, :, j] *= tmp3.shape[0] * tmp3.shape[1]
                 tmp3[:, :, j] = np.fft.fftshift(tmp3[:, :, j])
  
             offset = (p_wfs._Ntot - p_wfs._nrebin * p_wfs.npix) // 2
             j = offset + p_wfs._nrebin * p_wfs.npix
             tmp = np.zeros((j - offset + 1, j - offset + 1, tmp3.shape[2]),
                            dtype=np.float32)
             tmp3 = np.cumsum(tmp3[offset:j, offset:j, :], axis=0)
             tmp[1:, 1:, :] = np.cumsum(tmp3, axis=1)
             tmp = np.diff(tmp[::p_wfs._nrebin, ::p_wfs._nrebin, :], axis=0)
             tmp = np.diff(tmp, axis=1)
  
             p_centroider.weights = tmp
         else:
             p_centroider.type_fct = scons.CentroiderFctType.GAUSS
             print("No LGS found, centroider weighting function becomes gaussian")
  
     if (p_centroider.type_fct == scons.CentroiderFctType.GAUSS):
         if p_centroider.width is None:
             p_centroider.width = npix
         if (p_wfs.npix % 2 == 1):
             p_centroider.weights = utilities.makegaussian(
                     p_wfs.npix, p_centroider.width, p_wfs.npix // 2,
                     p_wfs.npix // 2).astype(np.float32)
         elif (p_centroider.type == scons.CentroiderType.CORR):
             p_centroider.weights = utilities.makegaussian(
                     p_wfs.npix, p_centroider.width, p_wfs.npix // 2,
                     p_wfs.npix // 2).astype(np.float32)
         else:
             p_centroider.weights = utilities.makegaussian(
                     p_wfs.npix, p_centroider.width, p_wfs.npix // 2 - 0.5,
                     p_wfs.npix // 2 - 0.5).astype(np.float32)
  
  

Here is the caller graph for this function:

◆ init_centroider()

def shesha.init.rtc_init.init_centroider	(		context,
		int	nwfs,
		conf.Param_wfs	p_wfs,
		conf.Param_centroider	p_centroider,
		conf.Param_tel	p_tel,
		conf.Param_atmos	p_atmos,
		Sensors	wfs,
		Rtc	rtc
	)

Initialize a centroider object in Rtc.

:parameters: context (carmaWrap_context): context nwfs (int) : index of wfs p_wfs (Param_wfs): wfs settings p_centroider (Param_centroider) : centroider settings wfs (Sensors): Sensor object rtc (Rtc) : Rtc object

Definition at line 203 of file rtc_init.py.

         wfs: (Sensors): Sensor object
         rtc : (Rtc) : Rtc object
     """
     if (p_wfs.type == scons.WFSType.SH):
         if (p_centroider.type != scons.CentroiderType.CORR):
             s_offset = p_wfs.npix // 2. - 0.5
         else:
             if (p_centroider.type_fct == scons.CentroiderFctType.MODEL):
                 if (p_wfs.npix % 2 == 0):
                     s_offset = p_wfs.npix // 2 - 0.5
                 else:
                     s_offset = p_wfs.npix // 2
             else:
                 s_offset = p_wfs.npix // 2 - 0.5
         s_scale = p_wfs.pixsize
  
     elif (p_wfs.type == scons.WFSType.PYRHR or p_wfs.type == scons.WFSType.PYRLR):
         s_offset = 0.
         s_scale = (p_wfs.Lambda * 1e-6 / p_tel.diam) * \
             p_wfs.pyr_ampl * CONST.RAD2ARCSEC
  
     rtc.add_centroider(context, p_wfs._nvalid, s_offset, s_scale, p_centroider.filter_TT,
                        context.active_device, p_centroider.type, wfs.d_wfs[nwfs])
     rtc.d_centro[-1].load_validpos(p_wfs._validsubsx, p_wfs._validsubsy,
                                    p_wfs._nvalid * p_wfs.nPupils)
  
     rtc.d_centro[-1].set_npix(p_wfs.npix)
  
     if (p_centroider.type != scons.CentroiderType.MASKEDPIX):
         p_centroider._nslope = 2 * p_wfs._nvalid
     else:
         p_centroider._nslope = p_wfs._validsubsx.size
  
     if (p_centroider.type == scons.CentroiderType.PYR):
         # FIXME SIGNATURE CHANGES
         rtc.d_centro[nwfs].set_pyr_method(p_centroider.method)
         rtc.d_centro[nwfs].set_pyr_thresh(p_centroider.thresh)
  
     elif (p_wfs.type == scons.WFSType.SH):
         if (p_centroider.type == scons.CentroiderType.TCOG):
             rtc.d_centro[nwfs].set_threshold(p_centroider.thresh)
         elif (p_centroider.type == scons.CentroiderType.BPCOG):
             rtc.d_centro[nwfs].set_nmax(p_centroider.nmax)
         elif (p_centroider.type == scons.CentroiderType.WCOG or
               p_centroider.type == scons.CentroiderType.CORR):
             r0 = p_atmos.r0 * (p_wfs.Lambda / 0.5)**(6 / 5.)
             seeing = CONST.RAD2ARCSEC * (p_wfs.Lambda * 1.e-6) / r0
             npix = seeing // p_wfs.pixsize
             comp_weights(p_centroider, p_wfs, npix)
             if p_centroider.type == scons.CentroiderType.WCOG:
                 rtc.d_centro[nwfs].init_weights()
                 rtc.d_centro[nwfs].load_weights(p_centroider.weights,
                                                 p_centroider.weights.ndim)
             else:
                 corrnorm = np.ones((2 * p_wfs.npix, 2 * p_wfs.npix), dtype=np.float32)
                 p_centroider.sizex = 3
                 p_centroider.sizey = 3
                 p_centroider.interpmat = rtc_util.create_interp_mat(
                         p_centroider.sizex, p_centroider.sizey).astype(np.float32)
  
                 if (p_centroider.weights is None):
                     raise ValueError("p_centroider.weights is None")
                 rtc.d_centro[nwfs].init_corr(p_centroider.sizex, p_centroider.sizey,
                                              p_centroider.interpmat)
                 rtc.d_centro[nwfs].load_corr(p_centroider.weights, corrnorm,
                                              p_centroider.weights.ndim)
  
  

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_controller()

def shesha.init.rtc_init.init_controller	(		context,
		int	i,
		conf.Param_controller	p_controller,
		list	p_wfss,
		conf.Param_geom	p_geom,
		list	p_dms,
		conf.Param_atmos	p_atmos,
		float	ittime,
		conf.Param_tel	p_tel,
		Rtc	rtc,
		Dms	dms,
		Sensors	wfs,
		Telescope	tel,
		Atmos	atmos,
		List[conf.Param_centroider]	p_centroiders,
			do_refslp = `False`,
			dataBase = `{}`,
			use_DB = `False`
	)

Initialize the controller part of rtc.

:parameters: context (carmaWrap_context): context i (int) : controller index p_controller (Param_controller) : controller settings p_wfss (list of Param_wfs) : wfs settings p_geom (Param_geom) : geom settings p_dms (list of Param_dms) : dms settings p_atmos (Param_atmos) : atmos settings ittime (float) : iteration time [s] p_tel (Param_tel) : telescope settings rtc (Rtc) : Rtc objet dms (Dms) : Dms object wfs (Sensors) : Sensors object tel (Telescope) : Telescope object atmos (Atmos) : Atmos object p_centroiders (list of Param_centroider): centroiders settings

Definition at line 346 of file rtc_init.py.

         dms: (Dms) : Dms object
         wfs: (Sensors) : Sensors object
         tel: (Telescope) : Telescope object
         atmos: (Atmos) : Atmos object
         p_centroiders: (list of Param_centroider): centroiders settings
     """
     if (p_controller.type != scons.ControllerType.GEO):
         nwfs = p_controller.nwfs
         if (len(p_wfss) == 1):
             nwfs = p_controller.nwfs
             # TODO fixing a bug ... still not understood
         nvalid = sum([p_wfss[k]._nvalid for k in nwfs])
         p_controller.set_nvalid(int(np.sum([p_wfss[k]._nvalid for k in nwfs])))
         tmp = 0
         for c in p_centroiders:
             if (c.nwfs in nwfs):
                 tmp = tmp + c._nslope
         p_controller.set_nslope(int(tmp))
     else:
         nslope = np.sum([c._nslope for c in p_centroiders])
         p_controller.set_nslope(int(nslope))
  
     # parameter for add_controller(_geo)
     ndms = p_controller.ndm.tolist()
     nactu = np.sum([p_dms[j]._ntotact for j in ndms])
     p_controller.set_nactu(int(nactu))
  
     alt = np.array([p_dms[j].alt for j in p_controller.ndm], dtype=np.float32)
  
     list_dmseen = [p_dms[j].type for j in p_controller.ndm]
     if (p_controller.type == scons.ControllerType.GEO):
         Nphi = np.where(p_geom._spupil)[0].size
     else:
         Nphi = -1
  
     #nslope = np.sum([c._nslope for c in p_centroiders])
     #p_controller.set_nslope(int(nslope))
  
     #TODO : find a proper way to set the number of slope (other than 2 times nvalid)
     rtc.add_controller(context, p_controller.nvalid, p_controller.nslope,
                        p_controller.nactu, p_controller.delay, context.active_device,
                        p_controller.type, dms, p_controller.ndm, p_controller.ndm.size,
                        p_controller.nwfs, p_controller.nwfs.size, Nphi, False,
                        p_controller.nstates)
     print("CONTROLLER ADDED")
     if (p_wfss is not None and do_refslp):
         rtc.do_centroids_ref(i)
  
     if (p_controller.type == scons.ControllerType.GEO):
         init_controller_geo(i, rtc, dms, p_geom, p_controller, p_dms)
  
     if (p_controller.type == scons.ControllerType.LS):
         init_controller_ls(i, p_controller, p_wfss, p_geom, p_dms, p_atmos, ittime,
                            p_tel, rtc, dms, wfs, tel, atmos, dataBase=dataBase,
                            use_DB=use_DB)
  
     if (p_controller.type == scons.ControllerType.CURED):
         init_controller_cured(i, rtc, p_controller, p_dms, p_wfss)
  
     if (p_controller.type == scons.ControllerType.MV):
         init_controller_mv(i, p_controller, p_wfss, p_geom, p_dms, p_atmos, p_tel, rtc,
                            dms, wfs, atmos)
  
     elif (p_controller.type == scons.ControllerType.GENERIC):
         init_controller_generic(i, p_controller, p_dms, rtc)
         try:
             p_controller._imat = imats.imat_geom(wfs, dms, p_wfss, p_dms, p_controller,
                                                  meth=0)
         except:
             print("p_controller._imat not set")
  
  

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_controller_cured()

def shesha.init.rtc_init.init_controller_cured	(	int	i,
		Rtc	rtc,
		conf.Param_controller	p_controller,
		list	p_dms,
		list	p_wfss
	)

Definition at line 525 of file rtc_init.py.

         p_wfss: (list of Param_wfs) : wfs settings
     """
  
     print("initializing cured controller")
     if (scons.DmType.TT in [p_dms[j].type for j in range(len(p_dms))]):
         tt_flag = True
     else:
         tt_flag = False
     rtc.d_control[i].init_cured(p_wfss[0].nxsub, p_wfss[0]._isvalid,
                                 p_controller.cured_ndivs, tt_flag)
     rtc.d_control[i].set_gain(p_controller.gain)
  
  

Here is the caller graph for this function:

◆ init_controller_generic()

def shesha.init.rtc_init.init_controller_generic	(	int	i,
		conf.Param_controller	p_controller,
		list	p_dms,
		Rtc	rtc
	)

Initialize the generic controller.

:parameters: i (int): controller index p_controller (Param_controller): controller settings p_dms (list of Param_dm): dms settings rtc (Rtc): Rtc object

Definition at line 579 of file rtc_init.py.

         rtc: (Rtc): Rtc object
     """
     size = sum([p_dms[j]._ntotact for j in range(len(p_dms))])
     decayFactor = np.ones(size, dtype=np.float32)
     mgain = np.ones(size, dtype=np.float32) * p_controller.gain
     matE = np.identity(size, dtype=np.float32)
     cmat = np.zeros((size, p_controller.nslope), dtype=np.float32)
  
     rtc.d_control[i].set_decayFactor(decayFactor)
     rtc.d_control[i].set_modal_gains(mgain)
     rtc.d_control[i].set_cmat(cmat)
     rtc.d_control[i].set_matE(matE)

Here is the caller graph for this function:

◆ init_controller_geo()

def shesha.init.rtc_init.init_controller_geo	(	int	i,
		Rtc	rtc,
		Dms	dms,
		conf.Param_geom	p_geom,
		conf.Param_controller	p_controller,
		list	p_dms,
			roket = `False`
	)

Initialize geometric controller.

:parameters: i (int): controller index rtc (Rtc): rtc object dms (Dms): Dms object p_geom (Param_geom): geometry settings p_controller (Param_controller): controller settings p_dms (list of Param_dms): dms settings roket (bool): Flag to initialize ROKET

Definition at line 430 of file rtc_init.py.

         roket: (bool): Flag to initialize ROKET
     """
     indx_pup = np.where(p_geom._spupil.flatten('F'))[0].astype(np.int32)
     indx_mpup = np.where(p_geom._mpupil.flatten('F'))[0].astype(np.int32)
     cpt = 0
     indx_dm = np.zeros((p_controller.ndm.size * indx_pup.size), dtype=np.int32)
     for dmn in range(p_controller.ndm.size):
         tmp_s = (p_geom._ipupil.shape[0] - (p_dms[dmn]._n2 - p_dms[dmn]._n1 + 1)) // 2
         tmp_e0 = p_geom._ipupil.shape[0] - tmp_s
         tmp_e1 = p_geom._ipupil.shape[1] - tmp_s
         pup_dm = p_geom._ipupil[tmp_s:tmp_e0, tmp_s:tmp_e1]
         indx_dm[cpt:cpt + np.where(pup_dm)[0].size] = np.where(pup_dm.flatten('F'))[0]
         cpt += np.where(pup_dm)[0].size
     # convert unitpervolt list to a np.ndarray
     unitpervolt = np.array([p_dms[j].unitpervolt
                             for j in range(len(p_dms))], dtype=np.float32)
  
     rtc.d_control[i].init_proj_sparse(dms, indx_dm, unitpervolt, indx_pup, indx_mpup,
                                       roket=roket)
  
  
 def init_controller_ls(i: int, p_controller: conf.Param_controller, p_wfss: list,
                        p_geom: conf.Param_geom, p_dms: list, p_atmos: conf.Param_atmos,
                        ittime: float, p_tel: conf.Param_tel, rtc: Rtc, dms: Dms,
                        wfs: Sensors, tel: Telescope, atmos: Atmos, dataBase: dict = {},
                        use_DB: bool = False):
     """
         Initialize the least square controller
     :parameters:
         i : (int) : controller index
         p_controller: (Param_controller) : controller settings
         p_wfss: (list of Param_wfs) : wfs settings
         p_geom: (Param_geom) : geom settings
         p_dms: (list of Param_dms) : dms settings
         p_atmos: (Param_atmos) : atmos settings
         ittime: (float) : iteration time [s]
         p_tel: (Param_tel) : telescope settings
         rtc: (Rtc) : Rtc objet

Here is the caller graph for this function:

◆ init_controller_ls()

def shesha.init.rtc_init.init_controller_ls	(	int	i,
		conf.Param_controller	p_controller,
		list	p_wfss,
		conf.Param_geom	p_geom,
		list	p_dms,
		conf.Param_atmos	p_atmos,
		float	ittime,
		conf.Param_tel	p_tel,
		Rtc	rtc,
		Dms	dms,
		Sensors	wfs,
		Telescope	tel,
		Atmos	atmos,
		dict	dataBase = `{}`,
		bool	use_DB = `False`
	)

Definition at line 468 of file rtc_init.py.

         dms: (Dms) : Dms object
         wfs: (Sensors) : Sensors object
         tel: (Telescope) : Telescope object
         atmos: (Atmos) : Atmos object
     """
     M2V = None
     if p_controller.do_kl_imat:
         IF = basis.compute_IFsparse(dms, p_dms, p_geom).T
         M2V, _ = basis.compute_btt(IF[:, :-2], IF[:, -2:].toarray())
         print("Filtering ", p_controller.nModesFilt, " modes based on mode ordering")
         M2V = M2V[:, list(range(M2V.shape[1] - 2 - p_controller.nModesFilt)) + [-2, -1]]
  
         if len(p_controller.klpush) == 1:  # Scalar allowed, now we expand
             p_controller.klpush = p_controller.klpush[0] * np.ones(M2V.shape[1])
     imats.imat_init(i, rtc, dms, p_dms, wfs, p_wfss, p_tel, p_controller, M2V,
                     dataBase=dataBase, use_DB=use_DB)
  
     if p_controller.modopti:
         print("Initializing Modal Optimization : ")
         p_controller.nrec = int(2**np.ceil(np.log2(p_controller.nrec)))
         if p_controller.nmodes is None:
             p_controller.nmodes = sum([p_dms[j]._ntotact for j in range(len(p_dms))])
  
         IF = basis.compute_IFsparse(dms, p_dms, p_geom).T
         M2V, _ = basis.compute_btt(IF[:, :-2], IF[:, -2:].toarray())
         M2V = M2V[:, list(range(p_controller.nmodes - 2)) + [-2, -1]]
  
         rtc.d_control[i].init_modalOpti(p_controller.nmodes, p_controller.nrec, M2V,
                                         p_controller.gmin, p_controller.gmax,
                                         p_controller.ngain, 1. / ittime)
         ol_slopes = modopti.open_loopSlp(tel, atmos, wfs, rtc, p_controller.nrec, i,
                                          p_wfss)
         rtc.d_control[i].loadopen_loopSlp(ol_slopes)
         rtc.d_control[i].modalControlOptimization()
     else:
         cmats.cmat_init(i, rtc, p_controller, p_wfss, p_atmos, p_tel, p_dms,
                         nmodes=p_controller.nmodes)
  
         rtc.d_control[i].set_gain(p_controller.gain)
         mgain = np.ones(
                 sum([p_dms[j]._ntotact for j in range(len(p_dms))]), dtype=np.float32)
         cc = 0
         for ndm in p_dms:
             mgain[cc:cc + ndm._ntotact] = ndm.gain
             cc += ndm._ntotact
         rtc.d_control[i].set_modal_gains(mgain)
  
  
 def init_controller_cured(i: int, rtc: Rtc, p_controller: conf.Param_controller,
                           p_dms: list, p_wfss: list):
     """
         Initialize the CURED controller
     :parameters:
         i : (int) : controller index
         rtc: (Rtc) : Rtc objet
         p_controller: (Param_controller) : controller settings
         p_dms: (list of Param_dms) : dms settings

Here is the caller graph for this function:

◆ init_controller_mv()

def shesha.init.rtc_init.init_controller_mv	(	int	i,
		conf.Param_controller	p_controller,
		list	p_wfss,
		conf.Param_geom	p_geom,
		list	p_dms,
		conf.Param_atmos	p_atmos,
		conf.Param_tel	p_tel,
		Rtc	rtc,
		Dms	dms,
		Sensors	wfs,
		Atmos	atmos
	)

Initialize the MV controller.

:parameters: i (int) : controller index p_controller (Param_controller) : controller settings p_wfss (list of Param_wfs) : wfs settings p_geom (Param_geom) : geom settings p_dms (list of Param_dms) : dms settings p_atmos (Param_atmos) : atmos settings p_tel (Param_tel) : telescope settings rtc (Rtc) : Rtc objet dms (Dms) : Dms object wfs (Sensors) : Sensors object atmos (Atmos) : Atmos object

Definition at line 554 of file rtc_init.py.

         dms: (Dms) : Dms object
         wfs: (Sensors) : Sensors object
         atmos: (Atmos) : Atmos object
     """
     p_controller._imat = imats.imat_geom(wfs, dms, p_wfss, p_dms, p_controller)
     # imat_init(i,rtc,p_rtc,dms,wfs,p_wfss,p_tel,clean=1,simul_name=simul_name)
     rtc.d_control[i].set_imat(p_controller._imat)
     rtc.d_control[i].set_gain(p_controller.gain)
     size = sum([p_dms[j]._ntotact for j in range(len(p_dms))])
     mgain = np.ones(size, dtype=np.float32)
     rtc.d_control[i].set_modal_gains(mgain)
     tomo.do_tomo_matrices(i, rtc, p_wfss, dms, atmos, wfs, p_controller, p_geom, p_dms,
                           p_tel, p_atmos)
     cmats.cmat_init(i, rtc, p_controller, p_wfss, p_atmos, p_tel, p_dms)
  
  

Here is the caller graph for this function:

◆ rtc_init()

def shesha.init.rtc_init.rtc_init	(	carmaWrap_context	context,
		Telescope	tel,
		Sensors	wfs,
		Dms	dms,
		Atmos	atmos,
		list	p_wfss,
		conf.Param_tel	p_tel,
		conf.Param_geom	p_geom,
		conf.Param_atmos	p_atmos,
		float	ittime,
			p_centroiders = `None`,
			p_controllers = `None`,
			p_dms = `None`,
			do_refslp = `False`,
			brahma = `False`,
			cacao = `False`,
			tar = `None`,
			dataBase = `{}`,
			use_DB = `False`
	)

Initialize all the SutraRtc objects : centroiders and controllers.

:parameters: context (carmaWrap_context): context tel (Telescope) : Telescope object wfs (Sensors) : Sensors object dms (Dms) : Dms object atmos (Atmos) : Atmos object p_wfss (list of Param_wfs) : wfs settings p_tel (Param_tel) : telescope settings p_geom (Param_geom) : geom settings p_atmos (Param_atmos) : atmos settings ittime (float) : iteration time [s] p_centroiders (list of Param_centroider): (optional) centroiders settings p_controllers (list of Param_controller): (optional) controllers settings p_dms (list of Param_dms) : (optional) dms settings do_refslp (bool): (optional) do ref slopes flag, default=False brahma (bool) : (optional) brahma flag cacao (bool) : (optional) cacao flag tar (Target) : (optional) dataBase (dict): (optional) dict containig paths to files to load use_DB (bool): use dataBase flag :return: Rtc (Rtc) : Rtc object

Definition at line 79 of file rtc_init.py.

         dataBase: (dict): (optional) dict containig paths to files to load
         use_DB: (bool): use dataBase flag
     :return:
         Rtc : (Rtc) : Rtc object
     """
     # initialisation var
     # ________________________________________________
     if brahma:
         rtc = Rtc_brahma(context, wfs, tar, "rtc_brahma")
     elif cacao:
         rtc = Rtc_cacao_FFF("compass_calPix", "compass_loopData")
     else:
         rtc = Rtc()
  
     if p_wfss is None:
         return rtc
  
     if p_centroiders:
         ncentro = len(p_centroiders)
     else:
         ncentro = 0
  
     if p_controllers:
         ncontrol = len(p_controllers)
     else:
         ncontrol = 0
  
     if p_centroiders is not None:
         for i in range(ncentro):
             nwfs = p_centroiders[i].nwfs
             init_centroider(context, nwfs, p_wfss[nwfs], p_centroiders[i], p_tel,
                             p_atmos, wfs, rtc)
  
     if p_controllers is not None:
         if (p_wfss is not None and p_dms is not None):
             for i in range(ncontrol):
                 if not "dm" in dataBase:
                     imat = imats.imat_geom(wfs, dms, p_wfss, p_dms, p_controllers[i],
                                            meth=0)
                 else:
                     imat = None
  
                 if p_dms[0].type == scons.DmType.PZT:
                     dm_init.correct_dm(context, dms, p_dms, p_controllers[i], p_geom,
                                        imat, dataBase=dataBase, use_DB=use_DB)
  
                 init_controller(context, i, p_controllers[i], p_wfss, p_geom, p_dms,
                                 p_atmos, ittime, p_tel, rtc, dms, wfs, tel, atmos,
                                 p_centroiders, do_refslp, dataBase=dataBase,
                                 use_DB=use_DB)
  
             # add a geometric controller for processing error breakdown
             roket_flag = True in [w.roket for w in p_wfss]
             if (roket_flag):
                 p_controller = p_controllers[0]
                 Nphi = np.where(p_geom._spupil)[0].size
  
                 list_dmseen = [p_dms[j].type for j in p_controller.ndm]
                 nactu = np.sum([p_dms[j]._ntotact for j in p_controller.ndm])
  
                 rtc.add_controller(context, p_controller.nvalid, p_controller.nslope,
                                    p_controller.nactu, p_controller.delay,
                                    context.active_device, scons.ControllerType.GEO, dms,
                                    p_controller.ndm, p_controller.ndm.size,
                                    p_controller.nwfs, p_controller.nwfs.size, Nphi, True)
  
                 # rtc.add_controller_geo(context, nactu, Nphi, p_controller.delay,
                 #                        context.active_device, p_controller.type, dms,
                 #                        list_dmseen, p_controller.ndm.size, True)
  
                 # list_dmseen,alt,p_controller.ndm.size
                 init_controller_geo(ncontrol, rtc, dms, p_geom, p_controller, p_dms,
                                     roket=True)
  
     return rtc
  
  
 # MODBY J

Here is the call graph for this function:

◆ rtc_standalone()

Rtc shesha.init.rtc_init.rtc_standalone	(	carmaWrap_context	context,
		int	nwfs,
		list	nvalid,
		int	nactu,
		list	centroider_type,
		list	delay,
		list	offset,
		list	scale,
		bool	brahma = `False`,
		bool	fp16 = `False`,
		bool	cacao = `False`
	)

TODO docstring.

Definition at line 160 of file rtc_init.py.

     """
     TODO docstring
     """
     print("start rtc_standalone")
     if brahma:
         rtc = Rtc_brahma(context, None, None, "rtc_brahma")
     elif cacao:
         if fp16:
             from shesha.sutra_wrap import Rtc_cacao_FHF
             rtc = Rtc_cacao_FHF("compass_calPix", "compass_loopData")
         else:
             rtc = Rtc_cacao_FFF("compass_calPix", "compass_loopData")
     else:
         if fp16:
             from shesha.sutra_wrap import Rtc_FHF
             rtc = Rtc_FHF()
         else:
             rtc = Rtc()
     for k in range(nwfs):
         # print(context, nvalid[k], offset[k], scale[k], False,
         #                 context.active_device, centroider_type[k])
         rtc.add_centroider(context, nvalid[k], offset[k], scale[k], False,
                            context.active_device, centroider_type[k])
  
     nslopes = sum([c.nslopes for c in rtc.d_centro])
     rtc.add_controller(context, sum(nvalid), nslopes, nactu, delay[k],
                        context.active_device, "generic", idx_centro=np.arange(nwfs),
                        ncentro=nwfs)
  
     print("rtc_standalone set")
     return rtc
  
  

Functions

Detailed Description

Function Documentation

◆ comp_weights()

◆ init_centroider()

◆ init_controller()

◆ init_controller_cured()

◆ init_controller_generic()

◆ init_controller_geo()

◆ init_controller_ls()

◆ init_controller_mv()

◆ rtc_init()

◆ rtc_standalone()