Functions
def	loop (n)

def	preloop (n)

def	error_breakdown (com, noise_com, alias_wfs_com, tomo_com, H_com, trunc_com, bp_com, wf_com, mod_com, fit, psf_ortho, i, Ee, Ff, gamma, gRD)

def	centroid_gain (E, F)

def	compute_btt2 ()

def	compute_cmatWithBtt (Btt, nfilt)

def	compute_cmatWithBtt2 (Btt, nfilt)

def	cov_cor (P, noise, trunc, alias, H, bp, tomo)

def	save_it (filename)

Variables
string	error = 'command line should be at least:"python -i test.py parameters_filename"\n with "parameters_filename" the path to the parameters file'

	param_file = sys.argv[1]

	filename = param_file.split('/')[-1]

	param_path = param_file.split(filename)[0]

	savename = sys.argv[2]

string	simul_name = ""

dictionary	matricesToLoad = {}

int	clean = 1

	param_dict = h5u.params_dictionary(config)

	c = ch.carmaWrap_context(devices=np.array([6], dtype=np.int32))

	wfs

	tel

	atm

	dms = ao.dm_init(config.p_dms, config.p_wfss, wfs, config.p_geom, config.p_tel)

	tar

	rtc

bool	error_flag = True in [w.roket for w in config.p_wfss]

	nfiltered = int(config.p_controllers[0].maxcond)
	_ _ \| \|_ ___ ___\| \|_ ___ \| __/ _ \/ __\| __/ __\| \| \|\| __/__ \ \|___ \ _____\|\|___/__\|___/ More...

	niters = config.p_loop.niter

int	N_preloop = 1000

	Btt

	P

	Dm

	cmat

	R = rtc.get_cmat(0)

	imat = rtc.get_imat(0)

	RD = np.dot(R, imat)

	Nact = ao.create_nact_geom(config.p_dms, 0)

int	gamma = 1. / 0.51495

	com

	noise_com = noise_com[N_preloop:, :]

	alias_wfs_com = alias_wfs_com[N_preloop:, :]

	tomo_com = tomo_com[N_preloop:, :]

	H_com = H_com[N_preloop:, :]

	trunc_com = trunc_com[N_preloop:, :]

	bp_com = bp_com[N_preloop:, :]

	wf_com

	fit

	SR

	SR2

	psf_ortho

	E = E[N_preloop:, :]

	F = F[N_preloop:, :]

Function Documentation

◆ centroid_gain()

def roket_cpu.centroid_gain	(	E,
		F
	)

Definition at line 461 of file roket_cpu.py.

 def centroid_gain(E, F):
  
     cgains = np.zeros(E.shape[1])
     for k in range(E.shape[1]):
         cgains[k] = np.polyfit(E[:, k], F[:, k], 1)[0]
  
     return np.mean(cgains)

◆ compute_btt2()

def roket_cpu.compute_btt2 ( )

