Functions
def	compute_psf (filename)

def	compute_psf_independence (filename)

def	compute_and_compare_PSFs (filename, plot=False)

def	filter_piston_TT (filename, C)

def	filter_TT (filename, C)

def	compute_covariance_model (filename)

def	add_TT_model (filename, Ccov)

def	load_datas (files)

def	ensquare_PSF (filename, psf, N, display=False)

def	cutsPSF (filename, psf, psfs)

def	Hcor (f, Fe, g, dt)

def	Hretard (f, Fe, g, dt)

def	compareTransferFunctions (filename)

Variables
dictionary	font = {'family': 'normal', 'weight': 'bold', 'size': 22}

string	datapath = '/home/fferreira/Data/correlation/'

	filenames = glob.glob(datapath + 'roket_8m_1layer_dir*_cpu.h5')

list	files = []

	tabx

	taby

	nfiles = len(filenames)

	theta = np.zeros(nfiles)

	speeds = np.zeros(nfiles)

	gain = np.zeros(nfiles)

	SRcompass = np.zeros(nfiles)

	SRroket = np.zeros(nfiles)

	SRi = np.zeros(nfiles)

	fROKET = h5py.File('ROKETStudy.h5', 'r')

	psfr = fROKET["psf"][:]

	psfi = fROKET["psfi"][:]

	nrjcompass = np.zeros(nfiles)

	nrjroket = np.zeros(nfiles)

	nrji = np.zeros(nfiles)

int	ind = 0

	f = h5py.File('corStudy_Nact.h5', 'r')

	psf = f["psf"][:]

	psfs = f["psfs"][:]

	nrj = f["nrj5"][:]

	nrjs = f["nrj5s"][:]

	SR = np.max(psf, axis=(0, 1))

	SRs = np.max(psfs, axis=(0, 1))

list	colors = ["blue", "red", "green"]

int	k = 0

list	c = colors[i]

	v = np.unique(speeds)[i]

	color

	s

	loc

Function Documentation

◆ add_TT_model()

def correlation_study.add_TT_model	(	filename,
		Ccov
	)

Definition at line 246 of file correlation_study.py.

 def add_TT_model(filename, Ccov):
     C = np.zeros((Ccov.shape[0] + 2, Ccov.shape[0] + 2))
     IF, T = rexp.get_IF(filename)
     IF = IF.T
     T = T.T
     N = IF.shape[0]
     deltaTT = T.T.dot(T) / N
     deltaF = IF.T.dot(T) / N
     pzt2tt = np.linalg.inv(deltaTT).dot(deltaF.T)
  
     CTT = Ccov - filter_TT(filename, Ccov)
     C[-2:, -2:] = pzt2tt.dot(CTT).dot(pzt2tt.T)
     C[:-2, :-2] = Ccov
  
     return C
  
  

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compareTransferFunctions()

def correlation_study.compareTransferFunctions ( filename )

Definition at line 373 of file correlation_study.py.

 def compareTransferFunctions(filename):
     rfile = h5py.File(filename, 'r')
     v = rfile.attrs["windspeed"][0]
     dt = rfile.attrs["ittime"]
     Fe = 1 / dt
     g = rfile.attrs["gain"]
     Lambda_tar = rfile.attrs["target.Lambda"][0]
     Lambda_wfs = rfile.attrs["wfs.Lambda"][0]
     r0 = rfile.attrs["r0"] * (Lambda_tar / Lambda_wfs)**(6. / 5.)
     d = rfile.attrs["tel_diam"] / rfile.attrs["nxsub"]
     fc = 0.314 * v / d
     f = np.linspace(0.1, fc * 1.5, 1000)
     H = Hcor(f, Fe, g, dt)
     Hr = Hretard(f, Fe, g, dt)
     plt.figure()
     plt.plot(f, H)
     plt.plot(f, Hr, color="red")
     plt.plot([fc, fc], [H.min(), Hr.max()])
     rfile.close()
  
  

