#! /usr/bin/env python3 # -*- coding: iso-8859-15 -*- import matplotlib as mpl mpl.use('Agg') # necessary to be able to generate the reports even without X server #import matplotlib.pyplot as plt import sys import datetime import numpy as np from . import gravi_visual_class def get_reg_number(regnames,base,pola): # pola = 'S','P' or 'C' base_order=["12","13","14","23","24","34"] base_inv=["21","31","41","32","42","43"] noutputs = regnames.shape[0] regbase = [] regabcd = [] regpola = [] for output in range(0,noutputs): regbase.append(''.join(list(str(regnames[output]))[0:2])) # baseline number regabcd.append(list(str(regnames[output]))[3]) # ABCD output regpola.append(list(str(regnames[output]))[5]) # polarization reg = [] for output in range(0,noutputs): if ((regbase[output] == base_order[base]) or (regbase[output] == base_inv[base])): if (regabcd[output] == "A"): if (regpola[output] == pola): reg.append(output) if (regabcd[output] == "B"): if (regpola[output] == pola): reg.append(output) if (regabcd[output] == "C"): if (regpola[output] == pola): reg.append(output) if (regabcd[output] == "D"): if (regpola[output] == pola): reg.append(output) return reg #============================================================================== # Computation of statistics on the beam combiners #============================================================================== def combiner_stats (p2vm,base_list): nbase = 6 # number of baselines ntel = 4 nregion = p2vm.coherence_sc.shape[0] # number of regions (48 or 24, valid for sc and ft) # Science combiner # ---------------------------------------------------------- #print get_reg_number(p2vm.regname_sc,0,'S') # returns ABCD indices in the region table #print p2vm.coherence_sc.shape # region, baseline, wavelength if p2vm.polarsplitSC == True: coherence_sc=np.zeros((nregion, p2vm.nwave_sc), dtype='d') # region, wavelength, polarization (0 or 1) for split coherence_sc_s=np.zeros((nregion, p2vm.nwave_sc), dtype='d') # region, wavelength, polarization (0 or 1) for split coherence_sc_p=np.zeros((nregion, p2vm.nwave_sc), dtype='d') phase_sc=np.zeros((nregion, p2vm.nwave_sc), dtype='d') phase_sc_s=np.zeros((nregion, p2vm.nwave_sc), dtype='d') phase_sc_p=np.zeros((nregion, p2vm.nwave_sc), dtype='d') for baseline in range(0,nbase): regs = get_reg_number(p2vm.regname_sc,baseline,'S') regp = get_reg_number(p2vm.regname_sc,baseline,'P') allregs = regs+regp tel1 = p2vm.ports_sc[regs[0],0] tel2 = p2vm.ports_sc[regs[0],1] norms = 2*np.sqrt(np.abs(p2vm.transmission_sc[regs,tel1,:]*p2vm.transmission_sc[regs,tel2,:])) normp = 2*np.sqrt(np.abs(p2vm.transmission_sc[regp,tel1,:]*p2vm.transmission_sc[regp,tel2,:])) allnorm = 2*np.sqrt(np.abs(p2vm.transmission_sc[allregs,tel1,:]*p2vm.transmission_sc[allregs,tel2,:])) coherence_sc[allregs,:] = p2vm.coherence_sc[allregs,baseline,:]/(allnorm+1e-10) coherence_sc_s[regs,:] = p2vm.coherence_sc[regs,baseline,:]/(norms+1e-10) coherence_sc_p[regp,:] = p2vm.coherence_sc[regp,baseline,:]/(normp+1e-10) phase_sc[allregs,:] = np.unwrap(p2vm.phase_sc[allregs,baseline,:],axis=1) phase_sc_s[regs,:] = np.unwrap(p2vm.phase_sc[regs,baseline,:],axis=1) phase_sc_p[regp,:] = np.unwrap(p2vm.phase_sc[regp,baseline,:],axis=1) else: # combined mode coherence_sc=np.zeros((nregion, p2vm.nwave_sc), dtype='d') phase_sc=np.zeros((nregion, p2vm.nwave_sc), dtype='d') for baseline in range(0,nbase): regc = get_reg_number(p2vm.regname_sc,baseline,'C') tel1 = p2vm.ports_sc[regc[0],0] tel2 = p2vm.ports_sc[regc[0],1] normc = 2*np.sqrt(np.abs(p2vm.transmission_sc[regc,tel1,:]*p2vm.transmission_sc[regc,tel2,:])) coherence_sc[regc,:] = p2vm.coherence_sc[regc,baseline,:]/(normc+1e-10) phase_sc[regc,:] = np.unwrap(p2vm.phase_sc[regc,baseline,:],axis=1) # Fringe tracker # ---------------------------------------------------------- if p2vm.polarsplit == True: coherence_ft=np.zeros((nregion, p2vm.nwave_ft), dtype='d') coherence_ft_s=np.zeros((nregion, p2vm.nwave_ft), dtype='d') coherence_ft_p=np.zeros((nregion, p2vm.nwave_ft), dtype='d') phase_ft=np.zeros((nregion, p2vm.nwave_ft), dtype='d') phase_ft_s=np.zeros((nregion, p2vm.nwave_ft), dtype='d') phase_ft_p=np.zeros((nregion, p2vm.nwave_ft), dtype='d') for baseline in range(0,nbase): regs = get_reg_number(p2vm.regname_ft,baseline,'S') regp = get_reg_number(p2vm.regname_ft,baseline,'P') allregs = regs+regp tel1 = p2vm.ports_ft[regs[0],0] tel2 = p2vm.ports_ft[regs[0],1] allnorm = 2*np.sqrt(np.abs(p2vm.transmission_ft[allregs,tel1,:]*p2vm.transmission_ft[allregs,tel2,:])) norms = 2*np.sqrt(np.abs(p2vm.transmission_ft[regs,tel1,:]*p2vm.transmission_ft[regs,tel2,:])) normp = 2*np.sqrt(np.abs(p2vm.transmission_ft[regp,tel1,:]*p2vm.transmission_ft[regp,tel2,:])) coherence_ft[allregs,:] = p2vm.coherence_ft[allregs,baseline,:]/(allnorm+1e-10) if norms.all() > 0: coherence_ft_s[regs,:] = p2vm.coherence_ft[regs,baseline,:]/(norms+1e-10) if normp.all() > 0: coherence_ft_p[regp,:] = p2vm.coherence_ft[regp,baseline,:]/(normp+1e-10) phase_ft[allregs,:] = np.unwrap(p2vm.phase_ft[allregs,baseline,:],axis=1) phase_ft_s[regs,:] = np.unwrap(p2vm.phase_ft[regs,baseline,:],axis=1) phase_ft_p[regp,:] = np.unwrap(p2vm.phase_ft[regp,baseline,:],axis=1) else: # combined mode coherence_ft=np.zeros((nregion, p2vm.nwave_ft), dtype='d') phase_ft=np.zeros((nregion, p2vm.nwave_ft), dtype='d') for baseline in range(0,nbase): regc = get_reg_number(p2vm.regname_ft,baseline,'C') tel1 = p2vm.ports_ft[regc[0],0] tel2 = p2vm.ports_ft[regc[0],1] normc = 2*np.sqrt(np.abs(p2vm.transmission_ft[regc,tel1,:]*p2vm.transmission_ft[regc,tel2,:])) if normc.all() > 0: coherence_ft[regc,:] = p2vm.coherence_ft[regc,baseline,:]/(normc+1e-10) phase_ft[regc,:] = np.unwrap(p2vm.phase_ft[regc,baseline,:],axis=1) if p2vm.polarsplitSC==False: ph_sc_BA = np.zeros([nbase], dtype='d') ph_sc_CA = np.zeros([nbase], dtype='d') ph_sc_DA = np.zeros([nbase], dtype='d') ph_sc_DB = np.zeros([nbase], dtype='d') ph_sc_max = np.zeros([nbase], dtype='d') ph_sc_avg = np.zeros([nbase], dtype='d') ph_sc_shift_avg = np.zeros([nbase], dtype='d') #ph_sc_shift_slope = np.zeros([nbase], dtype='d') for baseline in range(0,nbase): regionA=get_reg_number(p2vm.regname_sc,baseline,'C')[0] regionB=get_reg_number(p2vm.regname_sc,baseline,'C')[1] regionC=get_reg_number(p2vm.regname_sc,baseline,'C')[2] regionD=get_reg_number(p2vm.regname_sc,baseline,'C')[3] ph_sc_BA[baseline] = np.mean(phase_sc[regionB, :]-phase_sc[regionA, :])/np.pi*180 ph_sc_CA[baseline] = np.mean(phase_sc[regionC, :]-phase_sc[regionA, :])/np.pi*180 ph_sc_DA[baseline] = np.mean(phase_sc[regionD, :]-phase_sc[regionA, :])/np.pi*180 ph_sc_DB[baseline] = np.mean(phase_sc[regionD, :]-phase_sc[regionB, :])/np.pi*180 ph_sc = (phase_sc[regionC, :]-phase_sc[regionA, :]+\ phase_sc[regionB, :]-phase_sc[regionD, :])/np.pi*180/2 phase_shift=(phase_sc[regionD, :]+phase_sc[regionB, :]-\ phase_sc[regionC, :]-phase_sc[regionA, :])/np.pi*180/2 ph_sc_max[baseline]=np.max(np.abs(ph_sc-180)) ph_sc_avg[baseline]=np.mean(ph_sc) ph_sc_shift_avg[baseline]=np.mean(phase_shift) if p2vm.polarsplitSC==True: ph_sc_BA_s = np.zeros([nbase], dtype='d') ph_sc_CA_s = np.zeros([nbase], dtype='d') ph_sc_DA_s = np.zeros([nbase], dtype='d') ph_sc_DB_s = np.zeros([nbase], dtype='d') ph_sc_max_s = np.zeros([nbase], dtype='d') ph_sc_avg_s = np.zeros([nbase], dtype='d') ph_sc_shift_avg_s = np.zeros([nbase], dtype='d') #ph_sc_shift_slope_s = np.zeros([nbase], dtype='d') ph_sc_BA_p = np.zeros([nbase], dtype='d') ph_sc_CA_p = np.zeros([nbase], dtype='d') ph_sc_DA_p = np.zeros([nbase], dtype='d') ph_sc_DB_p = np.zeros([nbase], dtype='d') ph_sc_max_p = np.zeros([nbase], dtype='d') ph_sc_avg_p = np.zeros([nbase], dtype='d') ph_sc_shift_avg_p = np.zeros([nbase], dtype='d') ph_sc_shift_slope_p = np.zeros([nbase], dtype='d') # S polar for baseline in range(0,nbase): regionAs=get_reg_number(p2vm.regname_sc,baseline,'S')[0] regionBs=get_reg_number(p2vm.regname_sc,baseline,'S')[1] regionCs=get_reg_number(p2vm.regname_sc,baseline,'S')[2] regionDs=get_reg_number(p2vm.regname_sc,baseline,'S')[3] ph_sc_BA_s[baseline] = np.mean(phase_sc_s[regionBs, :]-phase_sc_s[regionAs, :])/np.pi*180 ph_sc_CA_s[baseline] = np.mean(phase_sc_s[regionCs, :]-phase_sc_s[regionAs, :])/np.pi*180 ph_sc_DA_s[baseline] = np.mean(phase_sc_s[regionDs, :]-phase_sc_s[regionAs, :])/np.pi*180 ph_sc_DB_s[baseline] = np.mean(phase_sc_s[regionDs, :]-phase_sc_s[regionBs, :])/np.pi*180 ph_sc_s = (phase_sc_s[regionCs, :]-phase_sc_s[regionAs, :]+\ phase_sc_s[regionBs, :]-phase_sc_s[regionDs, :])/np.pi*180/2 phase_shift_s=(phase_sc_s[regionDs, :]+phase_sc_s[regionBs, :]-\ phase_sc_s[regionCs, :]-phase_sc_s[regionAs, :])/np.pi*180/2 ph_sc_max_s[baseline]=np.max(np.abs(ph_sc_s-180)) ph_sc_avg_s[baseline]=np.mean(ph_sc_s) ph_sc_shift_avg_s[baseline]=np.mean(phase_shift_s) # if (len(phase_shift_s[0,:,0]) == 2) : # ph_sc_shift_slope_s[baseline]=(np.polyfit(p2vm.wave_sc, phase_shift_s[0,0,:], 1)[0]+\ # np.polyfit(p2vm.wave_sc, phase_shift_s[0,1,:], 1)[0])/2 # P polar for baseline in range(0,nbase): regionAp=get_reg_number(p2vm.regname_sc,baseline,'P')[0] regionBp=get_reg_number(p2vm.regname_sc,baseline,'P')[1] regionCp=get_reg_number(p2vm.regname_sc,baseline,'P')[2] regionDp=get_reg_number(p2vm.regname_sc,baseline,'P')[3] ph_sc_BA_p[baseline] = (phase_sc_p[regionBp, :].mean()-phase_sc_p[regionAp, :].mean())/np.pi*180 ph_sc_CA_p[baseline] = (phase_sc_p[regionCp, :].mean()-phase_sc_p[regionAp, :].mean())/np.pi*180 ph_sc_DA_p[baseline] = (phase_sc_p[regionDp, :].mean()-phase_sc_p[regionAp, :].mean())/np.pi*180 ph_sc_DB_p[baseline] = (phase_sc_p[regionDp, :].mean()-phase_sc_p[regionBp, :].mean())/np.pi*180 ph_sc_p = (phase_sc_p[regionCp, :]-phase_sc_p[regionAp, :]+\ phase_sc_p[regionBp, :]-phase_sc_p[regionDp, :])/np.pi*180/2 phase_shift_p=(phase_sc_p[regionDp, :]+phase_sc_p[regionBp, :]-\ phase_sc_p[regionCp, :]-phase_sc_p[regionAp, :])/np.pi*180/2 ph_sc_max_p[baseline]=np.max(np.abs(ph_sc_p-180)) ph_sc_avg_p[baseline]=np.mean(ph_sc_p) ph_sc_shift_avg_p[baseline]=np.mean(phase_shift_p) # if (len(phase_shift_p[0,:,0]) == 2) : # ph_sc_shift_slope_p[baseline]=(np.polyfit(p2vm.wave_sc, phase_shift_p[0,0,:], 1)[0]+\ # np.polyfit(p2vm.wave_sc, phase_shift_p[0,1,:], 1)[0])/2 if p2vm.polarsplit == False: ph_ft_BA = np.zeros([nbase], dtype='d') ph_ft_CA = np.zeros([nbase], dtype='d') ph_ft_DA = np.zeros([nbase], dtype='d') ph_ft_DB = np.zeros([nbase], dtype='d') ph_ft_max = np.zeros([nbase], dtype='d') ph_ft_avg = np.zeros([nbase], dtype='d') ph_ft_shift_avg = np.zeros([nbase], dtype='d') #ph_ft_shift_slope = np.zeros([nbase], dtype='d') for baseline in range(0,nbase): regionA=get_reg_number(p2vm.regname_ft,baseline,'C')[0] regionB=get_reg_number(p2vm.regname_ft,baseline,'C')[1] regionC=get_reg_number(p2vm.regname_ft,baseline,'C')[2] regionD=get_reg_number(p2vm.regname_ft,baseline,'C')[3] ph_ft_BA[baseline] = np.mean(phase_ft[regionB, :]-phase_ft[regionA, :])/np.pi*180 ph_ft_CA[baseline] = np.mean(phase_ft[regionC, :]-phase_ft[regionA, :])/np.pi*180 ph_ft_DA[baseline] = np.mean(phase_ft[regionD, :]-phase_ft[regionA, :])/np.pi*180 ph_ft_DB[baseline] = np.mean(phase_ft[regionD, :]-phase_ft[regionB, :])/np.pi*180 ph_ft = (phase_ft[regionC, :]-phase_ft[regionA, :]+\ phase_ft[regionB, :]-phase_ft[regionD, :])/np.pi*180/2 phase_shift=(phase_ft[regionD, :]+phase_ft[regionB, :]-\ phase_ft[regionC, :]-phase_ft[regionA, :])/np.pi*180/2 ph_ft_max[baseline]=np.max(np.abs(ph_ft-180)) ph_ft_avg[baseline]=np.mean(ph_ft) ph_ft_shift_avg[baseline]=np.mean(phase_shift) if p2vm.polarsplit==True: ph_ft_BA_s = np.zeros([nbase], dtype='d') ph_ft_CA_s = np.zeros([nbase], dtype='d') ph_ft_DA_s = np.zeros([nbase], dtype='d') ph_ft_DB_s = np.zeros([nbase], dtype='d') ph_ft_max_s = np.zeros([nbase], dtype='d') ph_ft_avg_s = np.zeros([nbase], dtype='d') ph_ft_shift_avg_s = np.zeros([nbase], dtype='d') #ph_ft_shift_slope_s = np.zeros([nbase], dtype='d') ph_ft_BA_p = np.zeros([nbase], dtype='d') ph_ft_CA_p = np.zeros([nbase], dtype='d') ph_ft_DA_p = np.zeros([nbase], dtype='d') ph_ft_DB_p = np.zeros([nbase], dtype='d') ph_ft_max_p = np.zeros([nbase], dtype='d') ph_ft_avg_p = np.zeros([nbase], dtype='d') ph_ft_shift_avg_p = np.zeros([nbase], dtype='d') ph_ft_shift_slope_p = np.zeros([nbase], dtype='d') for baseline in range(0,nbase): regionAs=get_reg_number(p2vm.regname_ft,baseline,'S')[0] regionBs=get_reg_number(p2vm.regname_ft,baseline,'S')[1] regionCs=get_reg_number(p2vm.regname_ft,baseline,'S')[2] regionDs=get_reg_number(p2vm.regname_ft,baseline,'S')[3] ph_ft_BA_s[baseline] = np.mean(phase_ft_s[regionBs, :]-phase_ft_s[regionAs, :])/np.pi*180 ph_ft_CA_s[baseline] = np.mean(phase_ft_s[regionCs, :]-phase_ft_s[regionAs, :])/np.pi*180 ph_ft_DA_s[baseline] = np.mean(phase_ft_s[regionDs, :]-phase_ft_s[regionAs, :])/np.pi*180 ph_ft_DB_s[baseline] = np.mean(phase_ft_s[regionDs, :]-phase_ft_s[regionBs, :])/np.pi*180 ph_ft_s = (phase_ft_s[regionCs, :]-phase_ft_s[regionAs, :]+\ phase_ft_s[regionBs, :]-phase_ft_s[regionDs, :])/np.pi*180/2 phase_shift_s=(phase_ft_s[regionDs, :]+phase_ft_s[regionBs, :]-\ phase_ft_s[regionCs, :]-phase_ft_s[regionAs, :])/np.pi*180/2 ph_ft_max_s[baseline]=np.max(np.abs(ph_ft_s-180)) ph_ft_avg_s[baseline]=np.mean(ph_ft_s) ph_ft_shift_avg_s[baseline]=np.mean(phase_shift_s) # if (len(phase_shift_s[0,:,0]) == 2) : # ph_ft_shift_slope_s[i]=(np.polyfit(p2vm.wave_ft, phase_shift_s[0,0,:], 1)[0]+np.polyfit(p2vm.wave_ft, phase_shift_s[0,1,:], 1)[0])/2 # P polar regionAp=get_reg_number(p2vm.regname_ft,baseline,'P')[0] regionBp=get_reg_number(p2vm.regname_ft,baseline,'P')[1] regionCp=get_reg_number(p2vm.regname_ft,baseline,'P')[2] regionDp=get_reg_number(p2vm.regname_ft,baseline,'P')[3] ph_ft_BA_p[baseline] = (phase_ft_p[regionBp, :].mean()-phase_ft_p[regionAp, :].mean())/np.pi*180 ph_ft_CA_p[baseline] = (phase_ft_p[regionCp, :].mean()-phase_ft_p[regionAp, :].mean())/np.pi*180 ph_ft_DA_p[baseline] = (phase_ft_p[regionDp, :].mean()-phase_ft_p[regionAp, :].mean())/np.pi*180 ph_ft_DB_p[baseline] = (phase_ft_p[regionDp, :].mean()-phase_ft_p[regionBp, :].mean())/np.pi*180 ph_ft_p = (phase_ft_p[regionCp, :]-phase_ft_p[regionAp, :]+\ phase_ft_p[regionBp, :]-phase_ft_p[regionDp, :])/np.pi*180/2 phase_shift_p=(phase_ft_p[regionDp, :]+phase_ft_p[regionBp, :]-\ phase_ft_p[regionCp, :]-phase_ft_p[regionAp, :])/np.pi*180/2 ph_ft_max_p[baseline]=np.max(np.abs(ph_ft_p-180)) ph_ft_avg_p[baseline]=np.mean(ph_ft_p) ph_ft_shift_avg_p[baseline]=np.mean(phase_shift_p) # if (len(phase_shift_p[0,:,0]) == 2) : # ph_ft_shift_slope_p[i]=(np.polyfit(p2vm.wave_ft, phase_shift_p[0,0,:], 1)[0]+np.polyfit(p2vm.wave_ft, phase_shift_p[0,1,:], 1)[0])/2 # Photometric transmissions of the beam combiners # ---------------------------------------------------------- # p2vm.transmission_ft[region,telescope,wavelength] transwave_ft = np.zeros((p2vm.nregion_ft,ntel)) transwave_sc = np.zeros((p2vm.nregion_sc,ntel)) for baseline in range(0,p2vm.nregion_sc): for tel in range(0,ntel): # Sum over wavelength channels transwave_sc[baseline,tel] = np.sum(p2vm.transmission_sc[baseline,tel,:]) for baseline in range(0,p2vm.nregion_ft): for tel in range(0,ntel): transwave_ft[baseline,tel] = np.sum(p2vm.transmission_ft[baseline,tel,:]) transavg_ft = np.zeros((nbase,ntel)) transavg_sc = np.zeros((nbase,ntel)) for baseline in range(0,nbase): for tel in range(0,ntel): # Sum over output channels of each baseline # The regions are sorted properly according to the order of base_list if p2vm.polarsplit == True: region = get_reg_number(p2vm.regname_ft,baseline,'P') + get_reg_number(p2vm.regname_ft,baseline,'S') if np.sum(transwave_ft[region,:]) != 0: transavg_ft[baseline,tel] = transwave_ft[region,tel].sum()/np.sum(transwave_ft[region,:]) else: transavg_ft[baseline,tel] = 0 else: region = get_reg_number(p2vm.regname_ft,baseline,'C') if np.sum(transwave_ft[region,:]) != 0: transavg_ft[baseline,tel] = transwave_ft[region,tel].sum()/np.sum(transwave_ft[region,:]) else: transavg_ft[baseline,tel] = 0 if p2vm.polarsplitSC == True: region = get_reg_number(p2vm.regname_sc,baseline,'P') + get_reg_number(p2vm.regname_sc,baseline,'S') if np.sum(transwave_sc[region,:]) != 0: transavg_sc[baseline,tel] = transwave_sc[region,tel].sum()/np.sum(transwave_sc[region,:]) else: transavg_sc[baseline,tel] = 0 else: region = get_reg_number(p2vm.regname_sc,baseline,'C') if np.sum(transwave_sc[region,:]) != 0: transavg_sc[baseline,tel] = transwave_sc[region,tel].sum()/np.sum(transwave_sc[region,:]) else: transavg_sc[baseline,tel] = 0 #----------------------------------------------------- # Average coherence transmissions and crosstalk #----------------------------------------------------- cohwave_ft = np.zeros((p2vm.nregion_ft,nbase)) cohwave_sc = np.zeros((p2vm.nregion_sc,nbase)) for region in range(0,p2vm.nregion_ft): for baseline in range(0,nbase): # Averaging over wavelength channels cohwave_ft[region,baseline] = np.mean(p2vm.coherence_ft[region,baseline,:]) # Averaging over wavelength channels cohwave_sc[region,baseline] = np.mean(p2vm.coherence_sc[region,baseline,:]) cohavg_ft = np.zeros((nbase,nbase)) cohavg_sc = np.zeros((nbase,nbase)) for baseline1 in range(0,nbase): for baseline2 in range(0,nbase): if p2vm.polarsplit == True: region= get_reg_number(p2vm.regname_ft,baseline1,'P') + get_reg_number(p2vm.regname_ft,baseline1,'S') if cohwave_ft[region,:].sum() != 0: cohavg_ft[baseline1,baseline2] = cohwave_ft[region,baseline2].sum()/cohwave_ft[region,:].sum() else: cohavg_ft[baseline1,baseline2] = 0 else: region=get_reg_number(p2vm.regname_ft,baseline1,'C') if cohwave_ft[region,:].sum() != 0: cohavg_ft[baseline1,baseline2] = cohwave_ft[region,baseline2].sum()/cohwave_ft[region,:].sum() if p2vm.polarsplitSC == True: region=get_reg_number(p2vm.regname_sc,baseline1,'P') + get_reg_number(p2vm.regname_sc,baseline1,'S') if cohwave_sc[region,:].sum() != 0: cohavg_sc[baseline1,baseline2] = cohwave_sc[region,baseline2].sum()/cohwave_sc[region,:].sum() else: region=get_reg_number(p2vm.regname_sc,baseline1,'C') if cohwave_sc[region,:].sum() != 0: cohavg_sc[baseline1,baseline2] = cohwave_sc[region,baseline2].sum()/cohwave_sc[region,:].sum() # Preparation of the output dictionary of combiner statistics # ----------------------------------------------------------- comb_stats = dict() comb_stats["baseline"] = base_list if p2vm.polarsplit==False: comb_stats["coh_ft"] = np.array([coherence_ft[get_reg_number(p2vm.regname_ft,baseline,'C'),:] for baseline in range(0,nbase)]) comb_stats["pha_ft"] = np.array([phase_ft[get_reg_number(p2vm.regname_ft,baseline,'C'),:] for baseline in range(0,nbase)]) comb_stats["coh_ft_avg"] = np.array([np.mean(coherence_ft[get_reg_number(p2vm.regname_ft,baseline,'C'),:])\ for baseline in range(0,nbase)]) comb_stats["coh_ft_rms"] = np.array([np.std(coherence_ft[get_reg_number(p2vm.regname_ft,baseline,'C'),:])\ for baseline in range(0,nbase)]) comb_stats["ph_ft_max"]=ph_ft_max.max() comb_stats["ph_ft_avg"]=ph_ft_avg comb_stats["ph_ft_shift_avg"]=ph_ft_shift_avg #comb_stats["ph_ft_shift_slope"]=ph_ft_shift_slope comb_stats["ph_ft_BA"]=ph_ft_BA comb_stats["ph_ft_CA"]=ph_ft_CA comb_stats["ph_ft_DA"]=ph_ft_DA comb_stats["ph_ft_DB"]=ph_ft_DB if p2vm.polarsplit==True: comb_stats["coh_ft_s"] = np.array([coherence_ft_s[get_reg_number(p2vm.regname_ft,baseline,'S'),:] for baseline in range(0,nbase)]) comb_stats["coh_ft_p"] = np.array([coherence_ft_p[get_reg_number(p2vm.regname_ft,baseline,'P'),:] for baseline in range(0,nbase)]) comb_stats["pha_ft_s"] = np.array([phase_ft_s[get_reg_number(p2vm.regname_ft,baseline,'S'),:] for baseline in range(0,nbase)]) comb_stats["pha_ft_p"] = np.array([phase_ft_p[get_reg_number(p2vm.regname_ft,baseline,'P'),:] for baseline in range(0,nbase)]) allregs = np.zeros((nbase,8), int) for baseline in range(0,nbase): allregs[baseline,:] = get_reg_number(p2vm.regname_ft,baseline,'S')+\ get_reg_number(p2vm.regname_ft,baseline,'P') comb_stats["coh_ft_avg"] = np.array([np.mean(coherence_ft[allregs[baseline],:]) for baseline in range(0,nbase)]) comb_stats["coh_ft_rms"] = np.array([np.std(coherence_ft[allregs[baseline],:]) for baseline in range(0,nbase)]) comb_stats["coh_ft_avg_s"] = np.array([np.mean(coherence_ft[get_reg_number(p2vm.regname_ft,baseline,'S'),:]) for baseline in range(0,nbase)]) comb_stats["coh_ft_rms_s"] = np.array([np.std(coherence_ft[get_reg_number(p2vm.regname_ft,baseline,'S'),:]) for baseline in range(0,nbase)]) comb_stats["coh_ft_avg_p"] = np.array([np.mean(coherence_ft[get_reg_number(p2vm.regname_ft,baseline,'P'),:]) for baseline in range(0,nbase)]) comb_stats["coh_ft_rms_p"] = np.array([np.std(coherence_ft[get_reg_number(p2vm.regname_ft,baseline,'P'),:]) for baseline in range(0,nbase)]) comb_stats["ph_ft_max_s"]=ph_ft_max_s.max() comb_stats["ph_ft_avg_s"]=ph_ft_avg_s comb_stats["ph_ft_shift_avg_s"]=ph_ft_shift_avg_s #comb_stats["ph_ft_shift_slope_s"]=ph_ft_shift_slope_s comb_stats["ph_ft_BA_s"]=ph_ft_BA_s comb_stats["ph_ft_CA_s"]=ph_ft_CA_s comb_stats["ph_ft_DA_s"]=ph_ft_DA_s comb_stats["ph_ft_DB_s"]=ph_ft_DB_s comb_stats["ph_ft_max_p"]=ph_ft_max_p.max() comb_stats["ph_ft_avg_p"]=ph_ft_avg_p comb_stats["ph_ft_shift_avg_p"]=ph_ft_shift_avg_p comb_stats["ph_ft_shift_slope_p"]=ph_ft_shift_slope_p comb_stats["ph_ft_BA_p"]=ph_ft_BA_p comb_stats["ph_ft_CA_p"]=ph_ft_CA_p comb_stats["ph_ft_DA_p"]=ph_ft_DA_p comb_stats["ph_ft_DB_p"]=ph_ft_DB_p if p2vm.polarsplitSC==False: comb_stats["coh_sc"] = np.array([coherence_sc[get_reg_number(p2vm.regname_sc,baseline,'C'),:] for baseline in range(0,nbase)]) comb_stats["pha_sc"] = np.array([phase_sc[get_reg_number(p2vm.regname_sc,baseline,'C'),:] for baseline in range(0,nbase)]) comb_stats["coh_sc_avg"] = np.array([np.mean(coherence_sc[get_reg_number(p2vm.regname_sc,baseline,'C'),:])\ for baseline in range(0,nbase)]) comb_stats["coh_sc_rms"] = np.array([np.std(coherence_sc[get_reg_number(p2vm.regname_sc,baseline,'C'),:])\ for baseline in range(0,nbase)]) comb_stats["ph_sc_max"]=ph_sc_max.max() comb_stats["ph_sc_avg"]=ph_sc_avg comb_stats["ph_sc_shift_avg"]=ph_sc_shift_avg #comb_stats["ph_sc_shift_slope"]=ph_sc_shift_slope comb_stats["ph_sc_BA"]=ph_sc_BA comb_stats["ph_sc_CA"]=ph_sc_CA comb_stats["ph_sc_DA"]=ph_sc_DA comb_stats["ph_sc_DB"]=ph_sc_DB if p2vm.polarsplitSC==True: comb_stats["coh_sc_s"] = np.array([coherence_sc_s[get_reg_number(p2vm.regname_sc,baseline,'S'),:] for baseline in range(0,nbase)]) comb_stats["coh_sc_p"] = np.array([coherence_sc_p[get_reg_number(p2vm.regname_sc,baseline,'P'),:] for baseline in range(0,nbase)]) comb_stats["pha_sc_s"] = np.array([phase_sc_s[get_reg_number(p2vm.regname_sc,baseline,'S'),:] for baseline in range(0,nbase)]) comb_stats["pha_sc_p"] = np.array([phase_sc_p[get_reg_number(p2vm.regname_sc,baseline,'P'),:] for baseline in range(0,nbase)]) allregs = np.zeros((nbase,8), int) for baseline in range(0,nbase): allregs[baseline,:] = get_reg_number(p2vm.regname_sc,baseline,'S')+\ get_reg_number(p2vm.regname_sc,baseline,'P') comb_stats["coh_sc_avg"] = np.array([np.mean(coherence_sc[allregs[baseline],:]) for baseline in range(0,nbase)]) comb_stats["coh_sc_rms"] = np.array([np.std(coherence_sc[allregs[baseline],:]) for baseline in range(0,nbase)]) comb_stats["coh_sc_avg_s"] = np.array([np.mean(coherence_sc[get_reg_number(p2vm.regname_sc,baseline,'S'),:]) for baseline in range(0,nbase)]) comb_stats["coh_sc_rms_s"] = np.array([np.std(coherence_sc[get_reg_number(p2vm.regname_sc,baseline,'S'),:]) for baseline in range(0,nbase)]) comb_stats["coh_sc_avg_p"] = np.array([np.mean(coherence_sc[get_reg_number(p2vm.regname_sc,baseline,'P'),:]) for baseline in range(0,nbase)]) comb_stats["coh_sc_rms_p"] = np.array([np.std(coherence_sc[get_reg_number(p2vm.regname_sc,baseline,'P'),:]) for baseline in range(0,nbase)]) comb_stats["ph_sc_max_s"]=ph_sc_max_s.max() comb_stats["ph_sc_avg_s"]=ph_sc_avg_s comb_stats["ph_sc_shift_avg_s"]=ph_sc_shift_avg_s #comb_stats["ph_sc_shift_slope_s"]=ph_sc_shift_slope_s comb_stats["ph_sc_BA_s"]=ph_sc_BA_s comb_stats["ph_sc_CA_s"]=ph_sc_CA_s comb_stats["ph_sc_DA_s"]=ph_sc_DA_s comb_stats["ph_sc_DB_s"]=ph_sc_DB_s comb_stats["ph_sc_max_p"]=ph_sc_max_p.max() comb_stats["ph_sc_avg_p"]=ph_sc_avg_p comb_stats["ph_sc_shift_avg_p"]=ph_sc_shift_avg_p comb_stats["ph_sc_shift_slope_p"]=ph_sc_shift_slope_p comb_stats["ph_sc_BA_p"]=ph_sc_BA_p comb_stats["ph_sc_CA_p"]=ph_sc_CA_p comb_stats["ph_sc_DA_p"]=ph_sc_DA_p comb_stats["ph_sc_DB_p"]=ph_sc_DB_p comb_stats["trans_ft"]=transavg_ft comb_stats["trans_sc"]=transavg_sc comb_stats["cohavg_ft"]=cohavg_ft comb_stats["cohavg_sc"]=cohavg_sc return comb_stats #============================================================================== # Preparation of the p2vm report using reportlab #============================================================================== def produce_p2vm_report(p2vm,filename): # From gravi_visual_class from . import gravi_visual_class from .gravi_visual_class import myFirstPage, myLaterPages from .gravi_visual_class import clipdata, transbarchartout, graphoutaxes, graphoutnoaxis from .gravi_visual_class import plotTitle, plotSubtitle from .gravi_visual_class import base_list, nbase from .gravi_visual_class import plotReductionSummary, plotSummary from reportlab.platypus import SimpleDocTemplate, Spacer, Table, TableStyle, PageBreak from reportlab.lib.units import cm, mm from reportlab.lib import colors #============================================================================== # Global parameters #============================================================================== specres = p2vm.header['HIERARCH ESO INS SPEC RES'] if specres == 'HIGH': resamp = 5 resampp = 5 else: resamp = 1 resampp = 1 #============================================================================== # Start Story #============================================================================== Story = [Spacer(1,2*mm)] plotSummary (Story, filename, p2vm, onTarget=False) #============================================================================== # Computation of the statistics #============================================================================== comb_stats = combiner_stats(p2vm,base_list) # Grand average transmission trans_avg_sc = np.mean(p2vm.transmission_sc) # Average transmission per region normalized to grand mean trans_region_sc = np.zeros([p2vm.nregion_sc],dtype='d') for region in range(0,p2vm.nregion_sc): trans_region_sc[region]=np.mean(p2vm.transmission_sc[region,:,:])/trans_avg_sc # Grand average transmission trans_avg_ft = np.mean(p2vm.transmission_ft) # Average transmission per region normalized to grand mean trans_region_ft = np.zeros([p2vm.nregion_ft],dtype='d') for region in range(0,p2vm.nregion_ft): trans_region_ft[region]=np.mean(p2vm.transmission_ft[region,:,:])/trans_avg_ft #============================================================================== # Overall quality of the p2vm #============================================================================== minwaveplot = 1.95 # minimum wavelength for plots maxwaveplot = 2.50 # maximum wavelength for plots qualcheckp = 0 # photometry flag qualcheckc = 0 # coherence flag photmin = 0.7 photmax = 1.3 cohmin = 0.80 cohmax = 1.03 okbad = 0.05 # fraction of acceptable bad values in coherence spectrum minlbdchk = int(p2vm.nwave_sc * 0.15) # minimum lambda channel to check the coherence and photometry maxlbdchk = int(p2vm.nwave_sc * 0.85) if np.sum(trans_region_sc0: qualcheckp+=1 if np.sum(trans_region_sc>photmax)>0: qualcheckp+=1 if np.sum(trans_region_ft0: qualcheckp+=1 if np.sum(trans_region_ft>photmax)>0: qualcheckp+=1 # print comb_stats["coh_sc"].shape # print comb_stats["coh_sc"][:,:,minlbdchk:maxlbdchk].shape if p2vm.polarsplit == True: if np.sum(comb_stats["coh_ft_s"](okbad*p2vm.nwave_ft): qualcheckc+=1 if np.sum(comb_stats["coh_ft_p"](okbad*p2vm.nwave_ft): qualcheckc+=1 if np.sum(comb_stats["coh_ft_s"]>cohmax)>(okbad*p2vm.nwave_ft): qualcheckc+=1 if np.sum(comb_stats["coh_ft_p"]>cohmax)>(okbad*p2vm.nwave_ft): qualcheckc+=1 else: if np.sum(comb_stats["coh_ft"](okbad*p2vm.nwave_ft): qualcheckc+=1 if np.sum(comb_stats["coh_ft"]>cohmax)>(okbad*p2vm.nwave_ft): qualcheckc+=1 if p2vm.polarsplitSC == True: if np.sum(comb_stats["coh_sc_s"][:,:,minlbdchk:maxlbdchk](okbad*p2vm.nwave_sc): qualcheckc+=1 if np.sum(comb_stats["coh_sc_p"][:,:,minlbdchk:maxlbdchk](okbad*p2vm.nwave_sc): qualcheckc+=1 if np.sum(comb_stats["coh_sc_s"][:,:,minlbdchk:maxlbdchk]>cohmax)>(okbad*p2vm.nwave_sc): qualcheckc+=1 if np.sum(comb_stats["coh_sc_p"][:,:,minlbdchk:maxlbdchk]>cohmax)>(okbad*p2vm.nwave_sc): qualcheckc+=1 else: if np.sum(comb_stats["coh_sc"][:,:,minlbdchk:maxlbdchk](okbad*p2vm.nwave_sc): qualcheckc+=1 if np.sum(comb_stats["coh_sc"][:,:,minlbdchk:maxlbdchk]>cohmax)>(okbad*p2vm.nwave_sc): qualcheckc+=1 if (qualcheckp+qualcheckc == 0): quality = 'GOOD' qualcolor = colors.lightgreen else: if (qualcheckp+qualcheckc < 3): quality = 'WARNING (Phot:%i / Coh:%i)'% (qualcheckp,qualcheckc) qualcolor = colors.yellow if (qualcheckp+qualcheckc >= 3): quality = 'BAD (Phot:%i / Coh:%i)'% (qualcheckp,qualcheckc) qualcolor = colors.orange data = [['P2VM overall quality', quality]] t=Table(data, colWidths=[5*cm, 11*cm]) t.setStyle(TableStyle([('INNERGRID', (0,0), (-1,-1), 0.25, colors.black), ('BACKGROUND',(1,0),(1,0),qualcolor), ('BOX', (0,0), (-1,-1), 2, colors.black),])) Story.append(t) #============================================================================== # Plots of the first page #============================================================================== plotTitle(Story,"Relative photometric transmission per output") plotSubtitle(Story,"Normalized to average transmission over all outputs. Cyan=Pol.1(P) or COMB, Blue=Pol.2(S).") Story.append(Spacer(1,-3*mm)) hsize = 18*cm vsize = 3.8*cm # plot the two polarizations separately (alternatively S and P) yminval=0 ymaxval=2 ystep=0.25 if p2vm.polarsplit == True: transdata = [tuple(clipdata(trans_region_sc[::2],yminval,ymaxval)),tuple(clipdata(trans_region_sc[1::2],yminval,ymaxval))] labelbase = p2vm.regname_sc[::2].astype('|S4').tolist() bc = transbarchartout(transdata,labelbase,yminval,ymaxval,ystep,hsize,vsize,colors.aquamarine,colors.cornflower,'Science Combiner') else: transdata = [tuple(clipdata(trans_region_sc,yminval,ymaxval))] labelbase = p2vm.regname_sc.astype('|S4').tolist() bc = transbarchartout(transdata,labelbase,yminval,ymaxval,ystep,hsize,vsize,colors.aquamarine,colors.cornflower,'Science Combiner') Story.append(bc) Story.append(Spacer(1,2*mm)) if p2vm.polarsplit == True: transdata = [tuple(clipdata(trans_region_ft[::2],yminval,ymaxval)),tuple(clipdata(trans_region_ft[1::2],yminval,ymaxval))] labelbase = p2vm.regname_ft[::2].astype('|S4').tolist() bc = transbarchartout(transdata,labelbase,yminval,ymaxval,ystep,hsize,vsize,colors.aquamarine,colors.cornflower,'Fringe Tracker') else: transdata = [tuple(clipdata(trans_region_ft,yminval,ymaxval))] labelbase = p2vm.regname_ft.astype('|S4').tolist() bc = transbarchartout(transdata,labelbase,yminval,ymaxval,ystep,hsize,vsize,colors.aquamarine,colors.cornflower,'Fringe Tracker') Story.append(bc) Story.append(Spacer(1,3*mm)) plotTitle(Story,"Coherence transmission per baseline") Story.append(Spacer(1,-3*mm)) # Graphical display of the SC visibility transmission yminval=0.7 ymaxval=1.05 ystep=0.05 if p2vm.polarsplit == True: transdata = [tuple(clipdata(comb_stats["coh_sc_avg_s"],yminval,ymaxval)),tuple(clipdata(comb_stats["coh_sc_avg_p"],yminval,ymaxval))] labelbase = comb_stats["baseline"] bc = transbarchartout(transdata,labelbase,yminval,ymaxval,ystep,hsize,vsize,colors.aquamarine,colors.cornflower,'Science Combiner') else: transdata = [tuple(clipdata(comb_stats["coh_sc_avg"],yminval,ymaxval))] labelbase = comb_stats["baseline"] bc = transbarchartout(transdata,labelbase,yminval,ymaxval,ystep,hsize,vsize,colors.aquamarine,colors.cornflower,'Science Combiner') Story.append(bc) # Story.append(Spacer(1,2*mm)) # Graphical display of the FT visibility transmission if p2vm.polarsplit == True: transdata = [tuple(clipdata(comb_stats["coh_ft_avg_s"],yminval,ymaxval)),tuple(clipdata(comb_stats["coh_ft_avg_p"],yminval,ymaxval))] labelbase = comb_stats["baseline"] bc = transbarchartout(transdata,labelbase,yminval,ymaxval,ystep,hsize,vsize,colors.aquamarine,colors.cornflower,'Fringe Tracker') else: transdata = [tuple(clipdata(comb_stats["coh_ft_avg"],yminval,ymaxval))] labelbase = comb_stats["baseline"] bc = transbarchartout(transdata,labelbase,yminval,ymaxval,ystep,hsize,vsize,colors.aquamarine,colors.cornflower,'Fringe Tracker') Story.append(bc) Story.append(PageBreak()) #============================================================================== # Summary of reduction parameters #============================================================================== plotReductionSummary(Story, p2vm) Story.append(PageBreak()) #============================================================================== # Photometric transmissions #============================================================================== plotTitle(Story,"Wavelength averaged photometric transmissions (%)") plotSubtitle(Story,"Expressed in percentage of the total transmitted flux per baseline output.") baselines = [[c] for c in comb_stats["baseline"]] baselines = np.vstack((['SC'],baselines)) data = (comb_stats["trans_sc"]*100).astype('|S5') data = np.vstack((['tel1','tel2','tel3','tel4'],data)) data = np.hstack((baselines, data)) t1=Table(data.astype('|S5').tolist()) t1.setStyle(TableStyle([('INNERGRID', (0,0), (-1,-1), 0.25, colors.black), ('BACKGROUND',(0,0),(0,0),colors.pink), ('BACKGROUND',(1,1),(1,1),colors.lavender), ('BACKGROUND',(1,1),(2,1),colors.lavender), ('BACKGROUND',(1,2),(1,2),colors.lavender), ('BACKGROUND',(3,2),(3,2),colors.lavender), ('BACKGROUND',(1,3),(1,3),colors.lavender), ('BACKGROUND',(4,3),(4,3),colors.lavender), ('BACKGROUND',(2,4),(3,4),colors.lavender), ('BACKGROUND',(2,5),(2,5),colors.lavender), ('BACKGROUND',(4,5),(4,5),colors.lavender), ('BACKGROUND',(3,6),(4,6),colors.lavender), ('BOX', (0,0), (-1,-1), 2, colors.black),])) baselines = [[c] for c in comb_stats["baseline"]] baselines = np.vstack((['FT'],baselines)) data = (comb_stats["trans_ft"]*100).astype('|S5') data = np.vstack((['tel1','tel2','tel3','tel4'],data)) data = np.hstack((baselines,data)) t2=Table(data.astype('|S5').tolist()) t2.setStyle(TableStyle([('INNERGRID', (0,0), (-1,-1), 0.25, colors.black), ('BACKGROUND',(0,0),(0,0),colors.pink), ('BACKGROUND',(1,1),(2,1),colors.lavender), ('BACKGROUND',(1,2),(1,2),colors.lavender), ('BACKGROUND',(3,2),(3,2),colors.lavender), ('BACKGROUND',(1,3),(1,3),colors.lavender), ('BACKGROUND',(4,3),(4,3),colors.lavender), ('BACKGROUND',(2,4),(3,4),colors.lavender), ('BACKGROUND',(2,5),(2,5),colors.lavender), ('BACKGROUND',(4,5),(4,5),colors.lavender), ('BACKGROUND',(3,6),(4,6),colors.lavender), ('BOX', (0,0), (-1,-1), 2, colors.black),])) t1t2 = [[t1, t2]] # adjust the length of tables t1_w = 8 * cm t2_w = 8 * cm t = Table(t1t2, colWidths=[t1_w, t2_w]) Story.append(t) Story.append(Spacer(1,4*mm)) #============================================================================== # Coherence transmissions #============================================================================== plotTitle(Story,"Wavelength averaged coherent flux transmission") plotSubtitle(Story,"Instrumental transfer function of the modulated fringe coherent flux, expressed in percentage of the total transmitted coherent flux per baseline output. It should be close to 100% along the diagonal of the matrix and zero elsewhere.") baselines = [[c] for c in comb_stats["baseline"]] baselines = np.vstack((['SC'],baselines)) data = (comb_stats["cohavg_sc"]*100).astype('|S5') data = np.vstack((comb_stats["baseline"],data)) data = np.hstack((baselines,data)) t1=Table(data.astype('|S4').tolist()) t1.setStyle(TableStyle([('INNERGRID', (0,0), (-1,-1), 0.25, colors.black), ('BACKGROUND',(0,0),(0,0),colors.pink), ('BACKGROUND',(1,1),(1,1),colors.lavender), ('BACKGROUND',(2,2),(2,2),colors.lavender), ('BACKGROUND',(3,3),(3,3),colors.lavender), ('BACKGROUND',(4,4),(4,4),colors.lavender), ('BACKGROUND',(5,5),(5,5),colors.lavender), ('BACKGROUND',(6,6),(6,6),colors.lavender), ('BOX', (0,0), (-1,-1), 2, colors.black),])) baselines = [[c] for c in comb_stats["baseline"]] baselines = np.vstack((['FT'],baselines)) data = (comb_stats["cohavg_ft"]*100).astype('|S5') data = np.vstack((["1-2", "1-3", "1-4", "2-3", "2-4", "3-4"],data)) data = np.hstack((baselines,data)) t2=Table(data.astype('|S4').tolist()) t2.setStyle(TableStyle([('INNERGRID', (0,0), (-1,-1), 0.25, colors.black), ('BACKGROUND',(0,0),(0,0),colors.pink), ('BACKGROUND',(1,1),(1,1),colors.lavender), ('BACKGROUND',(2,2),(2,2),colors.lavender), ('BACKGROUND',(3,3),(3,3),colors.lavender), ('BACKGROUND',(4,4),(4,4),colors.lavender), ('BACKGROUND',(5,5),(5,5),colors.lavender), ('BACKGROUND',(6,6),(6,6),colors.lavender), ('BOX', (0,0), (-1,-1), 2, colors.black),])) t1t2 = [[t1, t2]] # adjust the length of tables t1_w = 8 * cm t2_w = 8 * cm t = Table(t1t2, colWidths=[t1_w, t2_w]) Story.append(t) Story.append(Spacer(1,4*mm)) plotTitle(Story,"Wavelength averaged visibility transmission") plotSubtitle(Story,"Instrumental transfer function for the visibility (flux normalized fringe amplitude). It should be as close to 100% as possible (nominal: higher than 80%).") if p2vm.polarsplit == False: data = (comb_stats["coh_sc_avg"]*100).astype('|S5') data = np.vstack((comb_stats["baseline"],data)) data = np.vstack((data, (comb_stats["coh_sc_rms"]*100).astype('|S4'))) data = np.hstack(([['SC'], ["Transfer function (%)"], ["Standard dev. (%)"]],data)) t=Table(data.tolist()) t.setStyle(TableStyle([('INNERGRID', (0,0), (-1,-1), 0.25, colors.black), ('BACKGROUND',(0,0),(0,0),colors.pink), ('BOX', (0,0), (-1,-1), 2, colors.black),])) Story.append(t) Story.append(Spacer(1,5*mm)) data = (comb_stats["coh_ft_avg"]*100).astype('|S5') data = np.vstack((comb_stats["baseline"],data)) data = np.vstack((data, (comb_stats["coh_ft_rms"]*100).astype('|S4'))) data = np.hstack(([['FT'], ["Transfer function (%)"], ["Standard dev. (%)"]],data)) t=Table(data.tolist()) t.setStyle(TableStyle([('INNERGRID', (0,0), (-1,-1), 0.25, colors.black), ('BACKGROUND',(0,0),(0,0),colors.pink), ('BOX', (0,0), (-1,-1), 2, colors.black),])) Story.append(t) if p2vm.polarsplit == True: data = comb_stats["baseline"] data = np.vstack((data,(comb_stats["coh_sc_avg_s"]*100).astype('|S5'))) data = np.vstack((data,(comb_stats["coh_sc_rms_s"]*100).astype('|S4'))) data = np.vstack((data,(comb_stats["coh_sc_avg_p"]*100).astype('|S5'))) data = np.vstack((data,(comb_stats["coh_sc_rms_p"]*100).astype('|S4'))) data = np.hstack(([['SC'], ["Transfer function S (%)"], ["Standard dev. S (%)"], ["Transfer function P (%)"], ["Standard dev. P (%)"]],data)) t=Table(data.tolist()) t.setStyle(TableStyle([('INNERGRID', (0,0), (-1,-1), 0.25, colors.black), ('BACKGROUND',(0,0),(0,0),colors.pink), ('BOX', (0,0), (-1,-1), 2, colors.black),])) Story.append(t) Story.append(Spacer(1,2*mm)) data = comb_stats["baseline"] data = np.vstack((data,(comb_stats["coh_ft_avg_s"]*100).astype('|S5'))) data = np.vstack((data,(comb_stats["coh_ft_rms_s"]*100).astype('|S4'))) data = np.vstack((data,(comb_stats["coh_ft_avg_p"]*100).astype('|S5'))) data = np.vstack((data,(comb_stats["coh_ft_rms_p"]*100).astype('|S4'))) data = np.hstack(([['FT'], ["Transfer function S (%)"], ["Standard dev. S (%)"], ["Transfer function P (%)"], ["Standard dev. P (%)"]],data)) t=Table(data.tolist()) t.setStyle(TableStyle([('INNERGRID', (0,0), (-1,-1), 0.25, colors.black), ('BACKGROUND',(0,0),(0,0),colors.pink), ('BOX', (0,0), (-1,-1), 2, colors.black),])) Story.append(t) Story.append(PageBreak()) plotTitle(Story,"Science combiner coherence vs. wavelength") plotSubtitle(Story,"Colors: output A=red, B=orange, C=blue, D=green.") d=() data=[] xminval = minwaveplot xmaxval = maxwaveplot yminval=0.7 ymaxval=1.1 ticky=0.05 if p2vm.polarsplitSC == False: hsize=4.7*cm vsize=4.7*cm coh = comb_stats["coh_sc"] #print a for baseline in range(0,nbase): for output in range(0,4): data.append( tuple(zip(p2vm.wave_sc[::resampp], clipdata(coh[baseline,output,::resampp],yminval,ymaxval)))) if(baseline == 3): a = graphoutaxes(data,xminval,xmaxval,None,yminval,ymaxval,None,hsize,vsize,None,ticky,base_list[baseline]), else: a = graphoutnoaxis( data, xminval, xmaxval,yminval,ymaxval,hsize,vsize,ticky,base_list[baseline]), data = [] d = d + a plotmatrix = [list(d[0:int(nbase/2)]),list(d[int(nbase/2):nbase])] t = Table(plotmatrix,colWidths=hsize,rowHeights=vsize) Story.append(t) Story.append(Spacer(1,3*mm)) if p2vm.polarsplitSC == True: hsize=5*cm vsize=5*cm coh = comb_stats["coh_sc_s"] for baseline in range(0,nbase): for output in range(0,4): data.append( tuple(zip(p2vm.wave_sc[::resampp], clipdata(coh[baseline,output,::resampp],yminval,ymaxval)))) a = graphoutnoaxis( data, xminval, xmaxval,yminval,ymaxval, hsize,vsize,ticky,base_list[baseline]+'-S'), data = [] d = d + a coh = comb_stats["coh_sc_p"] #print a for baseline in range(0,nbase): for output in range(0,4): data.append( tuple(zip(p2vm.wave_sc[::resamp], clipdata(coh[baseline,output,::resamp],yminval,ymaxval)))) if(baseline == nbase/2): a = graphoutaxes(data,xminval,xmaxval,None,yminval,ymaxval,None,hsize,vsize,None,ticky,base_list[baseline]+'-P'), else: a = graphoutnoaxis( data, xminval, xmaxval,yminval,ymaxval, hsize,vsize,ticky,base_list[baseline]+'-P'), data = [] d = d + a plotmatrix = [list(d[0:int(nbase/2)]),list(d[int(nbase/2):nbase]),list(d[nbase:nbase+int(nbase/2)]),list(d[nbase+int(nbase/2):2*nbase])] t = Table(plotmatrix,colWidths=hsize,rowHeights=vsize) Story.append(t) Story.append(PageBreak()) #================ # if p2vm.polarsplit == True: # Story.append(Spacer(1,3*mm)) # hsize=12*cm # vsize=2*cm # # for reg in range(0,p2vm.nregion_sc): # data = [] # for base in range(0,6): # tel1 = p2vm.ports_sc[reg,0] # tel2 = p2vm.ports_sc[reg,1] # allnorm = 2*np.sqrt(np.abs(p2vm.transmission_sc[reg,tel1,:]*p2vm.transmission_sc[reg,tel2,:])) # data.append (tuple(zip(p2vm.wave_sc[::resampp], allnorm[::resampp]/5))) # data.append (tuple(zip(p2vm.wave_sc[::resampp], p2vm.coherence_sc[reg,base,::resampp]/5))) # data.append (tuple(zip(p2vm.wave_sc[::resampp], p2vm.coherence_sc[reg,base,::resampp] / (allnorm+1e-10)))) # a = graphoutnoaxis( data,2.15,2.16, 0, 1.1,hsize,vsize,1.0,'toto') # Story.append(a) # # Story.append(t) # Story.append(Spacer(1,3*mm)) # Story.append(PageBreak()) #================ plotTitle(Story,"Fringe tracker coherence vs. wavelength") plotSubtitle(Story,"Colors: output A=red, B=orange, C=blue, D=green.") d=() data=[] yminval=0.7 ymaxval=1.1 ticky=0.05 if p2vm.polarsplit == False: hsize=4.7*cm vsize=4.7*cm coh = comb_stats["coh_ft"] #print a for baseline in range(0,nbase): for output in range(0,4): data.append( tuple(zip(p2vm.wave_ft, clipdata(coh[baseline,output,:],yminval,ymaxval)))) if(baseline == nbase/2): a = graphoutaxes(data,xminval,xmaxval,None,yminval,ymaxval,None,hsize,vsize,None,ticky,base_list[baseline]), else: a = graphoutnoaxis( data, xminval, xmaxval,yminval,ymaxval,hsize,vsize,ticky,base_list[baseline]), data = [] d = d + a plotmatrix = [list(d[0:int(nbase/2)]),list(d[int(nbase/2):nbase])] t = Table(plotmatrix,colWidths=hsize,rowHeights=vsize) Story.append(t) if p2vm.polarsplit==True: hsize=5*cm vsize=5*cm Story.append(Spacer(1,3*mm)) d=() data=[] coh = comb_stats["coh_ft_s"] for baseline in range(0,nbase): for output in range(0,4): data.append( tuple(zip(p2vm.wave_ft, clipdata(coh[baseline,output,:],yminval,ymaxval)))) #print zip(p2vm.wave_ft, coh[baseline,output,:]) a = graphoutnoaxis(data,xminval,xmaxval,yminval,ymaxval, hsize,vsize,ticky,base_list[baseline]+'-S'), data = [] d = d + a coh = comb_stats["coh_ft_p"] #print a for baseline in range(0,nbase): for output in range(0,4): data.append( tuple(zip(p2vm.wave_ft, clipdata(coh[baseline,output,:],yminval,ymaxval)))) if(baseline == nbase/2): a = graphoutaxes(data,xminval,xmaxval,None,yminval,ymaxval,None,hsize,vsize,None,ticky,base_list[baseline]+'-P'), else: a = graphoutnoaxis( data, xminval, xmaxval,yminval,ymaxval, hsize,vsize,ticky,base_list[baseline]+'-P'), data = [] d = d + a plotmatrix = [list(d[0:int(nbase/2)]),list(d[int(nbase/2):nbase]),list(d[nbase:nbase+int(nbase/2)]),list(d[nbase+int(nbase/2):2*nbase])] t = Table(plotmatrix,colWidths=hsize,rowHeights=vsize) Story.append(t) Story.append(PageBreak()) #============================================================================== # Phases #============================================================================== plotTitle(Story,"Wavelength averaged phases of combiner outputs (degrees, A=0)") plotSubtitle(Story,"Normal values are around 90 deg for B-A, 180 deg for C-A, 270 deg for D-A and -180 deg for D-B.") if p2vm.polarsplitSC == False: data = np.vstack((comb_stats["baseline"], comb_stats["ph_sc_BA"].astype('|S8'))) data = np.vstack((data, (comb_stats["ph_sc_CA"]).astype('|S8'))) data = np.vstack((data, (comb_stats["ph_sc_DA"]).astype('|S8'))) data = np.vstack((data, (comb_stats["ph_sc_DB"]).astype('|S8'))) data = np.hstack(([['Phase'], ["SC B-A"], ["SC C-A"], ["SC D-A"], ["SC D-B"]],data)) t=Table(data.astype('|S8').tolist()) t.setStyle(TableStyle([('INNERGRID', (0,0), (-1,-1), 0.25, colors.black), ('BACKGROUND',(0,1),(0,1),colors.pink), ('BACKGROUND',(0,2),(0,2),colors.pink), ('BACKGROUND',(0,3),(0,3),colors.pink), ('BACKGROUND',(0,4),(0,4),colors.pink), ('BOX', (0,0), (-1,-1), 2, colors.black),])) Story.append(t) if p2vm.polarsplitSC == True: data = np.vstack((comb_stats["baseline"], comb_stats["ph_sc_BA_s"].astype('|S8'))) data = np.vstack((data, (comb_stats["ph_sc_CA_s"]).astype('|S8'))) data = np.vstack((data, (comb_stats["ph_sc_DA_s"]).astype('|S8'))) data = np.vstack((data, (comb_stats["ph_sc_DB_s"]).astype('|S8'))) data = np.hstack(([['Phase'], ["SC B-A S"], ["SC C-A S"], ["SC D-A S"], ["SC D-B S"]],data)) t=Table(data.astype('|S8').tolist()) t.setStyle(TableStyle([('INNERGRID', (0,0), (-1,-1), 0.25, colors.black), ('BACKGROUND',(0,1),(0,1),colors.pink), ('BACKGROUND',(0,2),(0,2),colors.pink), ('BACKGROUND',(0,3),(0,3),colors.pink), ('BACKGROUND',(0,4),(0,4),colors.pink), ('BOX', (0,0), (-1,-1), 2, colors.black),])) Story.append(t) Story.append(Spacer(1,1*cm)) data = np.vstack((comb_stats["baseline"], (comb_stats["ph_sc_BA_p"]).astype('|S8'))) data = np.vstack((data, (comb_stats["ph_sc_CA_p"]).astype('|S8'))) data = np.vstack((data, (comb_stats["ph_sc_DA_p"]).astype('|S8'))) data = np.vstack((data, (comb_stats["ph_sc_DB_p"]).astype('|S8'))) data = np.hstack(([['Phase'], ["SC B-A P"], ["SC C-A P"], ["SC D-A P"], ["SC D-B P"]],data)) t=Table(data.astype('|S8').tolist()) t.setStyle(TableStyle([('INNERGRID', (0,0), (-1,-1), 0.25, colors.black), ('BACKGROUND',(0,1),(0,1),colors.pink), ('BACKGROUND',(0,2),(0,2),colors.pink), ('BACKGROUND',(0,3),(0,3),colors.pink), ('BACKGROUND',(0,4),(0,4),colors.pink), ('BOX', (0,0), (-1,-1), 2, colors.black),])) Story.append(t) Story.append(Spacer(1,1*cm)) if p2vm.polarsplit == False: data = np.vstack((comb_stats["baseline"], comb_stats["ph_ft_BA"].astype('|S8'))) data = np.vstack((data, comb_stats["ph_ft_CA"].astype('|S8'))) data = np.vstack((data, comb_stats["ph_ft_DA"].astype('|S8'))) data = np.vstack((data, comb_stats["ph_ft_DB"].astype('|S8'))) data = np.hstack(([['Phase'], ["FT B-A"], ["FT C-A"], ["FT D-A"], ["FT D-B"]],data)) t=Table(data.astype('|S8').tolist()) t.setStyle(TableStyle([('INNERGRID', (0,0), (-1,-1), 0.25, colors.black), ('BACKGROUND',(0,1),(0,1),colors.pink), ('BACKGROUND',(0,2),(0,2),colors.pink), ('BACKGROUND',(0,3),(0,3),colors.pink), ('BACKGROUND',(0,4),(0,4),colors.pink), ('BOX', (0,0), (-1,-1), 2, colors.black),])) Story.append(t) if p2vm.polarsplit == True: data = np.vstack((comb_stats["baseline"], comb_stats["ph_ft_BA_s"].astype('|S8'))) data = np.vstack((data, comb_stats["ph_ft_CA_s"])) data = np.vstack((data, comb_stats["ph_ft_DA_s"])) data = np.vstack((data, comb_stats["ph_ft_DB_s"])) data = np.hstack(([['Phase'], ["FT B-A S"], ["FT C-A S"], ["FT D-A S"], ["FT D-B S"]],data)) t=Table(data.astype('|S8').tolist()) t.setStyle(TableStyle([('INNERGRID', (0,0), (-1,-1), 0.25, colors.black), ('BACKGROUND',(0,1),(0,1),colors.pink), ('BACKGROUND',(0,2),(0,2),colors.pink), ('BACKGROUND',(0,3),(0,3),colors.pink), ('BACKGROUND',(0,4),(0,4),colors.pink), ('BOX', (0,0), (-1,-1), 2, colors.black),])) Story.append(t) Story.append(Spacer(1,1*cm)) data = np.vstack((comb_stats["baseline"], comb_stats["ph_ft_BA_p"].astype('|S8'))) data = np.vstack((data, comb_stats["ph_ft_CA_p"].astype('|S8'))) data = np.vstack((data, comb_stats["ph_ft_DA_p"].astype('|S8'))) data = np.vstack((data, comb_stats["ph_ft_DB_p"].astype('|S8'))) data = np.hstack(([['Phase'], ["FT B-A P"], ["FT C-A P"], ["FT D-A P"], ["FT D-B P"]],data)) t=Table(data.astype('|S8').tolist()) t.setStyle(TableStyle([('INNERGRID', (0,0), (-1,-1), 0.25, colors.black), ('BACKGROUND',(0,1),(0,1),colors.pink), ('BACKGROUND',(0,2),(0,2),colors.pink), ('BACKGROUND',(0,3),(0,3),colors.pink), ('BACKGROUND',(0,4),(0,4),colors.pink), ('BOX', (0,0), (-1,-1), 2, colors.black),])) Story.append(t) Story.append(Spacer(1,1*cm)) # data = comb_stats["ph_sc_shift_slope"] # data = np.vstack((comb_stats["baseline"],data)) # data = np.vstack((data, (comb_stats["ph_ft_shift_slope"]))) # data = np.hstack(([['Slope'], ["SC"], ["FT"]],data)) # t=Table(data.astype('|S5').tolist()) # t.setStyle(TableStyle([('INNERGRID', (0,0), (-1,-1), 0.25, colors.black), # ('BACKGROUND',(0,1),(0,1),colors.pink), # ('BACKGROUND',(0,2),(0,2),colors.pink), # ('BOX', (0,0), (-1,-1), 2, colors.black),])) # Story.append(t) # # Story.append(Spacer(1,1*cm)) if hasattr(p2vm, 'phase_met'): plotTitle(Story,"Phases of metrology outputs (degrees)") plotSubtitle(Story,"Normal values are around -90 deg for all outputs.") data = (p2vm.phase_met[:,1]*180./np.pi).astype('|S6').tolist() tmet=Table([list(range(0,len(data))), data],colWidths=2*cm) tmet.setStyle(TableStyle([('INNERGRID', (0,0), (-1,-1), 0.25, colors.black), ('BOX', (0,0), (-1,-1), 2, colors.black),])) Story.append(tmet) Story.append(PageBreak()) plotTitle(Story,"Science combiner output phases vs. wavelength") plotSubtitle(Story,"Relative to output A defining phase=0 deg. Outputs: B=red, C=orange, D=blue.") hsize=5*cm vsize=5*cm d=() data=[] yminval=60. ymaxval=300. xminval = minwaveplot xmaxval = maxwaveplot ticky=45. if p2vm.polarsplitSC == False: pha = comb_stats["pha_sc"]*180./np.pi # phase [baseline pair (6), output (4), wavelength] for baseline in range(0,nbase): pharef = np.copy(pha[baseline,0,:]) for output in range(1,4): pha[baseline,output,:] = (pha[baseline,output,:] - pharef)%360. # referencing to first output (A of ABCD) data.append( tuple(zip(p2vm.wave_sc[::resamp], clipdata(pha[baseline,output,::resamp],yminval,ymaxval)))) if(baseline == 3): a = graphoutaxes(data,xminval,xmaxval,None,yminval,ymaxval,None,hsize,vsize,None,ticky,base_list[baseline]), else: a = graphoutnoaxis( data, xminval, xmaxval, yminval,ymaxval,hsize,vsize,ticky,base_list[baseline]), data = [] d = d + a plotmatrix = [list(d[0:int(nbase/2)]),list(d[int(nbase/2):nbase])] t = Table(plotmatrix,colWidths=hsize,rowHeights=vsize) Story.append(t) Story.append(Spacer(1,2*mm)) if p2vm.polarsplitSC == True: pha = comb_stats["pha_sc_s"]*180./np.pi for baseline in range(0,nbase): pharef = np.copy(pha[baseline,0,:]) for output in range(1,4): pha[baseline,output,:] = (pha[baseline,output,:] - pharef)%360. # referencing to first output (A of ABCD) data.append( tuple(zip(p2vm.wave_sc[::resamp], clipdata(pha[baseline,output,::resamp],yminval,ymaxval)))) a = graphoutnoaxis( data, xminval, xmaxval,yminval,ymaxval, hsize,vsize,ticky,base_list[baseline]+'-S'), data = [] d = d + a pha = comb_stats["pha_sc_p"]*180./np.pi for baseline in range(0,nbase): pharef = np.copy(pha[baseline,0,:]) for output in range(1,4): pha[baseline,output,:] = (pha[baseline,output,:] - pharef)%360. # referencing to first output (A of ABCD) data.append( tuple(zip(p2vm.wave_sc[::resamp], clipdata(pha[baseline,output,::resamp],yminval,ymaxval)))) if(baseline == nbase/2): a = graphoutaxes( data, xminval, xmaxval,None,yminval,ymaxval,None,hsize,vsize,None,ticky, base_list[baseline]+'-P'), else: a = graphoutnoaxis( data, xminval, xmaxval, yminval, ymaxval, hsize, vsize, ticky, base_list[baseline]+'-P'), data = [] d = d + a plotmatrix = [list(d[0:int(nbase/2)]),list(d[int(nbase/2):nbase]),list(d[nbase:nbase+int(nbase/2)]),list(d[nbase+int(nbase/2):2*nbase])] t = Table(plotmatrix,colWidths=hsize,rowHeights=vsize) Story.append(t) Story.append(PageBreak()) plotTitle(Story,"Fringe tracker output phases vs. wavelength") plotSubtitle(Story,"Relative to output A defining phase=0 deg. Outputs: B=red, C=orange, D=blue.") hsize=5*cm vsize=5*cm xminval = minwaveplot xmaxval = maxwaveplot d=() data=[] if p2vm.polarsplit == False: pha = comb_stats["pha_ft"]*180./np.pi # phase [baseline pair (6), output (4), wavelength] for baseline in range(0,nbase): pharef = np.copy(pha[baseline,0,:]) for output in range(1,4): pha[baseline,output,:] = (pha[baseline,output,:] - pharef)%360. # referencing to first output (A of ABCD) data.append( tuple(zip(p2vm.wave_ft, clipdata(pha[baseline,output,:],yminval,ymaxval)))) if(baseline == 3): a = graphoutaxes( data, xminval, xmaxval,None,yminval,ymaxval,None,hsize,vsize,None,ticky,base_list[baseline]), else: a = graphoutnoaxis( data, xminval, xmaxval,yminval,ymaxval,hsize,vsize,ticky,base_list[baseline]), data = [] d = d + a plotmatrix = [list(d[0:int(nbase/2)]),list(d[int(nbase/2):nbase])] t = Table(plotmatrix,colWidths=hsize,rowHeights=vsize) Story.append(t) if p2vm.polarsplit == True: Story.append(Spacer(1,2*mm)) pha = comb_stats["pha_ft_s"]*180./np.pi for baseline in range(0,nbase): pharef = np.copy(pha[baseline,0,:]) for output in range(1,4): pha[baseline,output,:] = (pha[baseline,output,:] - pharef)%360. # referencing to first output (A of ABCD) data.append( tuple(zip(p2vm.wave_ft, clipdata(pha[baseline,output,:],yminval,ymaxval)))) a = graphoutnoaxis( data, xminval, xmaxval,yminval,ymaxval, hsize,vsize,ticky,base_list[baseline]+'-S'), data = [] d = d + a pha = comb_stats["pha_ft_p"]*180./np.pi #print a for baseline in range(0,nbase): pharef = np.copy(pha[baseline,0,:]) for output in range(1,4): pha[baseline,output,:] = (pha[baseline,output,:] - pharef)%360. # referencing to first output (A of ABCD) data.append( tuple(zip(p2vm.wave_ft, clipdata(pha[baseline,output,:],yminval,ymaxval)))) if(baseline == nbase/2): a = graphoutaxes(data,xminval,xmaxval,None,yminval,ymaxval,None,hsize,vsize,None,ticky,base_list[baseline]+'-P'), else: a = graphoutnoaxis( data, xminval, xmaxval, yminval,ymaxval, hsize,vsize,ticky,base_list[baseline]+'-P'), data = [] d = d + a plotmatrix = [list(d[0:int(nbase/2)]),list(d[int(nbase/2):nbase]),list(d[nbase:nbase+int(nbase/2)]),list(d[nbase+int(nbase/2):2*nbase])] t = Table(plotmatrix,colWidths=hsize,rowHeights=vsize) Story.append(t) Story.append(PageBreak()) #============================================================================== # Raw photometric transmission SC #============================================================================== plotTitle(Story,"SC RAW photometric transmission vs. wavelength") plotSubtitle(Story,"Colors: Tel1=red, Tel2=orange, Tel3=blue, Tel4=green.") if p2vm.polarsplit == True: hsize = 2*cm # horizontal size of subplots else: hsize = 4*cm vsize = 3.7*cm # vertical size of subplots yminval = -0.2 # due to the normalization by region ymaxval = 5.0 # due to the normalization by region ticky = 1.0 d=() data=[] for region in range(0,p2vm.nregion_sc): for tel in range(0,4): data.append( tuple(zip(p2vm.wave_sc[::resampp], clipdata(p2vm.transmission_sc[region,tel,::resampp],yminval,ymaxval)) )) if (region == p2vm.nregion_sc*5/6): a = graphoutaxes( data, minwaveplot,maxwaveplot,None,yminval,ymaxval,None,hsize,vsize,None,ticky,p2vm.regname_sc[region]), else: a = graphoutnoaxis( data, minwaveplot,maxwaveplot,yminval,ymaxval,hsize,vsize,ticky,p2vm.regname_sc[region]), data = [] d = d + a stepplot = int(p2vm.nregion_sc/6) # 8 with polarization splitting, 4 otherwise plotmatrix = [list(d[0:stepplot]), list(d[stepplot:2*stepplot]), list(d[2*stepplot:3*stepplot]), list(d[3*stepplot:4*stepplot]), list(d[4*stepplot:5*stepplot]), list(d[5*stepplot:6*stepplot])] t = Table(plotmatrix,colWidths=hsize,rowHeights=vsize) Story.append(t) Story.append(PageBreak()) #============================================================================== # RELATIVE photometric transmission SC #============================================================================== plotTitle(Story,"SC RELATIVE photometric transmission vs. wavelength") plotSubtitle(Story,"Colors: Tel1=red, Tel2=orange, Tel3=blue, Tel4=green.") if p2vm.polarsplit == True: hsize = 2*cm # horizontal size of subplots else: hsize = 4*cm vsize = 3.7*cm # vertical size of subplots yminval = -0.05 # due to the normalization by region ymaxval = 1.0 # due to the normalization by region ticky = 0.25 # Total transmission per region as a function of wavelength norm_sc = np.zeros([p2vm.nregion_sc,p2vm.nwave_sc],dtype='d') for region in range(0,p2vm.nregion_sc): for wave in range(0,p2vm.nwave_sc): norm_sc[region,wave]=np.sum(p2vm.transmission_sc[region,:,wave]) d=() data=[] for region in range(0,p2vm.nregion_sc): for tel in range(0,4): data.append( tuple(zip(p2vm.wave_sc[::resamp], clipdata(p2vm.transmission_sc[region,tel,::resamp]/norm_sc[region,::resamp],yminval,ymaxval)) )) if (region == p2vm.nregion_sc*5/6): a = graphoutaxes( data, minwaveplot,maxwaveplot,None,yminval,ymaxval,None,hsize,vsize,None,ticky,p2vm.regname_sc[region]), else: a = graphoutnoaxis( data, minwaveplot,maxwaveplot,yminval,ymaxval,hsize,vsize,ticky,p2vm.regname_sc[region]), data = [] d = d + a stepplot = int(p2vm.nregion_sc/6) # 8 with polarization splitting, 4 otherwise plotmatrix = [list(d[0:stepplot]), list(d[stepplot:2*stepplot]), list(d[2*stepplot:3*stepplot]), list(d[3*stepplot:4*stepplot]), list(d[4*stepplot:5*stepplot]), list(d[5*stepplot:6*stepplot])] t = Table(plotmatrix,colWidths=hsize,rowHeights=vsize) Story.append(t) #leg = legendout(['Tel1','Tel2','Tel3','Tel4'], [colors.red,colors.orange,colors.blue,colors.green],7*mm,3*cm) #Story.append(leg) Story.append(PageBreak()) #============================================================================== # Raw photometric transmission FT #============================================================================== plotTitle(Story,"FT RAW photometric transmission vs. wavelength") plotSubtitle(Story,"Colors: Tel1=red, Tel2=orange, Tel3=blue, Tel4=green.") if p2vm.polarsplit == True: hsize = 2*cm # horizontal size of subplots else: hsize = 4*cm vsize = 3.7*cm # vertical size of subplots yminval = -0.2 # due to the normalization by region ymaxval = 5.0 # due to the normalization by region ticky = 1.0 d=() data=[] for region in range(0,p2vm.nregion_ft): for tel in range(0,4): data.append( tuple(zip(p2vm.wave_ft, clipdata(p2vm.transmission_ft[region,tel,:],yminval,ymaxval)) )) if (region == p2vm.nregion_ft*5/6): a = graphoutaxes( data, minwaveplot,maxwaveplot,None,yminval,ymaxval,None,hsize,vsize,None,ticky,p2vm.regname_ft[region]), else: a = graphoutnoaxis( data, minwaveplot,maxwaveplot,yminval,ymaxval,hsize,vsize,ticky,p2vm.regname_ft[region]), data = [] d = d + a stepplot = int(p2vm.nregion_ft/6) # 8 with polarization splitting, 4 otherwise plotmatrix = [list(d[0:stepplot]), list(d[stepplot:2*stepplot]), list(d[2*stepplot:3*stepplot]), list(d[3*stepplot:4*stepplot]), list(d[4*stepplot:5*stepplot]), list(d[5*stepplot:6*stepplot])] t = Table(plotmatrix,colWidths=hsize,rowHeights=vsize) Story.append(t) Story.append(PageBreak()) #============================================================================== # RELATIVE photometric transmission FT #============================================================================== plotTitle(Story,"FT RELATIVE photometric transmission vs. wavelength") plotSubtitle(Story,"Colors: Tel1=red, Tel2=orange, Tel3=blue, Tel4=green.") yminval = -0.05 # due to the normalization by region ymaxval = 1.0 # due to the normalization by region ticky = 0.25 # Total transmission per region as a function of wavelength norm_ft = np.zeros([p2vm.nregion_ft,p2vm.nwave_ft],dtype='d') for region in range(0,p2vm.nregion_ft): for wave in range(0,p2vm.nwave_ft): norm_ft[region,wave]=np.sum(p2vm.transmission_ft[region,:,wave]) d=() data=[] for region in range(0,p2vm.nregion_ft): for tel in range(0,4): data.append( tuple(zip(p2vm.wave_ft, clipdata(p2vm.transmission_ft[region,tel,:]/norm_ft[region,:],yminval,ymaxval))) ) if (region == p2vm.nregion_ft*5/6): a = graphoutaxes( data, minwaveplot,maxwaveplot,None,yminval,ymaxval,None,hsize,vsize,None,ticky,p2vm.regname_ft[region]), else: a = graphoutnoaxis( data, minwaveplot,maxwaveplot,yminval,ymaxval,hsize,vsize,ticky,p2vm.regname_ft[region]), data = [] d = d + a stepplot = int(p2vm.nregion_ft/6) # 8 with polarization splitting, 4 otherwise plotmatrix = [list(d[0:stepplot]), list(d[stepplot:2*stepplot]), list(d[2*stepplot:3*stepplot]), list(d[3*stepplot:4*stepplot]), list(d[4*stepplot:5*stepplot]), list(d[5*stepplot:6*stepplot])] t = Table(plotmatrix,colWidths=hsize,rowHeights=vsize) Story.append(t) Story.append(PageBreak()) #============================================================================== # Total flux SC #============================================================================== plotTitle(Story,"Science combiner c-matrix [e-/DIT/channel] vs. wavelength") plotSubtitle(Story,"Colors: File1=red, File2=orange, File3=blue, File4=green, File5=cyan, File6=purple.") if p2vm.polarsplit == True: hsize = 2*cm # horizontal size of subplots else: hsize = 4*cm vsize = 3.7*cm # vertical size of subplots yminval = np.min([0,np.min(p2vm.cmatrix_sc)]) ymaxval = np.max(p2vm.cmatrix_sc) ticky = (ymaxval-yminval)/5 d=() data=[] for region in range(0,p2vm.nregion_sc): for b in range(0,6): data.append( tuple(zip(p2vm.wave_sc[::resamp], clipdata(p2vm.cmatrix_sc[region,b,::resamp],yminval,ymaxval)) )) if (region == p2vm.nregion_sc*5/6): a = graphoutaxes( data, minwaveplot,maxwaveplot,None,yminval,ymaxval,None,hsize,vsize,None,ticky,p2vm.regname_sc[region]), else: a = graphoutnoaxis( data, minwaveplot,maxwaveplot,yminval,ymaxval,hsize,vsize,ticky,p2vm.regname_sc[region]), data = [] d = d + a stepplot = int(p2vm.nregion_sc/6) # 8 with polarization splitting, 4 otherwise plotmatrix = [list(d[0:stepplot]), list(d[stepplot:2*stepplot]), list(d[2*stepplot:3*stepplot]), list(d[3*stepplot:4*stepplot]), list(d[4*stepplot:5*stepplot]), list(d[5*stepplot:6*stepplot])] t = Table(plotmatrix,colWidths=hsize,rowHeights=vsize) Story.append(t) Story.append(PageBreak()) #============================================================================== # Total flux FT #============================================================================== plotTitle(Story,"Fringe tracker c-matrix [e-/DIT/channel] vs. wavelength") plotSubtitle(Story,"Colors: File1=red, File2=orange, File3=blue, File4=green, File5=cyan, File6=purple.") if p2vm.polarsplit == True: hsize = 2*cm # horizontal size of subplots else: hsize = 4*cm vsize = 3.7*cm # vertical size of subplots yminval = np.min([0,np.min(p2vm.cmatrix_ft)]) ymaxval = np.max(p2vm.cmatrix_ft) ticky = (ymaxval-yminval)/5 d=() data=[] for region in range(0,p2vm.nregion_ft): for b in range(0,6): data.append( tuple(zip(p2vm.wave_ft, clipdata(p2vm.cmatrix_ft[region,b,:],yminval,ymaxval)) )) if (region == p2vm.nregion_ft*5/6): a = graphoutaxes( data, minwaveplot,maxwaveplot,None,yminval,ymaxval,None,hsize,vsize,None,ticky,p2vm.regname_ft[region]), else: a = graphoutnoaxis( data, minwaveplot,maxwaveplot,yminval,ymaxval,hsize,vsize,ticky,p2vm.regname_ft[region]), data = [] d = d + a stepplot = int(p2vm.nregion_ft/6) # 8 with polarization splitting, 4 otherwise plotmatrix = [list(d[0:stepplot]), list(d[stepplot:2*stepplot]), list(d[2*stepplot:3*stepplot]), list(d[3*stepplot:4*stepplot]), list(d[4*stepplot:5*stepplot]), list(d[5*stepplot:6*stepplot])] t = Table(plotmatrix,colWidths=hsize,rowHeights=vsize) Story.append(t) Story.append(PageBreak()) #============================================================================== # Production of the report #============================================================================== print("Create the PDF") gravi_visual_class.TITLE = "GRAVITY P2VM Quality Control Report" gravi_visual_class.PAGEINFO = "P2VM file: "+filename+".fits" reportname = filename+"-P2VM.pdf" doc = SimpleDocTemplate(reportname) doc.build(Story, onFirstPage=myFirstPage, onLaterPages=myLaterPages) print((" "+reportname)) #============================================================================== # MAIN PROGRAM #============================================================================== if __name__ == '__main__': # filename = 'GRAVITY.2015-09-18T15-43-01_0015' # filename = 'GRAVITY.2015-09-11T04-34-38_0015' # filename = '../GRAVITY.2015-11-14T08-34-14_0004' filename = '../test-files/GRAVITY.2016-09-16T18-20-08_p2vm' if len(sys.argv) == 2 : filename=sys.argv[1] if filename == '' : filename=input(" Enter P2VM file name (without .fits) : ") p2vm = gravi_visual_class.P2vm(filename+'.fits') produce_p2vm_report(p2vm,filename)