| _ ) __ _ __(_)___ | _ \/ _` (-< (_-< |___/_,_/__/_/__/

Definition at line 476 of file roket_cpu.py.

 def compute_btt2():
     IF = rtc.get_IFsparse(1).T
     N = IF.shape[0]
     n = IF.shape[1]
     #T = IF[:,-2:].copy()
     T = rtc.get_IFtt(1)
     #IF = IF[:,:n-2]
     n = IF.shape[1]
  
     delta = IF.T.dot(IF).toarray() / N
  
     # Tip-tilt + piston
     Tp = np.ones((T.shape[0], T.shape[1] + 1))
     Tp[:, :2] = T.copy()  #.toarray()
     deltaT = IF.T.dot(Tp) / N
     # Tip tilt projection on the pzt dm
     tau = np.linalg.inv(delta).dot(deltaT)
  
     # Famille generatrice sans tip tilt
     G = np.identity(n)
     tdt = tau.T.dot(delta).dot(tau)
     subTT = tau.dot(np.linalg.inv(tdt)).dot(tau.T).dot(delta)
     G -= subTT
  
     # Base orthonormee sans TT
     gdg = G.T.dot(delta).dot(G)
     U, s, V = np.linalg.svd(gdg)
     U = U[:, :U.shape[1] - 3]
     s = s[:s.size - 3]
     L = np.identity(s.size) / np.sqrt(s)
     B = G.dot(U).dot(L)
  
     # Rajout du TT
     TT = T.T.dot(T) / N  #.toarray()/N
     Btt = np.zeros((n + 2, n - 1))
     Btt[:B.shape[0], :B.shape[1]] = B
     mini = 1. / np.sqrt(np.abs(TT))
     mini[0, 1] = 0
     mini[1, 0] = 0
     Btt[n:, n - 3:] = mini
  
     # Calcul du projecteur actus-->modes
     delta = np.zeros((n + T.shape[1], n + T.shape[1]))
     #IF = rtc.get_IFsparse(1).T
     delta[:-2, :-2] = IF.T.dot(IF).toarray() / N
     delta[-2:, -2:] = T.T.dot(T) / N
     P = Btt.T.dot(delta)
  
     return Btt.astype(np.float32), P.astype(np.float32)
  
  

◆ compute_cmatWithBtt()

def roket_cpu.compute_cmatWithBtt	(	Btt,
		nfilt
	)

Definition at line 527 of file roket_cpu.py.

 def compute_cmatWithBtt(Btt, nfilt):
     D = rtc.get_imat(0)
     #D = ao.imat_geom(wfs,config.p_wfss,config.p_controllers[0],dms,config.p_dms,meth=0)
     # Filtering on Btt modes
     Btt_filt = np.zeros((Btt.shape[0], Btt.shape[1] - nfilt))
     Btt_filt[:, :Btt_filt.shape[1] - 2] = Btt[:, :Btt.shape[1] - (nfilt + 2)]
     Btt_filt[:, Btt_filt.shape[1] - 2:] = Btt[:, Btt.shape[1] - 2:]
  
     # Modal interaction basis
     Dm = D.dot(Btt_filt)
     # Direct inversion
     Dmp = np.linalg.inv(Dm.T.dot(Dm)).dot(Dm.T)
     # Command matrix
     cmat = Btt_filt.dot(Dmp)
  
     return Dm.astype(np.float32), cmat.astype(np.float32)
  
  

◆ compute_cmatWithBtt2()

def roket_cpu.compute_cmatWithBtt2	(	Btt,
		nfilt
	)

Definition at line 545 of file roket_cpu.py.

 def compute_cmatWithBtt2(Btt, nfilt):
     D = rtc.get_imat(0)
  
     # Modal interaction basis
     Dm = D.dot(Btt)
     # Filtering on modal imat
     DmtDm = Dm.T.dot(Dm)
     U, s, V = np.linalg.svd(DmtDm)
     s = 1. / s
     s[s.shape[0] - nfilt - 2:s.shape[0] - 2] = 0.
     DmtDm1 = U.dot(np.diag(s)).dot(U.T)
     Dmp = DmtDm1.dot(Dm.T)
     # Command matrix
     cmat = Btt.dot(Dmp)
  
     return Dm.astype(np.float32), cmat.astype(np.float32)
  
  

◆ cov_cor()

def roket_cpu.cov_cor	(	P,
		noise,
		trunc,
		alias,
		H,
		bp,
		tomo
	)

/ __|_____ ____ _ _ _(_)__ _ _ _ __ ___ / _|___ __ ___ _ _ _ _ ___| |__ _| |_(_)___ _ _ | (__/ _ \ V / _‘ | ’_| / _‘ | ’ \/ _/ -_) > _|_ _| / _/ _ \ '_| '_/ -_) / _‘ | _| / _ \ ’ \ ______/_/__,_|_| |___,_|_||______| _____| _____/_| |_| ___|___,_|__|____/_||_|

Definition at line 572 of file roket_cpu.py.

 def cov_cor(P, noise, trunc, alias, H, bp, tomo):
     cov = np.zeros((6, 6))
     cor = np.zeros((6, 6))
     bufdict = {
             "0": noise.T,
             "1": trunc.T,
             "2": alias.T,
             "3": H.T,
             "4": bp.T,
             "5": tomo.T
     }
     for i in range(cov.shape[0]):
         for j in range(cov.shape[1]):
             if (j >= i):
                 tmpi = P.dot(bufdict[str(i)])
                 tmpj = P.dot(bufdict[str(j)])
                 cov[i, j] = np.sum(
                         np.mean(tmpi * tmpj, axis=1) -
                         np.mean(tmpi, axis=1) * np.mean(tmpj, axis=1))
             else:
                 cov[i, j] = cov[j, i]
  
     s = np.reshape(np.diag(cov), (cov.shape[0], 1))
     sst = np.dot(s, s.T)
     ok = np.where(sst)
     cor[ok] = cov[ok] / np.sqrt(sst[ok])
  
     return cov, cor
  
  

Here is the caller graph for this function:

◆ error_breakdown()

def roket_cpu.error_breakdown	(	com,
		noise_com,
		alias_wfs_com,
		tomo_com,
		H_com,
		trunc_com,
		bp_com,
		wf_com,
		mod_com,
		fit,
		psf_ortho,
		i,
		Ee,
		Ff,
		gamma,
		gRD
	)

| __|_ _ _ _ ___ _ _ | _ )_ _ ___ __ _| |____| |_____ __ ___ _ | _|| '_| '_/ _ \ '_| | _ \ '_/ -_) _| / / _ / _ \ V V / ' \ |___|_| |_| ___/_| |___/_| _____,_|____,____/_/_/|_||_|

Compute the error breakdown of the AO simulation. Returns the error commands of each contributors. Suppose no delay (for now) and only 2 controllers : the main one, controller #0, (specified on the parameter file) and the geometric one, controller #1 (automatically added if roket is asked in the parameter file) Commands are computed by applying the loop filter on various kind of commands : (see schema_simulation_budget_erreur_v2)

- Ageom : Aliasing contribution on WFS direction
    Obtained by computing commands from DM orthogonal phase (projection + slopes_geom)

- B : Projection on the target direction
    Obtained as the commmands output of the geometric controller

- C : Wavefront
    Obtained by computing commands from DM parallel phase (RD*B)

- E : Wavefront + aliasing + ech/trunc + tomo
    Obtained by performing the AO loop iteration without noise on the WFS

- F : Wavefront + aliasing + tomo
    Obtained by performing the AO loop iteration without noise on the WFS and using phase deriving slopes

- G : tomo

Note rtc.get_err returns to -CMAT.slopes

:parameters: noise_com np.array((niter,nactu)) : Noise contribution Computed with com-E

alias_wfs_com np.array((niter,nactu)) : Aliasing on WFS direction contribution Computed with Ageom

tomo_com np.array((niter,nactu)) : Tomographic error contribution Computed with C-B

H_com np.array((niter,nactu)) : Filtered modes error Computed with B

trunc_com np.array((niter,nactu)) : sampling/truncature error contribution Computed with E-F

bp_com np.array((niter,nactu)) : Bandwidth error

wf_com np.array((niter,nactu)) : Reconstructed wavefront

mod_com np.array((niter,nactu)) : commanded modes

fit np.array((niter)) : fitting value

i (int) : current iteration number

Definition at line 334 of file roket_cpu.py.

  
     """
     g = config.p_controllers[0].gain
     Dcom = rtc.get_command(0)
     Derr = rtc.get_err(0)
     com[i, :] = Dcom
     tarphase = tar.get_phase(0)
     ###########################################################################
     ## Noise contribution
     ###########################################################################
     if (config.p_wfss[0].type == b"sh"):
         ideal_bincube = wfs.get_bincubeNotNoisy(0)
         bincube = wfs.get_bincube(0)
         if (config.p_centroiders[0].type == b"tcog"
             ):  # Select the same pixels with or without noise
             invalidpix = np.where(bincube <= config.p_centroiders[0].thresh)
             ideal_bincube[invalidpix] = 0
             rtc.setthresh(0, -1e16)
         wfs.set_bincube(0, ideal_bincube)
     elif (config.p_wfss[0].type == b"pyrhr"):
         ideal_pyrimg = wfs.get_binimg_notnoisy(0)
         wfs.set_pyrimg(0, ideal_pyrimg)
  
     rtc.docentroids(0)
     if (config.p_centroiders[0].type == b"tcog"):
         rtc.setthresh(0, config.p_centroiders[0].thresh)
  
     rtc.docontrol(0)
     E = rtc.get_err(0)
     Ee[i, :] = E
     # Apply loop filter to get contribution of noise on commands
     if (i + 1 < config.p_loop.niter):
         noise_com[i + 1, :] = gRD.dot(noise_com[i, :]) + g * (Derr - E)
  
     ###########################################################################
     ## Sampling/truncature contribution
     ###########################################################################
     rtc.docentroids_geom(0)
     rtc.docontrol(0)
     F = rtc.get_err(0)
     Ff[i, :] = F
     # Apply loop filter to get contribution of sampling/truncature on commands
     if (i + 1 < config.p_loop.niter):
         trunc_com[i + 1, :] = gRD.dot(trunc_com[i, :]) + g * (E - gamma * F)
  
     ###########################################################################
     ## Aliasing contribution on WFS direction
     ###########################################################################
     rtc.docontrol_geo_onwfs(1, dms, wfs, 0)
     rtc.applycontrol(1, dms)
     for w in range(len(config.p_wfss)):
         wfs.sensors_trace(w, "dm", tel, atm, dms)
     """
         wfs.sensors_compimg(0)
     if(config.p_wfss[0].type == b"sh"):
         ideal_bincube = wfs.get_bincubeNotNoisy(0)
         bincube = wfs.get_bincube(0)
         if(config.p_centroiders[0].type == b"tcog"): # Select the same pixels with or without noise
             invalidpix = np.where(bincube <= config.p_centroiders[0].thresh)
             ideal_bincube[invalidpix] = 0
             rtc.setthresh(0,-1e16)
         wfs.set_bincube(0,ideal_bincube)
     elif(config.p_wfss[0].type == b"pyrhr"):
         ideal_pyrimg = wfs.get_binimg_notnoisy(0)
         wfs.set_pyrimg(0,ideal_pyrimg)
     """
     rtc.docentroids_geom(0)
     rtc.docontrol(0)
     Ageom = rtc.get_err(0)
     if (i + 1 < config.p_loop.niter):
         alias_wfs_com[i + 1, :] = gRD.dot(
                 alias_wfs_com[i, :]) + gamma * g * (Ageom)  # - (E-F))
  
     ###########################################################################
     ## Wavefront + filtered modes reconstruction
     ###########################################################################
     tar.atmos_trace(0, atm, tel)
     rtc.docontrol_geo(1, dms, tar, 0)
     B = rtc.get_command(1)
  
     ###########################################################################
     ## Fitting
     ###########################################################################
     rtc.applycontrol(1, dms)
     tar.dmtrace(0, dms, do_phase_var=0)
     fit[i] = tar.get_strehl(0, comp_strehl=False)[2]
     if (i >= N_preloop):
         psf_ortho += tar.get_image(0, 'se') / niters
  
     ###########################################################################
     ## Filtered modes error & Commanded modes
     ###########################################################################
     modes = P.dot(B)
     modes_filt = modes.copy() * 0.
     modes_filt[-nfiltered - 2:-2] = modes[-nfiltered - 2:-2]
     H_com[i, :] = Btt.dot(modes_filt)
     modes[-nfiltered - 2:-2] = 0
     mod_com[i, :] = Btt.dot(modes)
  
     ###########################################################################
     ## Bandwidth error
     ###########################################################################
     C = mod_com[i, :] - mod_com[i - 1, :]
  
     bp_com[i, :] = gRD.dot(bp_com[i - 1, :]) - C
  
     ###########################################################################
     ## Tomographic error
     ###########################################################################
     #G = F - (mod_com[i,:] + Ageom - np.dot(RDgeom,com[i-1,:]))
     for w in range(len(config.p_wfss)):
         wfs.sensors_trace(w, "atmos", tel, atm, dms)
     rtc.docontrol_geo_onwfs(1, dms, wfs, 0)
     G = rtc.get_command(1)
     modes = P.dot(G)
     modes[-nfiltered - 2:-2] = 0
     wf_com[i, :] = Btt.dot(modes)
  
     G = mod_com[i, :] - wf_com[i, :]
     if (i + 1 < config.p_loop.niter):
         tomo_com[i + 1, :] = gRD.dot(tomo_com[i, :]) - g * RD.dot(G)
  
     # Without anyone noticing...
     tar.set_phase(0, tarphase)
     rtc.setCom(0, Dcom)
  
  

Here is the caller graph for this function:

◆ loop()

def roket_cpu.loop ( n )

/_\ / _ \ | |___ ___ _ __ / _ \ (_) | | / _ \/ _ \ '_ \ /_/ ____/ |____/___/ .__/ |_|

Performs the main AO loop for n interations. First, initialize buffers for error breakdown computations. Then, at the end of each iteration, just before applying the new DM shape, calls the error_breakdown function.

:param n: (int) : number of iterations

:return: com (np.array((n,nactus))) : full command buffer

noise_com (np.array((n,nactus))) : noise contribution for error breakdown

alias_wfs_com (np.array((n,nactus))) : aliasing estimation in the WFS direction

tomo_com (np.array((n,nactus))) : tomography error estimation

H_com (np.array((n,nactus))) : Filtered modes contribution for error breakdown

trunc_com (np.array((n,nactus))) : Truncature and sampling error of WFS

bp_com (np.array((n,nactus))) : Bandwidth error estimation on target

mod_com (np.array((n,nactus))) : Commanded modes expressed on the actuators

fit (float) : fitting (mean variance of the residual target phase after projection)

SR (float) : final strehl ratio returned by the simulation

Definition at line 161 of file roket_cpu.py.

     """
     if (error_flag):
         # Initialize buffers for error breakdown
         nactu = rtc.get_command(0).size
         com = np.zeros((n, nactu), dtype=np.float32)
         noise_com = np.zeros((n, nactu), dtype=np.float32)
         alias_wfs_com = np.copy(noise_com)
         wf_com = np.copy(noise_com)
         tomo_com = np.copy(noise_com)
         trunc_com = np.copy(noise_com)
         H_com = np.copy(noise_com)
         mod_com = np.copy(noise_com)
         bp_com = np.copy(noise_com)
         fit = np.zeros(n)
         psf_ortho = tar.get_image(0, 'se') * 0.
         Ee = np.copy(noise_com)
         Ff = np.copy(Ee)
         #gamma = 1.0
         gRD = np.identity(RD.shape[0]) - config.p_controllers[0].gain * gamma * RD
     t0 = time.time()
     for i in range(n):
         atm.move_atmos()
  
         if (config.p_controllers[0].type == b"geo"):
             for t in range(config.p_target.ntargets):
                 tar.atmos_trace(t, atm, tel)
                 rtc.docontrol_geo(0, dms, tar, 0)
                 rtc.applycontrol(0, dms)
                 tar.dmtrace(0, dms)
         else:
             for t in range(config.p_target.ntargets):
                 tar.atmos_trace(t, atm, tel)
                 tar.dmtrace(t, dms)
             for w in range(len(config.p_wfss)):
                 wfs.sensors_trace(w, "all", tel, atm, dms)
                 wfs.sensors_compimg(w)
             rtc.docentroids(0)
             rtc.docontrol(0)
             # if( i%500==0 and i>0):
             #     #gamma = centroid_gain(Ff[i-500:i,:],Ee[i-500:i,:])
             #     gRD = np.identity(RD.shape[0])-config.p_controllers[0].gain*gamma*RD
             if (error_flag and i > -1):
                 #compute the error breakdown for this iteration
                 error_breakdown(com, noise_com, alias_wfs_com, tomo_com, H_com,
                                 trunc_com, bp_com, wf_com, mod_com, fit, psf_ortho, i,
                                 Ee, Ff, gamma, gRD)
  
             rtc.applycontrol(0, dms)
  
         if ((i + 1) % 100 == 0 and i > -1):
             strehltmp = tar.get_strehl(0)
             print(i + 1, "\t", strehltmp[0], "\t", strehltmp[1], "\t",
                   np.exp(-strehltmp[2]), "\t", np.exp(-strehltmp[3]))
     t1 = time.time()
     print(" loop execution time:", t1 - t0, "  (", n, "iterations), ", (t1 - t0) / n,
           "(mean)  ", n / (t1 - t0), "Hz")
     if (error_flag):
         #Returns the error breakdown
         SR2 = np.exp(-tar.get_strehl(0, comp_strehl=False)[3])
         SR = tar.get_strehl(0, comp_strehl=False)[1]
         #bp_com[-1,:] = bp_com[-2,:]
         #SR = tar.get_strehl(0,comp_strehl=False)[1]
         return com, noise_com, alias_wfs_com, tomo_com, H_com, trunc_com, bp_com, mod_com, np.mean(
                 fit[N_preloop:]), SR, SR2, psf_ortho, Ee, Ff
  
  
 def preloop(n):
     """
     Performs the main AO loop for n interations. First, initialize buffers
     for error breakdown computations. Then, at the end of each iteration, just
     before applying the new DM shape, calls the error_breakdown function.
  
     :param n: (int) : number of iterations
  
     :return:
         com : (np.array((n,nactus))) : full command buffer
  
         noise_com : (np.array((n,nactus))) : noise contribution for error breakdown
  
         alias_wfs_com : (np.array((n,nactus))) : aliasing estimation in the WFS direction
  
         tomo_com : (np.array((n,nactus))) : tomography error estimation
  
         H_com : (np.array((n,nactus))) : Filtered modes contribution for error breakdown
  
         trunc_com : (np.array((n,nactus))) : Truncature and sampling error of WFS
  
         bp_com : (np.array((n,nactus))) : Bandwidth error estimation on target
  
         mod_com : (np.array((n,nactus))) : Commanded modes expressed on the actuators
  
         fit : (float) : fitting (mean variance of the residual target phase after projection)
  
         SR : (float) : final strehl ratio returned by the simulation

Here is the call graph for this function:

◆ preloop()

def roket_cpu.preloop ( n )

Definition at line 255 of file roket_cpu.py.

     """
     for i in range(0, n):
         atm.move_atmos()
  
         if (config.p_controllers[0].type == b"geo"):
             for t in range(config.p_target.ntargets):
                 tar.atmos_trace(t, atm, tel)
                 rtc.docontrol_geo(0, dms, tar, 0)
                 rtc.applycontrol(0, dms)
         else:
             for t in range(config.p_target.ntargets):
                 tar.atmos_trace(t, atm, tel)
             for w in range(len(config.p_wfss)):
                 wfs.sensors_trace(w, "all", tel, atm, dms)
                 wfs.sensors_compimg(w)
             rtc.docentroids(0)
             rtc.docontrol(0)
  
             rtc.applycontrol(0, dms)
  
  

◆ save_it()

def roket_cpu.save_it ( filename )

/ __| __ ___ _____ __ \/ _` \ V / -_) |___/__,_|_/___|