Here is the call graph for this function:

◆ compute_and_compare_PSFs()

def correlation_study.compute_and_compare_PSFs	(	filename,
		plot = `False`
	)

Definition at line 37 of file correlation_study.py.

 def compute_and_compare_PSFs(filename, plot=False):
     f = h5py.File(filename, 'r')
     psf_compass = np.fft.fftshift(f["psf"][:])
     #psf = compute_psf(filename)
     #psfi = compute_psf_independence(filename)
     psfc = 0
     psfs = 0
     tic = time.time()
     Caniso, Cbp, Ccov = compute_covariance_model(filename)
  
     Nact = f["Nact"][:]
     N1 = np.linalg.inv(Nact)
     Caniso = N1.dot(Caniso).dot(N1)
     Cbp = N1.dot(Cbp).dot(N1)
     Ccov = N1.dot(Ccov).dot(N1)
  
     Ccov_filtered = filter_piston_TT(filename, Ccov)
     Ctt = add_TT_model(filename, Ccov)
     Ctt[:-2, :-2] = Ccov_filtered
     Ctt = Ctt + Ctt.T
     Caniso_filtered = filter_piston_TT(filename, Caniso)
     tmp = add_TT_model(filename, Caniso)
     tmp[:-2, :-2] = Caniso_filtered
     Ctt += tmp
     Cbp_filtered = filter_piston_TT(filename, Cbp)
     tmp = add_TT_model(filename, Cbp)
     tmp[:-2, :-2] = Cbp_filtered
     Ctt += tmp
     #contributors = ["noise","aliasing","non linearity","filtered modes"]
     #cov_err = rexp.get_coverr_independence_contributors(filename,contributors)
     P = f["P"][:]
     cov_err = P.dot(Ctt).dot(P.T)
     otftels, otf2s, psfs, gpu = gamora.psf_rec_Vii(filename, fitting=False,
                                                    cov=cov_err.astype(np.float32))
     tac = time.time()
     print("PSF estimated in ", tac - tic, " seconds")
     t = f["tomography"][:]
     b = f["bandwidth"][:]
     tb = t + b
     tb = tb.dot(tb.T) / float(tb.shape[1])
     cov_err = P.dot(tb).dot(P.T)
     otftel, otf2, psf, gpu = gamora.psf_rec_Vii(filename, fitting=False,
                                                 cov=cov_err.astype(np.float32))
     if (plot):
         Lambda_tar = f.attrs["target.Lambda"][0]
         RASC = 180 / np.pi * 3600.
         pixsize = Lambda_tar * 1e-6 / (
                 psf.shape[0] * f.attrs["tel_diam"] / f.attrs["pupdiam"]) * RASC
         x = (np.arange(psf.shape[0]) - psf.shape[0] / 2) * pixsize / (
                 Lambda_tar * 1e-6 / f.attrs["tel_diam"] * RASC)
         plt.figure()
         plt.subplot(2, 1, 1)
         plt.semilogy(x, psf[psf.shape[0] / 2, :], color="blue")
         plt.semilogy(x, psfs[psf.shape[0] / 2, :], color="red")
         plt.xlabel("X-axis angular distance [units of lambda/D]")
         plt.ylabel("Normalized intensity")
         plt.legend(["PSF exp", "PSF model"])
  
         #plt.semilogy(x,psf_compass[psf.shape[0]/2,:],color="red")
         plt.legend(["PSF exp", "PSF model"])
         plt.subplot(2, 1, 2)
         plt.semilogy(x, psf[:, psf.shape[0] / 2], color="blue")
         plt.semilogy(x, psfs[:, psf.shape[0] / 2], color="red")
         plt.xlabel("Y-axis angular distance [units of lambda/D]")
         plt.ylabel("Normalized intensity")
  
         #plt.semilogy(x,psf_compass[psf.shape[0]/2,:],color="red")
         plt.legend(["PSF exp", "PSF model"])
     '''
     if(correction):
         #plt.semilogy(x,psfc[psf.shape[0]/2,:],color="purple")
         if(synth):
             plt.semilogy(x,psfs[psf.shape[0]/2,:],color="black")
             #plt.legend(["PSF rec","PSF ind. assumption", "PSF COMPASS", "PSF corrected", "PSF synth"])
             plt.legend(["PSF rec","PSF ind. assumption", "PSF COMPASS", "PSF synth"])
         else:
             plt.legend(["PSF rec","PSF ind. assumption", "PSF COMPASS", "PSF corrected"])
     elif(synth):
         plt.semilogy(x,psfs[psf.shape[0]/2,:],color="purple")
         plt.legend(["PSF rec","PSF ind. assumption", "PSF COMPASS", "PSF synth"])
  
     else:
         plt.legend(["PSF rec","PSF ind. assumption", "PSF COMPASS"])
     '''
  
     f.close()
     return psf_compass, psf, psfs
  
  