Definition at line 610 of file roket_cpu.py.

 def save_it(filename):
     IF = rtc.get_IFsparse(1)
     TT = rtc.get_IFtt(1)
  
     tmp = (config.p_geom._ipupil.shape[0] -
            (config.p_dms[0]._n2 - config.p_dms[0]._n1 + 1)) / 2
     tmp_e0 = config.p_geom._ipupil.shape[0] - tmp
     tmp_e1 = config.p_geom._ipupil.shape[1] - tmp
     pup = config.p_geom._ipupil[tmp:tmp_e0, tmp:tmp_e1]
     indx_pup = np.where(pup.flatten() > 0)[0].astype(np.int32)
     dm_dim = config.p_dms[0]._n2 - config.p_dms[0]._n1 + 1
     cov, cor = cov_cor(P, noise_com, trunc_com, alias_wfs_com, H_com, bp_com, tomo_com)
     psf = tar.get_image(0, "le", fluxNorm=False)
  
     fname = "/home/fferreira/Data/" + filename
     pdict = {
             "noise": noise_com.T,
             "aliasing": alias_wfs_com.T,
             "tomography": tomo_com.T,
             "filtered modes": H_com.T,
             "non linearity": trunc_com.T,
             "bandwidth": bp_com.T,
             "wf_com": wf_com.T,
             "P": P,
             "Btt": Btt,
             "IF.data": IF.data,
             "IF.indices": IF.indices,
             "IF.indptr": IF.indptr,
             "TT": TT,
             "dm_dim": dm_dim,
             "indx_pup": indx_pup,
             "fitting": fit,
             "SR": SR,
             "SR2": SR2,
             "cov": cov,
             "cor": cor,
             "psfortho": np.fft.fftshift(psf_ortho),
             "E": E,
             "F": F,
             "dm.xpos": config.p_dms[0]._xpos,
             "dm.ypos": config.p_dms[0]._ypos,
             "R": cmat,
             "Nact": Nact
     }
     h5u.save_h5(fname, "psf", config, psf)
     #h5u.writeHdf5SingleDataset(fname,com.T,datasetName="com")
     for k in list(pdict.keys()):
         h5u.save_hdf5(fname, k, pdict[k])
  
  

Here is the call graph for this function:

Variable Documentation

◆ alias_wfs_com

roket_cpu.alias_wfs_com = alias_wfs_com[N_preloop:, :]

Definition at line 692 of file roket_cpu.py.

◆ atm

roket_cpu.atm

Initial value:

 =  ao.atmos_init(c, config.p_atmos, config.p_tel, config.p_geom, config.p_loop,
                     config.p_wfss, wfs, config.p_target, rank=0, clean=clean,
                     load=matricesToLoad)

Definition at line 86 of file roket_cpu.py.

◆ bp_com

roket_cpu.bp_com = bp_com[N_preloop:, :]

Definition at line 692 of file roket_cpu.py.

◆ Btt

roket_cpu.Btt

Definition at line 671 of file roket_cpu.py.

◆ c

roket_cpu.c = ch.carmaWrap_context(devices=np.array([6], dtype=np.int32))

Definition at line 76 of file roket_cpu.py.

◆ clean

int roket_cpu.clean = 1

Definition at line 67 of file roket_cpu.py.

◆ cmat

roket_cpu.cmat

Definition at line 673 of file roket_cpu.py.

◆ com

roket_cpu.com

Definition at line 692 of file roket_cpu.py.

◆ Dm

roket_cpu.Dm

Definition at line 673 of file roket_cpu.py.