Here is the call graph for this function:

◆ compute_covariance_model()

def correlation_study.compute_covariance_model ( filename )

Definition at line 173 of file correlation_study.py.

 def compute_covariance_model(filename):
     f = h5py.File(filename, 'r')
     Lambda_tar = f.attrs["target.Lambda"][0]
     Lambda_wfs = f.attrs["wfs.Lambda"]
     dt = f.attrs["ittime"]
     gain = f.attrs["gain"]
     wxpos = f.attrs["wfs.xpos"][0]
     wypos = f.attrs["wfs.ypos"][0]
     r0 = f.attrs["r0"] * (Lambda_tar / Lambda_wfs)**(6. / 5.)
     RASC = 180. / np.pi * 3600.
     xpos = f["dm.xpos"][:]
     ypos = f["dm.ypos"][:]
     p2m = f.attrs["tel_diam"] / f.attrs["pupdiam"]
     pupshape = int(2**np.ceil(np.log2(f.attrs["pupdiam"]) + 1))
     xactu = (xpos - pupshape / 2) * p2m
     yactu = (ypos - pupshape / 2) * p2m
     Ccov = np.zeros((xpos.size, xpos.size))
     Caniso = np.zeros((xpos.size, xpos.size))
     Cbp = np.zeros((xpos.size, xpos.size))
     xx = np.tile(xactu, (xactu.shape[0], 1))
     yy = np.tile(yactu, (yactu.shape[0], 1))
     xij = xx - xx.T
     yij = yy - yy.T
  
     for l in range(f.attrs["nscreens"]):
         H = f.attrs["atm.alt"][l]
         L0 = f.attrs["L0"][l]
         speed = f.attrs["windspeed"][l]
         theta = f.attrs["winddir"][l] * np.pi / 180.
         frac = f.attrs["frac"][l]
  
         Htheta = np.linalg.norm([wxpos, wypos]) / RASC * H
         vdt = speed * dt / gain
         # Covariance matrices models on actuators space
         M = np.zeros((xpos.size, xpos.size))
         Mvdt = M.copy()
         Mht = M.copy()
         Mhvdt = M.copy()
         angleht = np.arctan2(wypos, wxpos)
         fc = xactu[1] - xactu[0]
         #fc = 0.05
  
         M = np.linalg.norm([xij, yij], axis=0)
         Mvdt = np.linalg.norm([xij - vdt * np.cos(theta), yij - vdt * np.sin(theta)],
                               axis=0)
         Mht = np.linalg.norm(
                 [xij - Htheta * np.cos(angleht), yij - Htheta * np.sin(angleht)], axis=0)
         Mhvdt = np.linalg.norm([
                 xij - vdt * np.cos(theta) - Htheta * np.cos(angleht),
                 yij - vdt * np.sin(theta) - Htheta * np.sin(angleht)
         ], axis=0)
         # for i in range(xpos.size):
         #     for j in range(xpos.size):
         #         Mvdt[i,j] = (np.sqrt((xactu[i]-(xactu[j]-vdt*np.cos(theta)))**2 + (yactu[i]-(yactu[j]-vdt*np.sin(theta)))**2))
         #         M[i,j] = (np.sqrt((xactu[i]-xactu[j])**2 + (yactu[i]-yactu[j])**2))
         #         Mht[i,j] = (np.sqrt((xactu[i]-(xactu[j]-Htheta*np.cos(angleht)))**2 + (yactu[i]-(yactu[j]-Htheta*np.sin(angleht)))**2))
         #         #Mhvdt[i,j] = (np.sqrt((xactu[i]-(xactu[j]+rho*np.cos(anglehvdt)))**2 + (yactu[i]-(yactu[j]+rho*np.sin(anglehvdt)))**2))
         #         Mhvdt[i,j] = (np.sqrt(((xactu[i]+vdt*np.cos(theta))-(xactu[j]-Htheta*np.cos(angleht)))**2 + ((yactu[i]+vdt*np.sin(theta))-(yactu[j]-Htheta*np.sin(angleht)))**2))
  
         Ccov +=  0.5 * (Dphi.dphi_lowpass(Mhvdt,fc,L0,tabx,taby) - Dphi.dphi_lowpass(Mht,fc,L0,tabx,taby) \
                 - Dphi.dphi_lowpass(Mvdt,fc,L0,tabx,taby) + Dphi.dphi_lowpass(M,fc,L0,tabx,taby)) * (1./r0)**(5./3.) * frac
  
         Caniso += 0.5 * (Dphi.dphi_lowpass(Mht, fc, L0, tabx, taby) - Dphi.dphi_lowpass(
                 M, fc, L0, tabx, taby)) * (1. / r0)**(5. / 3.) * frac
         Cbp += 0.5 * (Dphi.dphi_lowpass(Mvdt, fc, L0, tabx, taby) - Dphi.dphi_lowpass(
                 M, fc, L0, tabx, taby)) * (1. / r0)**(5. / 3.) * frac
  
     #Sp = (f.attrs["tel_diam"]/f.attrs["nxsub"])**2/2.
     Sp = (Lambda_tar / (2 * np.pi))**2  #/3.45
     f.close()
     return (Caniso + Caniso.T) * Sp, (Cbp + Cbp.T) * Sp, Ccov * Sp
  
  