◆ dms

roket_cpu.dms = ao.dm_init(config.p_dms, config.p_wfss, wfs, config.p_geom, config.p_tel)

Definition at line 92 of file roket_cpu.py.

◆ E

roket_cpu.E = E[N_preloop:, :]

Definition at line 692 of file roket_cpu.py.

◆ error

string roket_cpu.error = 'command line should be at least:"python -i test.py parameters_filename"\n with "parameters_filename" the path to the parameters file'

Definition at line 22 of file roket_cpu.py.

◆ error_flag

bool roket_cpu.error_flag = True in [w.roket for w in config.p_wfss]

Definition at line 123 of file roket_cpu.py.

◆ F

roket_cpu.F = F[N_preloop:, :]

Definition at line 692 of file roket_cpu.py.

◆ filename

roket_cpu.filename = param_file.split('/')[-1]

Definition at line 28 of file roket_cpu.py.

◆ fit

roket_cpu.fit

Definition at line 692 of file roket_cpu.py.

◆ gamma

int roket_cpu.gamma = 1. / 0.51495

Definition at line 679 of file roket_cpu.py.

◆ H_com

roket_cpu.H_com = H_com[N_preloop:, :]

Definition at line 692 of file roket_cpu.py.

◆ imat

roket_cpu.imat = rtc.get_imat(0)

Definition at line 676 of file roket_cpu.py.

◆ matricesToLoad

roket_cpu.matricesToLoad = {}

Definition at line 65 of file roket_cpu.py.

◆ N_preloop

int roket_cpu.N_preloop = 1000

Definition at line 669 of file roket_cpu.py.

◆ Nact

roket_cpu.Nact = ao.create_nact_geom(config.p_dms, 0)

Definition at line 678 of file roket_cpu.py.

◆ nfiltered

roket_cpu.nfiltered = int(config.p_controllers[0].maxcond)

_ _ | |_ ___ ___| |_ ___ | __/ _ \/ __| __/ __| | || __/__ \ |___ \ _____||___/__|___/

Definition at line 667 of file roket_cpu.py.

◆ niters

roket_cpu.niters = config.p_loop.niter

Definition at line 668 of file roket_cpu.py.

◆ noise_com

roket_cpu.noise_com = noise_com[N_preloop:, :]

Definition at line 692 of file roket_cpu.py.

◆ P

roket_cpu.P

Definition at line 671 of file roket_cpu.py.

◆ param_dict

roket_cpu.param_dict = h5u.params_dictionary(config)

Definition at line 70 of file roket_cpu.py.

◆ param_file

roket_cpu.param_file = sys.argv[1]

Definition at line 26 of file roket_cpu.py.