Here is the caller graph for this function:

◆ compute_psf()

def correlation_study.compute_psf ( filename )

Definition at line 26 of file correlation_study.py.

 def compute_psf(filename):
     otftel, otf, psf, gpu = gamora.psf_rec_Vii(filename)
     return psf
  
  

◆ compute_psf_independence()

def correlation_study.compute_psf_independence ( filename )

Definition at line 31 of file correlation_study.py.

 def compute_psf_independence(filename):
     cov_err = rexp.get_coverr_independence(filename)
     otfteli, otf2i, psfi, gpu = gamora.psf_rec_Vii(filenames[11], covmodes=cov_err)
     return psfi
  
  

◆ cutsPSF()

def correlation_study.cutsPSF	(	filename,
		psf,
		psfs
	)

Definition at line 335 of file correlation_study.py.

 def cutsPSF(filename, psf, psfs):
     f = h5py.File(filename, 'r')
     Lambda_tar = f.attrs["target.Lambda"][0]
     RASC = 180 / np.pi * 3600.
     pixsize = Lambda_tar * 1e-6 / (
             psf.shape[0] * f.attrs["tel_diam"] / f.attrs["pupdiam"]) * RASC
     x = (np.arange(psf.shape[0]) - psf.shape[0] / 2) * pixsize / (
             Lambda_tar * 1e-6 / f.attrs["tel_diam"] * RASC)
     plt.figure()
     plt.subplot(2, 1, 1)
     plt.semilogy(x, psf[psf.shape[0] / 2, :], color="blue")
     plt.semilogy(x, psfs[psf.shape[0] / 2, :], color="red")
     plt.xlabel("X-axis angular distance [units of lambda/D]")
     plt.ylabel("Normalized intensity")
     plt.legend(["PSF exp", "PSF model"])
     plt.xlim(-20, 20)
     plt.ylim(1e-5, 1)
     plt.subplot(2, 1, 2)
     plt.semilogy(x, psf[:, psf.shape[0] / 2], color="blue")
     plt.semilogy(x, psfs[:, psf.shape[0] / 2], color="red")
     plt.xlabel("Y-axis angular distance [units of lambda/D]")
     plt.ylabel("Normalized intensity")
     plt.legend(["PSF exp", "PSF model"])
     plt.xlim(-20, 20)
     plt.ylim(1e-5, 1)
     f.close()
  
  