◆ param_path

roket_cpu.param_path = param_file.split(filename)[0]

Definition at line 29 of file roket_cpu.py.

◆ psf_ortho

roket_cpu.psf_ortho

Definition at line 692 of file roket_cpu.py.

◆ R

roket_cpu.R = rtc.get_cmat(0)

Definition at line 675 of file roket_cpu.py.

◆ RD

roket_cpu.RD = np.dot(R, imat)

Definition at line 677 of file roket_cpu.py.

◆ rtc

roket_cpu.rtc

Initial value:

 =  ao.rtc_init(tel, wfs, config.p_wfss, dms, config.p_dms, config.p_geom,
                   config.p_rtc, config.p_atmos, atm, config.p_tel, config.p_loop,
                   clean=clean, simul_name=simul_name, load=matricesToLoad)

Definition at line 101 of file roket_cpu.py.

◆ savename

string roket_cpu.savename = sys.argv[2]

Definition at line 44 of file roket_cpu.py.

◆ simul_name

string roket_cpu.simul_name = ""

(_)_ __ (_) |_ ___ | | '_ | | __/ __| | | | | | | |___ \ |_|_| |_|_|__|___/

Definition at line 58 of file roket_cpu.py.

◆ SR

roket_cpu.SR

Definition at line 692 of file roket_cpu.py.