◆ ensquare_PSF()

def correlation_study.ensquare_PSF	(	filename,
		psf,
		N,
		display = `False`
	)

Definition at line 313 of file correlation_study.py.

 def ensquare_PSF(filename, psf, N, display=False):
     f = h5py.File(filename, 'r')
     Lambda_tar = f.attrs["target.Lambda"][0]
     RASC = 180 / np.pi * 3600.
     pixsize = Lambda_tar * 1e-6 / (
             psf.shape[0] * f.attrs["tel_diam"] / f.attrs["pupdiam"]) * RASC
     x = (np.arange(psf.shape[0]) - psf.shape[0] / 2) * pixsize / (
             Lambda_tar * 1e-6 / f.attrs["tel_diam"] * RASC)
     w = int(N * (Lambda_tar * 1e-6 / f.attrs["tel_diam"] * RASC) / pixsize)
     mid = psf.shape[0] / 2
     psfe = psf[mid - w:mid + w, mid - w:mid + w]
     if (display):
         plt.matshow(np.log10(psfe))
         xt = np.linspace(0, psfe.shape[0] - 1, 6).astype(np.int32)
         yt = np.linspace(-N, N, 6).astype(np.int32)
         plt.xticks(xt, yt)
         plt.yticks(xt, yt)
  
     f.close()
     return psf[mid - w:mid + w, mid - w:mid + w]
  
  

◆ filter_piston_TT()

def correlation_study.filter_piston_TT	(	filename,
		C
	)

Definition at line 126 of file correlation_study.py.

 def filter_piston_TT(filename, C):
     IF, T = rexp.get_IF(filename)
     IF = IF.T
     T = T.T
     N = IF.shape[0]
     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
  
     return G.T.dot(C).dot(G)
  
  

Here is the caller graph for this function:

◆ filter_TT()

def correlation_study.filter_TT	(	filename,
		C
	)

Definition at line 151 of file correlation_study.py.

 def filter_TT(filename, C):
     IF, T = rexp.get_IF(filename)
     IF = IF.T
     T = T.T
     N = IF.shape[0]
     n = IF.shape[1]
  
     delta = IF.T.dot(IF).toarray() / N
  
     deltaT = IF.T.dot(T) / 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
  
     return G.T.dot(C).dot(G)
  
  

Here is the caller graph for this function:

◆ Hcor()

def correlation_study.Hcor	(	f,
		Fe,
		g,
		dt
	)

Definition at line 363 of file correlation_study.py.

 def Hcor(f, Fe, g, dt):
     p = 1j * 2 * np.pi * f
     return np.abs(1 / (1 + g * Fe / p * np.exp(-dt * p)))**2
  
  

Here is the caller graph for this function:

◆ Hretard()

def correlation_study.Hretard	(	f,
		Fe,
		g,
		dt
	)

Definition at line 368 of file correlation_study.py.

 def Hretard(f, Fe, g, dt):
     p = 1j * 2 * np.pi * f
     return np.abs(1 - np.exp(-p * dt / g))**2
  
  

Here is the caller graph for this function:

◆ load_datas()

def correlation_study.load_datas ( files )

Definition at line 263 of file correlation_study.py.

 def load_datas(files):
     nmodes = (files[0])["P"][:].shape[0]
     P = (files[0])["P"][:]
     xpos = files[0].attrs["wfs.xpos"][0]
     ypos = files[0].attrs["wfs.ypos"][0]
     contributors = ["tomography", "bandwidth"]
     Lambda_tar = files[0].attrs["target.Lambda"][0]
     Lambda_wfs = files[0].attrs["wfs.Lambda"][0]
     L0 = files[0].attrs["L0"][0]
     dt = files[0].attrs["ittime"]
     H = files[0].attrs["atm.alt"][0]
     RASC = 180 / np.pi * 3600.
     Htheta = np.linalg.norm(
             [xpos, ypos]
     ) / RASC * H  # np.sqrt(2)*4/RASC*H # Hardcoded for angular separation of sqrt(2)*4 arcsec
     r0 = files[0].attrs["r0"] * (Lambda_tar / Lambda_wfs)**(6. / 5.)
     nfiles = len(files)
     vartomo = np.zeros((nfiles, nmodes))
     varbp = np.zeros((nfiles, nmodes))
     vartot = np.zeros((nfiles, nmodes))
     theta = np.zeros(nfiles)
     speeds = np.zeros(nfiles)
     gain = np.zeros(nfiles)
     # data[:,0,i] = var(tomo+bp) for file #i
     # data[:,1,i] = var(tomo) for file #i
     # data[:,2,i] = var(bp) for file #i
     # data[:,3,i] = var(tomo)+var(bp) for file #i
     ind = 0
     print("Loading data...")
     for f in files:
         vartot[ind, :] = rexp.variance(f, contributors) * ((2 * np.pi / Lambda_tar)**2)
         vartomo[ind, :] = rexp.variance(f, ["tomography"]) * (
                 (2 * np.pi / Lambda_tar)**2)
         varbp[ind, :] = rexp.variance(f, ["bandwidth"]) * ((2 * np.pi / Lambda_tar)**2)
         theta[ind] = f.attrs["winddir"][0]
         speeds[ind] = f.attrs["windspeed"][0]
         gain[ind] = float('%.1f' % f.attrs["gain"][0])
         ind += 1
         print(ind, "/", len(files))
  
     covar = (vartot - (vartomo + varbp)) / 2.
  
     stot = np.sum(vartot, axis=1)
     sbp = np.sum(varbp, axis=1)
     stomo = np.sum(vartomo, axis=1)
     scov = np.sum(covar, axis=1)
  
     return stot, sbp, stomo, scov, covar
  
  

Variable Documentation

◆ c

correlation_study.c = colors[i]

Definition at line 487 of file correlation_study.py.

◆ color

correlation_study.color

Definition at line 490 of file correlation_study.py.

◆ colors

list correlation_study.colors = ["blue", "red", "green"]

Definition at line 480 of file correlation_study.py.

◆ datapath

string correlation_study.datapath = '/home/fferreira/Data/correlation/'

Definition at line 394 of file correlation_study.py.

◆ f

correlation_study.f = h5py.File('corStudy_Nact.h5', 'r')

Definition at line 472 of file correlation_study.py.

◆ filenames

correlation_study.filenames = glob.glob(datapath + 'roket_8m_1layer_dir*_cpu.h5')

Definition at line 395 of file correlation_study.py.

◆ files

list correlation_study.files = []

Definition at line 396 of file correlation_study.py.

◆ font

dictionary correlation_study.font = {'family': 'normal', 'weight': 'bold', 'size': 22}

Definition at line 21 of file correlation_study.py.

◆ fROKET

correlation_study.fROKET = h5py.File('ROKETStudy.h5', 'r')