◆ SR2

roket_cpu.SR2

Definition at line 692 of file roket_cpu.py.

◆ tar

roket_cpu.tar

Initial value:

1 = ao.target_init(c, tel, config.p_target, config.p_atmos, config.p_geom,

2 config.p_tel, config.p_dms)

Definition at line 96 of file roket_cpu.py.

◆ tel

roket_cpu.tel

Definition at line 81 of file roket_cpu.py.

◆ tomo_com

roket_cpu.tomo_com = tomo_com[N_preloop:, :]

Definition at line 692 of file roket_cpu.py.

◆ trunc_com

roket_cpu.trunc_com = trunc_com[N_preloop:, :]

Definition at line 692 of file roket_cpu.py.

◆ wf_com

roket_cpu.wf_com

Definition at line 692 of file roket_cpu.py.

◆ wfs

roket_cpu.wfs

Definition at line 81 of file roket_cpu.py.

Functions

Variables

Function Documentation

◆ centroid_gain()

◆ compute_btt2()

◆ compute_cmatWithBtt()

◆ compute_cmatWithBtt2()

◆ cov_cor()

◆ error_breakdown()

◆ loop()

◆ preloop()

◆ save_it()

Variable Documentation

◆ alias_wfs_com

◆ atm

◆ bp_com

◆ Btt

◆ c

◆ clean

◆ cmat

◆ com

◆ Dm

◆ dms

◆ E

◆ error

◆ error_flag

◆ F

◆ filename

◆ fit

◆ gamma

◆ H_com

◆ imat

◆ matricesToLoad

◆ N_preloop

◆ Nact

◆ nfiltered

◆ niters

◆ noise_com

◆ P

◆ param_dict

◆ param_file

◆ param_path

◆ psf_ortho

◆ R

◆ RD

◆ rtc

◆ savename

◆ simul_name

◆ SR

◆ SR2

◆ tar

◆ tel

◆ tomo_com

◆ trunc_com

◆ wf_com

◆ wfs