Definition at line 409 of file correlation_study.py.

◆ gain

correlation_study.gain = np.zeros(nfiles)

Definition at line 405 of file correlation_study.py.

◆ ind

correlation_study.ind = 0

Definition at line 416 of file correlation_study.py.

◆ k

int correlation_study.k = 0

Definition at line 482 of file correlation_study.py.

◆ loc

correlation_study.loc

Definition at line 491 of file correlation_study.py.

◆ nfiles

correlation_study.nfiles = len(filenames)

Definition at line 402 of file correlation_study.py.

◆ nrj

correlation_study.nrj = f["nrj5"][:]

Definition at line 475 of file correlation_study.py.

◆ nrjcompass

correlation_study.nrjcompass = np.zeros(nfiles)

Definition at line 412 of file correlation_study.py.

◆ nrji

correlation_study.nrji = np.zeros(nfiles)

Definition at line 414 of file correlation_study.py.

◆ nrjroket

correlation_study.nrjroket = np.zeros(nfiles)

Definition at line 413 of file correlation_study.py.

◆ nrjs

correlation_study.nrjs = f["nrj5s"][:]

Definition at line 476 of file correlation_study.py.

◆ psf

correlation_study.psf = f["psf"][:]

Definition at line 473 of file correlation_study.py.

◆ psfi

correlation_study.psfi = fROKET["psfi"][:]

Definition at line 411 of file correlation_study.py.

◆ psfr

correlation_study.psfr = fROKET["psf"][:]

Definition at line 410 of file correlation_study.py.

◆ psfs

correlation_study.psfs = f["psfs"][:]

Definition at line 474 of file correlation_study.py.

◆ s

correlation_study.s

Definition at line 490 of file correlation_study.py.

◆ speeds

correlation_study.speeds = np.zeros(nfiles)

Definition at line 404 of file correlation_study.py.

◆ SR

correlation_study.SR = np.max(psf, axis=(0, 1))

Definition at line 477 of file correlation_study.py.

◆ SRcompass

correlation_study.SRcompass = np.zeros(nfiles)

Definition at line 406 of file correlation_study.py.

◆ SRi

correlation_study.SRi = np.zeros(nfiles)

Definition at line 408 of file correlation_study.py.

◆ SRroket

correlation_study.SRroket = np.zeros(nfiles)

Definition at line 407 of file correlation_study.py.

◆ SRs

correlation_study.SRs = np.max(psfs, axis=(0, 1))

Definition at line 478 of file correlation_study.py.

◆ tabx

correlation_study.tabx

Definition at line 400 of file correlation_study.py.

◆ taby

correlation_study.taby

Definition at line 400 of file correlation_study.py.

◆ theta

correlation_study.theta = np.zeros(nfiles)

Definition at line 403 of file correlation_study.py.

◆ v

correlation_study.v = np.unique(speeds)[i]

Definition at line 488 of file correlation_study.py.

Functions

Variables

Function Documentation

◆ add_TT_model()

◆ compareTransferFunctions()

◆ compute_and_compare_PSFs()

◆ compute_covariance_model()

◆ compute_psf()

◆ compute_psf_independence()

◆ cutsPSF()

◆ ensquare_PSF()

◆ filter_piston_TT()

◆ filter_TT()

◆ Hcor()

◆ Hretard()

◆ load_datas()

Variable Documentation

◆ c

◆ color

◆ colors

◆ datapath

◆ f

◆ filenames

◆ files

◆ font

◆ fROKET

◆ gain

◆ ind

◆ k

◆ loc

◆ nfiles

◆ nrj

◆ nrjcompass

◆ nrji

◆ nrjroket

◆ nrjs

◆ psf

◆ psfi

◆ psfr

◆ psfs

◆ s

◆ speeds

◆ SR

◆ SRcompass

◆ SRi

◆ SRroket

◆ SRs

◆ tabx

◆ taby

◆ theta

◆ v