def makeFtot(self, nmodes, Ttot, phaseshift=False): self.Fred, self.ranphase = utils.createFourierDesignmatrix_red(self.toas, nmodes=nmodes, pshift=phaseshift, Tspan=Ttot) self.Fdm = utils.createFourierDesignmatrix_dm(self.toas, nmodes, self.obs_freqs, Tspan=Ttot) self.Ftot = np.append(self.Fred, self.Fdm, axis=1)
def makeTe(self, nmodes_red, Ttot, makeDM=False, nmodes_dm=None, makeEph=False, nmodes_eph=None, ephFreqs=None, makeClk=False, clkDesign=False, phaseshift=False): self.Fred, self.ranphase = utils.createFourierDesignmatrix_red(self.toas, nmodes=nmodes_red, pshift=phaseshift, Tspan=Ttot) self.Ftot = self.Fred if makeDM: if nmodes_dm is None: nmodes_tmp = nmodes_red else: nmodes_tmp = nmodes_dm self.Fdm = utils.createFourierDesignmatrix_dm(self.toas, nmodes_tmp, self.obs_freqs, Tspan=Ttot) self.Ftot = np.append(self.Ftot, self.Fdm, axis=1) if makeEph: if nmodes_eph is None: nmodes_tmp = nmodes_red else: nmodes_tmp = nmodes_eph self.Fephx, self.Fephy, self.Fephz = \ utils.createFourierDesignmatrix_eph(self.toas, nmodes_tmp, self.psr_locs, Tspan=Ttot, input_freqs=ephFreqs) self.Ftot = np.append(self.Ftot, self.Fephx, axis=1) self.Ftot = np.append(self.Ftot, self.Fephy, axis=1) self.Ftot = np.append(self.Ftot, self.Fephz, axis=1) if makeClk and clkDesign: self.Fclk, _ = utils.createFourierDesignmatrix_red(self.toas, nmodes=nmodes_red, pshift=False, Tspan=Ttot) self.Ftot = np.append(self.Ftot, self.Fclk, axis=1) self.Te = np.append(self.Gc, self.Ftot, axis=1)
def makeTe(self, nmodes, Ttot, makeDM=False, makeEph=False, phaseshift=False): self.Fred, self.ranphase = utils.createFourierDesignmatrix_red( self.toas, nmodes=nmodes, pshift=phaseshift, Tspan=Ttot) if makeDM: self.Fdm = utils.createFourierDesignmatrix_dm(self.toas, nmodes, self.obs_freqs, Tspan=Ttot) self.Ftot = np.append(self.Fred, self.Fdm, axis=1) if makeEph: self.Fephx, self.Fephy, self.Fephz = \ utils.createFourierDesignmatrix_eph(self.toas, nmodes, self.psr_locs, Tspan=Ttot) self.Ftot = np.append(self.Ftot, self.Fephx, axis=1) self.Ftot = np.append(self.Ftot, self.Fephy, axis=1) self.Ftot = np.append(self.Ftot, self.Fephz, axis=1) if not makeDM and not makeEph: self.Ftot = self.Fred self.Te = np.append(self.Gc, self.Ftot, axis=1)
def makeFtot(self, nmodes, Ttot, phaseshift=False): self.Fred, self.ranphase = \ utils.createFourierDesignmatrix_red(self.toas, fqs_red, wgts_red, pshift=phaseshift, Tspan=Ttot) self.Fdm = utils.createFourierDesignmatrix_dm(self.toas, fqs_dm, wgts_dm, self.obs_freqs, Tspan=Ttot) self.Ftot = np.append(self.Fred, self.Fdm, axis=1)
def makeFdm(self, nmodes, obs_freqs, Ttot, input_freqs=None): self.Fdm = utils.createFourierDesignmatrix_dm(self.toas, nmodes=nmodes, obs_freqs=self.obs_freqs, Tspan=Ttot, input_freqs=input_freqs)
def makeTe(self, nmodes, Ttot, makeDM=False, makeEph=False, phaseshift=False): self.Fred, self.ranphase = utils.createFourierDesignmatrix_red(self.toas, nmodes=nmodes, pshift=phaseshift, Tspan=Ttot) if makeDM: self.Fdm = utils.createFourierDesignmatrix_dm(self.toas, nmodes, self.obs_freqs, Tspan=Ttot) self.Ftot = np.append(self.Fred, self.Fdm, axis=1) if makeEph: self.Fephx, self.Fephy, self.Fephz = \ utils.createFourierDesignmatrix_eph(self.toas, nmodes, self.psr_locs, Tspan=Ttot) self.Ftot = np.append(self.Ftot, self.Fephx, axis=1) self.Ftot = np.append(self.Ftot, self.Fephy, axis=1) self.Ftot = np.append(self.Ftot, self.Fephz, axis=1) if not makeDM and not makeEph: self.Ftot = self.Fred self.Te = np.append(self.Gc, self.Ftot, axis=1)
def makeTe(self, nmodes_red, Ttot, makeDM=False, nmodes_dm=None, makeEph=False, nmodes_eph=None, ephFreqs=None, phaseshift=False): self.Fred, self.ranphase = utils.createFourierDesignmatrix_red( self.toas, nmodes=nmodes_red, pshift=phaseshift, Tspan=Ttot) self.Ftot = self.Fred if makeDM: if nmodes_dm is None: nmodes_tmp = nmodes_red else: nmodes_tmp = nmodes_dm self.Fdm = utils.createFourierDesignmatrix_dm(self.toas, nmodes_tmp, self.obs_freqs, Tspan=Ttot) self.Ftot = np.append(self.Ftot, self.Fdm, axis=1) if makeEph: if nmodes_eph is None: nmodes_tmp = nmodes_red else: nmodes_tmp = nmodes_eph self.Fephx, self.Fephy, self.Fephz = \ utils.createFourierDesignmatrix_eph(self.toas, nmodes_tmp, self.psr_locs, Tspan=Ttot, input_freqs=ephFreqs) self.Ftot = np.append(self.Ftot, self.Fephx, axis=1) self.Ftot = np.append(self.Ftot, self.Fephy, axis=1) self.Ftot = np.append(self.Ftot, self.Fephz, axis=1) self.Te = np.append(self.Gc, self.Ftot, axis=1)
def OSupperLimit(psr, GCGnoiseInv, ORF, OSsmbhb, ul_list=None, far=None, drlist=None, tex=True, nlims=60): if tex == True: plt.rcParams['text.usetex'] = True gam_bkgrd = np.linspace(1.01,6.99,nlims) optStatList=[] ct=0 for indx in gam_bkgrd: optStatList.append( utils.optStat(psr, GCGnoiseInv, ORF, gam_gwb=indx)[:3] ) ct+=1 print "Finished {0}% of optimal-statistic upper-limit calculations...".format( 100.0*ct/(1.0*nlims) ) optStatList = np.array(optStatList) fig, ax = plt.subplots() stylelist = ['solid','dashed','dotted'] if ul_list is not None: for ii in range(len(ul_list)): ax.plot(gam_bkgrd, np.sqrt( optStatList[:,0] + optStatList[:,1]*np.sqrt(2.0)*( ss.erfcinv(2.0*(1.-ul_list[ii])) ) ), linestyle=stylelist[ii], color='black', linewidth=3.0, label='$A_h$ {0}$\%$ upper-limit'.format(ul_list[ii]*100)) plt.hlines(y=np.sqrt( OSsmbhb[0] + OSsmbhb[1]*np.sqrt(2.0)*( ss.erfcinv(2.0*(1.-ul_list[ii])) ) ), xmin=gam_bkgrd.min(), xmax=13./3., linewidth=3.0, linestyle='solid', color='red') plt.vlines(x=13./3., ymin=0.0, ymax=np.sqrt( OSsmbhb[0] + OSsmbhb[1]*np.sqrt(2.0)*( ss.erfcinv(2.0*(1.-ul_list[ii])) ) ), linewidth=3.0, linestyle='solid', color='red') else: for ii in range(len(drlist)): ax.plot(gam_bkgrd, np.sqrt( optStatList[:,1]*np.sqrt(2.0)*( ss.erfcinv(2.0*far) - ss.erfcinv(2.0*drlist[ii]) ) ), linestyle=stylelist[ii], color='black', linewidth=3.0, label='$A_h$ ({0}$\%$ FAR, {1}$\%$ DR)'.format(far*100,drlist[ii]*100)) plt.hlines(y=np.sqrt( OSsmbhb*np.sqrt(2.0)*( ss.erfcinv(2.0*far) - ss.erfcinv(2.0*drlist[ii]) ) ), xmin=gam_bkgrd.min(), xmax=13./3., linewidth=3.0, linestyle='solid', color='red') plt.vlines(x=13./3., ymin=0.0, ymax=np.sqrt( OSsmbhb*np.sqrt(2.0)*( ss.erfcinv(2.0*far) - ss.erfcinv(2.0*drlist[ii]) ) ), linewidth=3.0, linestyle='solid', color='red') ax.set_yscale('log') ax.set_xlabel(r'$\gamma\equiv 3-2\alpha$', fontsize=20) ax.set_ylabel(r'$A_h$', fontsize=20) ax.minorticks_on() plt.tick_params(labelsize=18) plt.grid(which='major') plt.grid(which='minor') plt.title('Optimal-statistic bounds') plt.legend(loc='lower left', shadow=True, frameon=True, prop={'size':15}) plt.show()
def makeFeph(self, nmodes, Ttot): self.Fephx, self.Fephy, self.Fephz = \ utils.createFourierDesignmatrix_eph(self.toas, nmodes, self.psr_locs, Tspan=Ttot)
gam_dm_ML.append(float(f.readline().split()[3])) Ared_ML.append(float(f.readline().split()[3])) gam_red_ML.append(float(f.readline().split()[3])) for jj in range(len(backends[ii])): EFAC_ML[ii][jj] = float(f.readline().split()[3]) for jj in range(len(backends[ii])): EQUAD_ML[ii][jj] = float(f.readline().split()[3]) ################################################################################################################################ # MAKE FIXED NOISE MATRICES FROM MAXIMUM-LIKELIHOOD VALUES OF SINGLE-PULSAR ANALYSIS ################################################################################################################################ GGCGG=[] for ii in range(len(psr)): tgrid = utils.makeTimeGrid(psr[ii], psr[ii]) Cred = utils.makeRedTDcov(Ared_ML[ii], gam_red_ML[ii], tgrid) Cdm = utils.makeDmTDcov(psr[ii], Adm_ML[ii], gam_dm_ML[ii], tgrid) Cwhite = np.diag(psr[ii].toaerrs**2.0) ######## GCGnoise = np.dot(psr[ii].G.T, np.dot(Cred+Cdm+Cwhite, psr[ii].G)) GCGnoise = np.nan_to_num(GCGnoise) cho = sl.cho_factor(GCGnoise) GGCGG.append( np.dot(psr[ii].G, np.dot(sl.cho_solve(cho, np.eye(len(GCGnoise))), psr[ii].G.T)) ) ################################################################################################################################ # DEFINING THE PRIOR AND THE LOG-LIKELIHOOD ################################################################################################################################
def ln_prob(xx): Ared = 10.0**xx[0] gam_red = xx[1] ct = 2 if args.incDM: Adm = 10.0**xx[ct] gam_dm = xx[ct+1] ct = 4 EFAC = xx[ct:ct+len(systems)] ct += len(systems) if args.fullN: EQUAD = 10.0**xx[ct:ct+len(systems)] ct += len(systems) ECORR = [] if 'pta' in t2psr.flags(): if 'NANOGrav' in list(set(t2psr.flagvals('pta'))): if len(psr.sysflagdict['nano-f'].keys())>0: ECORR = 10.0**xx[ct:ct+len(psr.sysflagdict['nano-f'].keys())] ct += len(psr.sysflagdict['nano-f'].keys()) if args.incGlitch: glitch_epoch = xx[ct] glitch_lamp = xx[ct+1] loglike1 = 0. #################################### #################################### scaled_err = (psr.toaerrs).copy() for jj,sysname in enumerate(systems): scaled_err[systems[sysname]] *= EFAC[jj] ### white_noise = np.zeros(len(scaled_err)) if args.fullN: white_noise = np.ones(len(scaled_err)) for jj,sysname in enumerate(systems): white_noise[systems[sysname]] *= EQUAD[jj] new_err = np.sqrt( scaled_err**2.0 + white_noise**2.0 ) ######## if args.incGlitch: model_res = psr.res - utils.glitch_signal(psr, glitch_epoch, glitch_lamp) elif not args.incGlitch: model_res = psr.res # compute ( T.T * N^-1 * T ) # & log determinant of N if args.fullN: if len(ECORR)>0: Jamp = np.ones(len(psr.epflags)) for jj,nano_sysname in enumerate(psr.sysflagdict['nano-f'].keys()): Jamp[np.where(psr.epflags==nano_sysname)] *= ECORR[jj]**2.0 Nx = jitter.cython_block_shermor_0D(model_res, new_err**2., Jamp, psr.Uinds) d = np.dot(psr.Te.T, Nx) logdet_N, TtNT = \ jitter.cython_block_shermor_2D(psr.Te, new_err**2., Jamp, psr.Uinds) det_dummy, dtNdt = \ jitter.cython_block_shermor_1D(model_res, new_err**2., Jamp, psr.Uinds) else: d = np.dot(psr.Te.T, model_res/( new_err**2.0 )) N = 1./( new_err**2.0 ) right = (N*psr.Te.T).T TtNT = np.dot(psr.Te.T, right) logdet_N = np.sum(np.log( new_err**2.0 )) # triple product in likelihood function dtNdt = np.sum(model_res**2.0/( new_err**2.0 )) else: d = np.dot(psr.Te.T, model_res/( new_err**2.0 )) N = 1./( new_err**2.0 ) right = (N*psr.Te.T).T TtNT = np.dot(psr.Te.T, right) logdet_N = np.sum(np.log( new_err**2.0 )) # triple product in likelihood function dtNdt = np.sum(model_res**2.0/( new_err**2.0 )) loglike1 += -0.5 * (logdet_N + dtNdt) #################################### #################################### # parameterize intrinsic red noise as power law Tspan = (1/fqs[0])*86400.0 f1yr = 1/3.16e7 # parameterize intrinsic red-noise and DM-variations as power law if args.incDM: kappa = np.log10( np.append( Ared**2/12/np.pi**2 * \ f1yr**(gam_red-3) * \ (fqs/86400.0)**(-gam_red)/Tspan, Adm**2/12/np.pi**2 * \ f1yr**(gam_dm-3) * \ (fqs/86400.0)**(-gam_dm)/Tspan ) ) else: kappa = np.log10( Ared**2/12/np.pi**2 * \ f1yr**(gam_red-3) * \ (fqs/86400.0)**(-gam_red)/Tspan ) # construct elements of sigma array if args.incDM: mode_count = 4*nmode else: mode_count = 2*nmode diagonal = np.zeros(mode_count) diagonal[0::2] = 10**kappa diagonal[1::2] = 10**kappa # compute Phi inverse red_phi = np.diag(1./diagonal) logdet_Phi = np.sum(np.log( diagonal )) # now fill in real covariance matrix Phi = np.zeros( TtNT.shape ) for kk in range(0,mode_count): Phi[kk+psr.Gc.shape[1],kk+psr.Gc.shape[1]] = red_phi[kk,kk] # symmeterize Phi Phi = Phi + Phi.T - np.diag(np.diag(Phi)) # compute sigma Sigma = TtNT + Phi # cholesky decomp for second term in exponential try: cf = sl.cho_factor(Sigma) expval2 = sl.cho_solve(cf, d) logdet_Sigma = np.sum(2*np.log(np.diag(cf[0]))) except np.linalg.LinAlgError: #print 'Cholesky Decomposition Failed second time!! Using SVD instead' #u,s,v = sl.svd(Sigma) #expval2 = np.dot(v.T, 1/s*np.dot(u.T, d)) #logdet_Sigma = np.sum(np.log(s)) print 'Cholesky Decomposition Failed second time!! Getting outta here...' return -np.inf logLike = -0.5 * (logdet_Phi + logdet_Sigma) + \ 0.5 * (np.dot(d, expval2)) + loglike1 prior_fac = 0.0 if args.redPrior == 'uniform': prior_fac += np.log(Ared * np.log(10.0)) if args.incDM and (args.dmPrior == 'uniform'): prior_fac += np.log(Adm * np.log(10.0)) return logLike + prior_fac
def makeFred(self, nmodes, Ttot, phaseshift=False, input_freqs=None): self.Fred, self.ranphase = \ utils.createFourierDesignmatrix_red(self.toas, nmodes=nmodes, pshift=phaseshift, Tspan=Ttot, input_freqs=input_freqs)
def grab_all_vars(self, jitterbin=10., makeGmat=False, fastDesign=True): # jitterbin is in seconds print "--> Processing {0}".format(self.T2psr.name) # basic quantities self.name = self.T2psr.name self.toas = np.double(self.T2psr.toas()) self.res = np.double(self.T2psr.residuals()) self.toaerrs = np.double(self.T2psr.toaerrs) * 1e-6 self.obs_freqs = np.double(self.T2psr.ssbfreqs()) self.Mmat = np.double(self.T2psr.designmatrix()) isort, iisort = None, None if 'pta' in self.T2psr.flags(): if 'NANOGrav' in list(set(self.T2psr.flagvals('pta'))): # now order everything try: isort, iisort = utils.argsortTOAs( self.toas, self.T2psr.flagvals('group'), which='jitterext', dt=jitterbin / 86400.) except KeyError: isort, iisort = utils.argsortTOAs(self.toas, self.T2psr.flagvals('f'), which='jitterext', dt=jitterbin / 86400.) # sort data self.toas = self.toas[isort] self.toaerrs = self.toaerrs[isort] self.res = self.res[isort] self.obs_freqs = self.obs_freqs[isort] self.Mmat = self.Mmat[isort, :] print "--> Initial sorting of data." # get the sky position if 'RAJ' and 'DECJ' in self.T2psr.pars(): self.psr_locs = [ np.double(self.T2psr['RAJ'].val), np.double(self.T2psr['DECJ'].val) ] elif 'ELONG' and 'ELAT' in self.T2psr.pars(): fac = 180. / np.pi # check for B name if 'B' in self.name: epoch = '1950' else: epoch = '2000' coords = Equatorial(Ecliptic(str(self.T2psr['ELONG'].val * fac), str(self.T2psr['ELAT'].val * fac)), epoch=epoch) self.psr_locs = [float(repr(coords.ra)), float(repr(coords.dec))] print "--> Grabbed the pulsar position." ################################################################################################ # These are all the relevant system flags used by the PTAs. system_flags = ['group', 'sys', 'i', 'f'] self.sysflagdict = OrderedDict.fromkeys(system_flags) # Put the systems into a dictionary which # has the locations of their toa placements. for systm in self.sysflagdict: try: if systm in self.T2psr.flags(): sys_uflagvals = list(set(self.T2psr.flagvals(systm))) self.sysflagdict[systm] = OrderedDict.fromkeys( sys_uflagvals) for kk, subsys in enumerate(sys_uflagvals): if isort is not None: self.sysflagdict[systm][subsys] = \ np.where(self.T2psr.flagvals(systm)[isort] == sys_uflagvals[kk]) elif isort is None: self.sysflagdict[systm][subsys] = \ np.where(self.T2psr.flagvals(systm) == sys_uflagvals[kk]) except KeyError: pass # If we have some NANOGrav data, then separate # this off for later ECORR assignment. if 'pta' in self.T2psr.flags(): pta_names = list(set(self.T2psr.flagvals('pta'))) pta_mask = [ self.T2psr.flagvals('pta')[isort] == ptaname for ptaname in pta_names ] pta_maskdict = OrderedDict.fromkeys(pta_names) for ii, item in enumerate(pta_maskdict): pta_maskdict[item] = pta_mask[ii] if len(pta_names) != 0 and ('NANOGrav' in pta_names): try: nanoflagdict = OrderedDict.fromkeys(['nano-f']) nano_flags = list( set( self.T2psr.flagvals('group')[ pta_maskdict['NANOGrav']])) nanoflagdict['nano-f'] = OrderedDict.fromkeys(nano_flags) for kk, subsys in enumerate(nano_flags): nanoflagdict['nano-f'][subsys] = \ np.where(self.T2psr.flagvals('group')[isort] == nano_flags[kk]) self.sysflagdict.update(nanoflagdict) except KeyError: nanoflagdict = OrderedDict.fromkeys(['nano-f']) nano_flags = list( set( self.T2psr.flagvals('f')[ pta_maskdict['NANOGrav']])) nanoflagdict['nano-f'] = OrderedDict.fromkeys(nano_flags) for kk, subsys in enumerate(nano_flags): nanoflagdict['nano-f'][subsys] = \ np.where(self.T2psr.flagvals('f')[isort] == nano_flags[kk]) self.sysflagdict.update(nanoflagdict) # If there are really no relevant flags, # then just make a full list of the toa indices. if np.all([self.sysflagdict[sys] is None for sys in self.sysflagdict]): print "No relevant flags found" print "Assuming one overall system for {0}\n".format( self.T2psr.name) self.sysflagdict[self.T2psr.name] = OrderedDict.fromkeys( [self.T2psr.name]) self.sysflagdict[self.T2psr.name][self.T2psr.name] = np.arange( len(self.toas)) print "--> Processed all relevant flags plus associated locations." ################################################################################################## if 'pta' in self.T2psr.flags(): if 'NANOGrav' in pta_names: # now order everything try: #isort_b, iisort_b = utils.argsortTOAs(self.toas, self.T2psr.flagvals('group')[isort], #which='jitterext', dt=jitterbin/86400.) flags = self.T2psr.flagvals('group')[isort] except KeyError: #isort_b, iisort_b = utils.argsortTOAs(self.toas, self.T2psr.flagvals('f')[isort], #which='jitterext', dt=jitterbin/86400.) flags = self.T2psr.flagvals('f')[isort] # sort data #self.toas = self.toas[isort_b] #self.toaerrs = self.toaerrs[isort_b] #self.res = self.res[isort_b] #self.obs_freqs = self.obs_freqs[isort_b] #self.Mmat = self.Mmat[isort_b, :] #flags = flags[isort_b] print "--> Sorted data." # get quantization matrix avetoas, self.Umat, Ui = utils.quantize_split(self.toas, flags, dt=jitterbin / 86400., calci=True) print "--> Computed quantization matrix." self.detsig_avetoas = avetoas.copy() self.detsig_Uinds = utils.quant2ind(self.Umat) # get only epochs that need jitter/ecorr self.Umat, avetoas, aveflags = utils.quantreduce( self.Umat, avetoas, flags) print "--> Excized epochs without jitter." # get quantization indices self.Uinds = utils.quant2ind(self.Umat) self.epflags = flags[self.Uinds[:, 0]] print "--> Checking TOA sorting and quantization..." print utils.checkTOAsort(self.toas, flags, which='jitterext', dt=jitterbin / 86400.) print utils.checkquant(self.Umat, flags) print "...Finished checks." # perform SVD of design matrix to stabilise if fastDesign: print "--> Stabilizing the design matrix the fast way..." Mm = self.Mmat.copy() norm = np.sqrt(np.sum(Mm**2, axis=0)) Mm /= norm self.Gc = Mm else: print "--> Performing SVD of design matrix for stabilization..." u, s, v = np.linalg.svd(self.Mmat) if makeGmat: self.G = u[:, len(s):len(u)] self.Gres = np.dot(self.G.T, self.res) self.Gc = u[:, :len(s)] print "--> Done reading in pulsar :-) \n"
EQUAD_ML[ii][jj] = float(f.readline().split()[3]) ################################################################################################################################ # MAKE FIXED NOISE MATRICES FROM MAXIMUM-LIKELIHOOD VALUES OF SINGLE-PULSAR ANALYSIS ################################################################################################################################ GCGnoiseInv=[] for ii in range(len(psr)): #################################################################### # For each pulsar, obtain the ML A_h value with scalar maximisation #################################################################### #func = lambda x: -utils.singlePsrLL(psr[ii], x, gam_gwb=13./3.) #fbounded = sciopt.minimize_scalar(func, bounds=(0.0, utils.sigma_gwRMS(psr[ii]), 1.0e-13), method='Golden') #Agwb_ML = fbounded.x tgrid = utils.makeTimeGrid(psr[ii], psr[ii]) #Cgwb_ML = utils.makeRedTDcov(Agwb_ML, 13./3., tgrid) Cred = utils.makeRedTDcov(Ared_ML[ii], gam_red_ML[ii], tgrid) Cdm = utils.makeDmTDcov(psr[ii], Adm_ML[ii], gam_dm_ML[ii], tgrid) Cwhite = np.diag(psr[ii].toaerrs**2.0) ######## #GCGnoise = np.dot(psr[ii].G.T, np.dot(Cgwb_ML+Cred+Cdm+Cwhite, psr[ii].G)) GCGnoise = np.dot(psr[ii].G.T, np.dot(Cred+Cdm+Cwhite, psr[ii].G)) GCGnoise = np.nan_to_num(GCGnoise) cho = sl.cho_factor(GCGnoise) GCGnoiseInv.append(sl.cho_solve(cho, np.eye(len(GCGnoise)))) gam_bkgrd = 4.33333 optimalStat = utils.optStat(psr, GCGnoiseInv, HnD, gam_gwb=gam_bkgrd)
def makeFred(self, fqs_red, wgts_red, Ttot, phaseshift=False): self.Fred, self.ranphase = \ utils.createFourierDesignmatrix_red(self.toas, fqs_red, wgts_red, pshift=phaseshift, Tspan=Ttot)
def makeFeph(self, fqs_eph, wgts_eph, psr_locs, Ttot): self.Fephx, self.Fephy, self.Fephz = \ utils.createFourierDesignmatrix_eph(self.toas, fqs_eph, wgts_eph, self.psrPos, Tspan=Ttot)
def makeFdm(self, nmodes, Ttot): self.Fdm = utils.createFourierDesignmatrix_dm(self.toas, nmodes, self.obs_freqs, Tspan=Ttot)
def ln_prob(xx): Ared = 10.0**xx[0] gam_red = xx[1] ct = 2 if args.dmVar: Adm = 10.0**xx[ct] gam_dm = xx[ct + 1] ct = 4 EFAC = xx[ct:ct + len(systems)] ct += len(systems) if args.fullN: EQUAD = 10.0**xx[ct + len(systems):ct + 2 * len(systems)] ct += len(systems) if 'pta' in t2psr.flags(): if len(psr.sysflagdict['nano-f'].keys()) > 0: ECORR = 10.0**xx[ct:ct + len(psr.sysflagdict['nano-f'].keys())] ct += len(psr.sysflagdict['nano-f'].keys()) if args.incGlitch: glitch_epoch = xx[ct] glitch_lamp = xx[ct + 1] loglike1 = 0 #################################### #################################### scaled_err = (psr.toaerrs).copy() for jj, sysname in enumerate(systems): scaled_err[systems[sysname]] *= EFAC[jj] ### white_noise = np.zeros(len(scaled_err)) if args.fullN: white_noise = np.ones(len(scaled_err)) for jj, sysname in enumerate(systems): white_noise[systems[sysname]] *= EQUAD[jj] new_err = np.sqrt(scaled_err**2.0 + white_noise**2.0) ######## if args.incGlitch: model_res = psr.res - utils.glitch_signal(psr, glitch_epoch, glitch_lamp) elif not incGlitch: model_res = psr.res # compute ( T.T * N^-1 * T ) # & log determinant of N if args.fullN: if len(ECORR) > 0: Jamp = np.ones(len(psr.epflags)) for jj, nano_sysname in enumerate( psr.sysflagdict['nano-f'].keys()): Jamp[np.where(psr.epflags == nano_sysname)] *= ECORR[jj]**2.0 Nx = jitter.cython_block_shermor_0D(model_res, new_err**2., Jamp, psr.Uinds) d = np.dot(psr.Te.T, Nx) logdet_N, TtNT = \ jitter.cython_block_shermor_2D(psr.Te, new_err**2., Jamp, psr.Uinds) det_dummy, dtNdt = \ jitter.cython_block_shermor_1D(model_res, new_err**2., Jamp, psr.Uinds) else: d = np.dot(psr.Te.T, model_res / (new_err**2.0)) N = 1. / (new_err**2.0) right = (N * psr.Te.T).T TtNT = np.dot(psr.Te.T, right) logdet_N = np.sum(np.log(new_err**2.0)) # triple product in likelihood function dtNdt = np.sum(model_res**2.0 / (new_err**2.0)) else: d = np.dot(psr.Te.T, model_res / (new_err**2.0)) N = 1. / (new_err**2.0) right = (N * psr.Te.T).T TtNT = np.dot(psr.Te.T, right) logdet_N = np.sum(np.log(new_err**2.0)) # triple product in likelihood function dtNdt = np.sum(model_res**2.0 / (new_err**2.0)) loglike1 += -0.5 * (logdet_N + dtNdt) #################################### #################################### # parameterize intrinsic red noise as power law Tspan = (1 / fqs[0]) * 86400.0 f1yr = 1 / 3.16e7 # parameterize intrinsic red-noise and DM-variations as power law if args.dmVar: kappa = np.log10( np.append( Ared**2/12/np.pi**2 * \ f1yr**(gam_red-3) * \ (fqs/86400.0)**(-gam_red)/Tspan, Adm**2/12/np.pi**2 * \ f1yr**(gam_dm-3) * \ (fqs/86400.0)**(-gam_dm)/Tspan ) ) else: kappa = np.log10( Ared**2/12/np.pi**2 * \ f1yr**(gam_red-3) * \ (fqs/86400.0)**(-gam_red)/Tspan ) # construct elements of sigma array if args.dmVar: mode_count = 4 * nmode else: mode_count = 2 * nmode diagonal = np.zeros(mode_count) diagonal[0::2] = 10**kappa diagonal[1::2] = 10**kappa # compute Phi inverse red_phi = np.diag(1. / diagonal) logdet_Phi = np.sum(np.log(diagonal)) # now fill in real covariance matrix Phi = np.zeros(TtNT.shape) for kk in range(0, mode_count): Phi[kk + psr.Gc.shape[1], kk + psr.Gc.shape[1]] = red_phi[kk, kk] # symmeterize Phi Phi = Phi + Phi.T - np.diag(np.diag(Phi)) # compute sigma Sigma = TtNT + Phi # cholesky decomp for second term in exponential try: cf = sl.cho_factor(Sigma) expval2 = sl.cho_solve(cf, d) logdet_Sigma = np.sum(2 * np.log(np.diag(cf[0]))) except np.linalg.LinAlgError: print 'Cholesky Decomposition Failed second time!! Using SVD instead' u, s, v = sl.svd(Sigma) expval2 = np.dot(v.T, 1 / s * np.dot(u.T, d)) logdet_Sigma = np.sum(np.log(s)) logLike = -0.5 * (logdet_Phi + logdet_Sigma) + \ 0.5 * (np.dot(d, expval2)) + loglike1 prior_fac = 0.0 if args.redamp_prior == 'uniform': prior_fac += np.log(Ared * np.log(10.0)) if (args.dmVar == True) and (args.dmamp_prior == 'uniform'): prior_fac += np.log(Adm * np.log(10.0)) return logLike + prior_fac
def makeFred(self, nmodes, Ttot, phaseshift=False): self.Fred, self.ranphase = utils.createFourierDesignmatrix_red( self.toas, nmodes=nmodes, pshift=phaseshift, Tspan=Ttot)
def grab_all_vars(self, jitterbin=10., makeGmat=False, fastDesign=True, planetssb=False): # jitterbin is in seconds print "--> Processing {0}".format(self.T2psr.name) # basic quantities self.name = self.T2psr.name self.toas = np.double(self.T2psr.toas()) self.res = np.double(self.T2psr.residuals()) self.toaerrs = np.double(self.T2psr.toaerrs) * 1e-6 self.obs_freqs = np.double(self.T2psr.ssbfreqs()) self.Mmat = np.double(self.T2psr.designmatrix()) # get the position vectors of the planets if planetssb: for ii in range(1,10): tag = 'DMASSPLANET'+str(ii) self.T2psr[tag].val = 0.0 self.T2psr.formbats() self.planet_ssb = np.zeros((len(self.toas),9,6)) self.planet_ssb[:,0,:] = self.T2psr.mercury_ssb self.planet_ssb[:,1,:] = self.T2psr.venus_ssb self.planet_ssb[:,2,:] = self.T2psr.earth_ssb self.planet_ssb[:,3,:] = self.T2psr.mars_ssb self.planet_ssb[:,4,:] = self.T2psr.jupiter_ssb self.planet_ssb[:,5,:] = self.T2psr.saturn_ssb self.planet_ssb[:,6,:] = self.T2psr.uranus_ssb self.planet_ssb[:,7,:] = self.T2psr.neptune_ssb self.planet_ssb[:,8,:] = self.T2psr.pluto_ssb print "--> Grabbed the planet position-vectors at the pulsar timestamps." isort, iisort = None, None if 'pta' in self.T2psr.flags(): if 'NANOGrav' in list(set(self.T2psr.flagvals('pta'))): # now order everything try: isort, iisort = utils.argsortTOAs(self.toas, self.T2psr.flagvals('group'), which='jitterext', dt=jitterbin/86400.) except KeyError: isort, iisort = utils.argsortTOAs(self.toas, self.T2psr.flagvals('f'), which='jitterext', dt=jitterbin/86400.) # sort data self.toas = self.toas[isort] self.toaerrs = self.toaerrs[isort] self.res = self.res[isort] self.obs_freqs = self.obs_freqs[isort] self.Mmat = self.Mmat[isort, :] if planetssb: self.planet_ssb = self.planet_ssb[isort, :, :] print "--> Initial sorting of data." # get the sky position if 'RAJ' and 'DECJ' in self.T2psr.pars(): self.psr_locs = [np.double(self.T2psr['RAJ'].val),np.double(self.T2psr['DECJ'].val)] elif 'ELONG' and 'ELAT' in self.T2psr.pars(): fac = 180./np.pi # check for B name if 'B' in self.name: epoch = '1950' else: epoch = '2000' coords = Equatorial(Ecliptic(str(self.T2psr['ELONG'].val*fac), str(self.T2psr['ELAT'].val*fac)), epoch=epoch) self.psr_locs = [float(repr(coords.ra)),float(repr(coords.dec))] print "--> Grabbed the pulsar position." ################################################################################################ # These are all the relevant system flags used by the PTAs. system_flags = ['group','f','sys','g','h'] self.sysflagdict = OrderedDict.fromkeys(system_flags) # Put the systems into a dictionary which # has the locations of their toa placements. for systm in self.sysflagdict: try: if systm in self.T2psr.flags(): sys_uflagvals = list(set(self.T2psr.flagvals(systm))) self.sysflagdict[systm] = OrderedDict.fromkeys(sys_uflagvals) for kk,subsys in enumerate(sys_uflagvals): if isort is not None: self.sysflagdict[systm][subsys] = \ np.where(self.T2psr.flagvals(systm)[isort] == sys_uflagvals[kk]) elif isort is None: self.sysflagdict[systm][subsys] = \ np.where(self.T2psr.flagvals(systm) == sys_uflagvals[kk]) except KeyError: pass # If we have some NANOGrav data, then separate # this off for later ECORR assignment. if 'pta' in self.T2psr.flags(): pta_names = list(set(self.T2psr.flagvals('pta'))) pta_mask = [self.T2psr.flagvals('pta')[isort]==ptaname for ptaname in pta_names] pta_maskdict = OrderedDict.fromkeys(pta_names) for ii,item in enumerate(pta_maskdict): pta_maskdict[item] = pta_mask[ii] if len(pta_names)!=0 and ('NANOGrav' in pta_names): try: nanoflagdict = OrderedDict.fromkeys(['nano-f']) nano_flags = list(set(self.T2psr.flagvals('group')[isort][pta_maskdict['NANOGrav']])) nanoflagdict['nano-f'] = OrderedDict.fromkeys(nano_flags) for kk,subsys in enumerate(nano_flags): nanoflagdict['nano-f'][subsys] = \ np.where(self.T2psr.flagvals('group')[isort] == nano_flags[kk]) self.sysflagdict.update(nanoflagdict) except KeyError: nanoflagdict = OrderedDict.fromkeys(['nano-f']) nano_flags = list(set(self.T2psr.flagvals('f')[isort][pta_maskdict['NANOGrav']])) nanoflagdict['nano-f'] = OrderedDict.fromkeys(nano_flags) for kk,subsys in enumerate(nano_flags): nanoflagdict['nano-f'][subsys] = \ np.where(self.T2psr.flagvals('f')[isort] == nano_flags[kk]) self.sysflagdict.update(nanoflagdict) # If there are really no relevant flags, # then just make a full list of the toa indices. if np.all([self.sysflagdict[sys] is None for sys in self.sysflagdict]): print "No relevant flags found" print "Assuming one overall system for {0}\n".format(self.T2psr.name) self.sysflagdict[self.T2psr.name] = OrderedDict.fromkeys([self.T2psr.name]) self.sysflagdict[self.T2psr.name][self.T2psr.name] = np.arange(len(self.toas)) print "--> Processed all relevant flags plus associated locations." ################################################################################################## if 'pta' in self.T2psr.flags(): if 'NANOGrav' in pta_names: # now order everything try: #isort_b, iisort_b = utils.argsortTOAs(self.toas, self.T2psr.flagvals('group')[isort], #which='jitterext', dt=jitterbin/86400.) flags = self.T2psr.flagvals('group')[isort] except KeyError: #isort_b, iisort_b = utils.argsortTOAs(self.toas, self.T2psr.flagvals('f')[isort], #which='jitterext', dt=jitterbin/86400.) flags = self.T2psr.flagvals('f')[isort] # sort data #self.toas = self.toas[isort_b] #self.toaerrs = self.toaerrs[isort_b] #self.res = self.res[isort_b] #self.obs_freqs = self.obs_freqs[isort_b] #self.Mmat = self.Mmat[isort_b, :] #flags = flags[isort_b] print "--> Sorted data." # get quantization matrix avetoas, self.Umat, Ui = utils.quantize_split(self.toas, flags, dt=jitterbin/86400., calci=True) print "--> Computed quantization matrix." self.detsig_avetoas = avetoas.copy() self.detsig_Uinds = utils.quant2ind(self.Umat) # get only epochs that need jitter/ecorr self.Umat, avetoas, aveflags = utils.quantreduce(self.Umat, avetoas, flags) print "--> Excized epochs without jitter." # get quantization indices self.Uinds = utils.quant2ind(self.Umat) self.epflags = flags[self.Uinds[:, 0]] print "--> Checking TOA sorting and quantization..." print utils.checkTOAsort(self.toas, flags, which='jitterext', dt=jitterbin/86400.) print utils.checkquant(self.Umat, flags) print "...Finished checks." # perform SVD of design matrix to stabilise if fastDesign: print "--> Stabilizing the design matrix the fast way..." Mm = self.Mmat.copy() norm = np.sqrt(np.sum(Mm ** 2, axis=0)) Mm /= norm self.Gc = Mm else: print "--> Performing SVD of design matrix for stabilization..." u,s,v = np.linalg.svd(self.Mmat) if makeGmat: self.G = u[:,len(s):len(u)] self.Gres = np.dot(self.G.T, self.res) self.Gc = u[:,:len(s)] print "--> Done reading in pulsar :-) \n"
def makeFred(self, nmodes, Ttot, phaseshift=False): self.Fred, self.ranphase = utils.createFourierDesignmatrix_red(self.toas, nmodes=nmodes, pshift=phaseshift, Tspan=Ttot)
def makeFeph(self, nmodes, psr_locs, Ttot, input_freqs=None): self.Fephx, self.Fephy, self.Fephz = \ utils.createFourierDesignmatrix_eph(self.toas, nmodes=nmodes, psr_locs=self.psr_locs, Tspan=Ttot, input_freqs=input_freqs)
def grab_all_vars(self, jitterbin=10., makeGmat=False, fastDesign=True, planetssb=False, allEphem=False, startMJD=None, endMJD=None): # jitterbin is in seconds print "--> Processing {0}".format(self.T2psr.name) # basic quantities self.name = self.T2psr.name self.psrPos = self.T2psr.psrPos if 'ELONG' and 'ELAT' in self.T2psr.pars(): # converting to equatorial print "--> Converting pulsar position time-series to equatorial" self.psrPos = utils.ecl2eq_vec(self.psrPos) self.toas = np.double(self.T2psr.toas()) self.res = np.double(self.T2psr.residuals()) self.toaerrs = np.double(self.T2psr.toaerrs) * 1e-6 self.obs_freqs = np.double(self.T2psr.ssbfreqs()) self.Mmat = np.double(self.T2psr.designmatrix()) self.flags = self.T2psr.flags() self.flagvals = OrderedDict.fromkeys(self.flags) for flag in self.flags: self.flagvals[flag] = self.T2psr.flagvals(flag) # getting ephemeris properties self.ephemeris = self.T2psr.ephemeris if '436' in self.T2psr.ephemeris: self.ephemname = 'DE436' elif '435' in self.T2psr.ephemeris: self.ephemname = 'DE435' elif '430' in self.T2psr.ephemeris: self.ephemname = 'DE430' elif '421' in self.T2psr.ephemeris: self.ephemname = 'DE421' elif '418' in self.T2psr.ephemeris: self.ephemname = 'DE418' # populating roemer-delay dictionary self.roemer = OrderedDict() self.roemer[self.ephemname] = np.double(self.T2psr.roemer) # time filtering if startMJD is not None and endMJD is not None: self.tmask = np.logical_and(self.T2psr.toas() >= startMJD, self.T2psr.toas() <= endMJD) self.psrPos = self.psrPos[self.tmask] self.toas = self.toas[self.tmask] self.toaerrs = self.toaerrs[self.tmask] self.res = self.res[self.tmask] self.obs_freqs = self.obs_freqs[self.tmask] self.Mmat = self.Mmat[self.tmask,:] dmx_mask = np.sum(self.Mmat, axis=0) != 0.0 self.Mmat = self.Mmat[:,dmx_mask] for flag in self.flags: self.flagvals[flag] = self.T2psr.flagvals(flag)[self.tmask] for eph in self.roemer: self.roemer[eph] = self.roemer[eph][self.tmask] # get the position vectors of the planets if planetssb: if allEphem: # JPL planet position vectors will # always be in equatorial coordinates from jplephem.spk import SPK from scipy import constants as sc ephemchoices = sorted(glob.glob(os.environ['TEMPO2']+'/ephemeris/*')) matchers = ['421.bsp', '430t.bsp', '435t.bsp', '436t.bsp'] ephemfiles = [s for s in ephemchoices if any(xs in s for xs in matchers)] self.planet_ssb = OrderedDict() for eph in ephemfiles: if '436' in eph: ephemname = 'DE436' elif '435' in eph: ephemname = 'DE435' elif '430' in eph: ephemname = 'DE430' elif '421' in eph: ephemname = 'DE421' kernel = SPK.open(eph) jd = self.toas + mjd2jd self.planet_ssb[ephemname] = np.zeros((self.toas.shape[0],9,6)) for ii in range(9): position, velocity = kernel[0,ii+1].compute_and_differentiate(jd) position = np.hstack([position.T * 1e3 / sc.c, velocity.T * 1e3 / sc.c / 86400.]) self.planet_ssb[ephemname][:,ii,:] = position else: # Planet position vectors will initially # be in coordinate system of .par file for ii in range(1,10): tag = 'DMASSPLANET'+str(ii) self.T2psr[tag].val = 0.0 self.T2psr.formbats() self.planet_ssb = OrderedDict.fromkeys([self.ephemname]) self.planet_ssb[self.ephemname] = np.zeros((len(self.T2psr.toas()),9,6)) self.planet_ssb[self.ephemname][:,0,:] = self.T2psr.mercury_ssb self.planet_ssb[self.ephemname][:,1,:] = self.T2psr.venus_ssb self.planet_ssb[self.ephemname][:,2,:] = self.T2psr.earth_ssb self.planet_ssb[self.ephemname][:,3,:] = self.T2psr.mars_ssb self.planet_ssb[self.ephemname][:,4,:] = self.T2psr.jupiter_ssb self.planet_ssb[self.ephemname][:,5,:] = self.T2psr.saturn_ssb self.planet_ssb[self.ephemname][:,6,:] = self.T2psr.uranus_ssb self.planet_ssb[self.ephemname][:,7,:] = self.T2psr.neptune_ssb self.planet_ssb[self.ephemname][:,8,:] = self.T2psr.pluto_ssb if 'ELONG' and 'ELAT' in self.T2psr.pars(): # Converting to equatorial if necessary print "--> Converting planet position time-series to equatorial" for ii in range(9): # position self.planet_ssb[self.ephemname][:,ii,:3] = \ utils.ecl2eq_vec(self.planet_ssb[self.ephemname][:,ii,:3]) # velocity self.planet_ssb[self.ephemname][:,ii,3:] = \ utils.ecl2eq_vec(self.planet_ssb[self.ephemname][:,ii,3:]) if startMJD is not None and endMJD is not None: for eph in self.planet_ssb: self.planet_ssb[eph] = \ self.planet_ssb[eph][self.tmask,:,:] print "--> Grabbed the planet position-vectors at the pulsar timestamps." self.isort, self.iisort = None, None if 'pta' in self.flags: if 'NANOGrav' in list(set(self.flagvals['pta'])): # now order everything try: self.isort, self.iisort = utils.argsortTOAs(self.toas, self.flagvals['group'], which='jitterext', dt=jitterbin/86400.) except KeyError: self.isort, self.iisort = utils.argsortTOAs(self.toas, self.flagvals['f'], which='jitterext', dt=jitterbin/86400.) # sort data self.psrPos = self.psrPos[self.isort] self.toas = self.toas[self.isort] self.toaerrs = self.toaerrs[self.isort] self.res = self.res[self.isort] self.obs_freqs = self.obs_freqs[self.isort] self.Mmat = self.Mmat[self.isort, :] for eph in self.roemer: self.roemer[eph] = self.roemer[eph][self.isort] if planetssb: for eph in self.planet_ssb: self.planet_ssb[eph] = \ self.planet_ssb[eph][self.isort, :, :] print "--> Initial sorting of data." # get the sky position # check for B name if 'B' in self.T2psr.name: epoch = '1950' else: epoch = '2000' if 'RAJ' and 'DECJ' in self.T2psr.pars(which='set'): self.raj = np.double(self.T2psr['RAJ'].val) self.decj = np.double(self.T2psr['DECJ'].val) self.psr_locs = [self.raj, self.decj] eq = ephem.Equatorial(self.T2psr['RAJ'].val, self.T2psr['DECJ'].val) ec = ephem.Ecliptic(eq, epoch=epoch) self.elong = np.double(ec.lon) self.elat = np.double(ec.lat) elif 'ELONG' and 'ELAT' in self.T2psr.pars(which='set'): self.elong = np.double(self.T2psr['ELONG'].val) self.elat = np.double(self.T2psr['ELAT'].val) ec = ephem.Ecliptic(self.elong, self.elat) eq = ephem.Equatorial(ec, epoch=epoch) self.raj = np.double(eq.ra) self.decj = np.double(eq.dec) self.psr_locs = [self.raj, self.decj] print "--> Grabbed the pulsar position." ################################################################################################ # These are all the relevant system flags used by the PTAs. system_flags = ['group','f','sys','g','h'] self.sysflagdict = OrderedDict.fromkeys(system_flags) # Put the systems into a dictionary which # has the locations of their toa placements. for systm in self.sysflagdict: try: if systm in self.flags: sys_uflagvals = list(set(self.flagvals[systm])) self.sysflagdict[systm] = OrderedDict.fromkeys(sys_uflagvals) for kk,subsys in enumerate(sys_uflagvals): if self.isort is not None: self.sysflagdict[systm][subsys] = \ np.where(self.flagvals[systm][self.isort] == sys_uflagvals[kk]) elif self.isort is None: self.sysflagdict[systm][subsys] = \ np.where(self.flagvals[systm] == sys_uflagvals[kk]) except KeyError: pass # If we have some NANOGrav data, then separate # this off for later ECORR assignment. if 'pta' in self.flags: pta_names = list(set(self.flagvals['pta'])) pta_mask = [self.flagvals['pta'][self.isort]==ptaname for ptaname in pta_names] pta_maskdict = OrderedDict.fromkeys(pta_names) for ii,item in enumerate(pta_maskdict): pta_maskdict[item] = pta_mask[ii] if len(pta_names)!=0 and ('NANOGrav' in pta_names): try: nanoflagdict = OrderedDict.fromkeys(['nano-f']) nano_flags = list(set(self.flagvals['group'][self.isort][pta_maskdict['NANOGrav']])) nanoflagdict['nano-f'] = OrderedDict.fromkeys(nano_flags) for kk,subsys in enumerate(nano_flags): nanoflagdict['nano-f'][subsys] = \ np.where(self.flagvals['group'][self.isort] == nano_flags[kk]) self.sysflagdict.update(nanoflagdict) except KeyError: nanoflagdict = OrderedDict.fromkeys(['nano-f']) nano_flags = list(set(self.flagvals['f'][self.isort][pta_maskdict['NANOGrav']])) nanoflagdict['nano-f'] = OrderedDict.fromkeys(nano_flags) for kk,subsys in enumerate(nano_flags): nanoflagdict['nano-f'][subsys] = \ np.where(self.flagvals['f'][self.isort] == nano_flags[kk]) self.sysflagdict.update(nanoflagdict) # If there are really no relevant flags, # then just make a full list of the toa indices. if np.all([self.sysflagdict[sys] is None for sys in self.sysflagdict]): print "No relevant flags found" print "Assuming one overall system for {0}\n".format(self.T2psr.name) self.sysflagdict[self.T2psr.name] = OrderedDict.fromkeys([self.T2psr.name]) self.sysflagdict[self.T2psr.name][self.T2psr.name] = np.arange(len(self.toas)) print "--> Processed all relevant flags plus associated locations." ################################################################################################## if 'pta' in self.flags: if 'NANOGrav' in pta_names: # now order everything try: dummy_flags = self.flagvals['group'][self.isort] except KeyError: dummy_flags = self.flagvals['f'][self.isort] print "--> Sorted data." # get quantization matrix avetoas, self.Umat, Ui = utils.quantize_split(self.toas, dummy_flags, dt=jitterbin/86400., calci=True) print "--> Computed quantization matrix." self.detsig_avetoas = avetoas.copy() self.detsig_Uinds = utils.quant2ind(self.Umat) # get only epochs that need jitter/ecorr self.Umat, avetoas, aveflags = utils.quantreduce(self.Umat, avetoas, dummy_flags) print "--> Excized epochs without jitter." # get quantization indices self.Uinds = utils.quant2ind(self.Umat) self.epflags = dummy_flags[self.Uinds[:, 0]] print "--> Checking TOA sorting and quantization..." print utils.checkTOAsort(self.toas, dummy_flags, which='jitterext', dt=jitterbin/86400.) print utils.checkquant(self.Umat, dummy_flags) print "...Finished checks." # perform SVD of design matrix to stabilise if fastDesign: print "--> Stabilizing the design matrix the fast way..." Mm = self.Mmat.copy() norm = np.sqrt(np.sum(Mm ** 2, axis=0)) Mm /= norm self.Gc = Mm else: print "--> Performing SVD of design matrix for stabilization..." if makeGmat: u,s,v = np.linalg.svd(self.Mmat) self.G = u[:,len(s):len(u)] self.Gres = np.dot(self.G.T, self.res) self.Gc = u[:,:len(s)] elif not makeGmat: u,s,v = np.linalg.svd(self.Mmat, full_matrices=0) self.Gc = u print "--> Done reading in pulsar :-) \n"
def makeTe(self, Ttot, fqs_red, wgts_red, makeDM=False, fqs_dm=None, wgts_dm=None, makeEph=False, jplBasis=False, fqs_eph=None, wgts_eph=None, ephFreqs=None, makeClk=False, clkDesign=False, makeBand=False, bands=None, phaseshift=False, pshift_vals=None): self.Fred, self.ranphase = \ utils.createFourierDesignmatrix_red(self.toas, fqs_red, wgts_red, pshift=phaseshift, pshift_vals=pshift_vals, Tspan=Ttot) self.Ftot = self.Fred if makeDM: if fqs_dm is None: fqs_tmp = fqs_red wgts_tmp = wgts_red else: fqs_tmp = fqs_dm wgts_tmp = wgts_dm self.Fdm = utils.createFourierDesignmatrix_dm(self.toas, fqs_tmp, wgts_tmp, self.obs_freqs, Tspan=Ttot) self.Ftot = np.append(self.Ftot, self.Fdm, axis=1) if makeEph: if jplBasis: Fmother = np.load('./data/jplephbasis/Fmother.npy') mjd = np.load('./data/jplephbasis/mjd.npy') posvec = np.array([np.sin(np.pi/2.- self.elat)*np.cos(self.elong), np.sin(np.pi/2.- self.elat)*np.sin(self.elong), np.cos(np.pi/2.- self.elat)]) Fproj = np.dot(Fmother[:,:,:],posvec) Feph = np.vstack(np.interp(self.toas,mjd,Fproj[:,ii]) for ii in range(Fproj.shape[1])).T self.Ftot = np.append(self.Ftot, Feph, axis=1) else: if fqs_eph is None: fqs_tmp = fqs_red wgts_tmp = wgts_red else: fqs_tmp = fqs_eph wgts_tmp = wgts_eph self.Fephx, self.Fephy, self.Fephz = \ utils.createFourierDesignmatrix_eph(self.toas, fqs_tmp, wgts_tmp, self.psrPos, Tspan=Ttot, input_freqs=ephFreqs) self.Ftot = np.append(self.Ftot, self.Fephx, axis=1) self.Ftot = np.append(self.Ftot, self.Fephy, axis=1) self.Ftot = np.append(self.Ftot, self.Fephz, axis=1) if makeClk and clkDesign: self.Fclk, _ = utils.createFourierDesignmatrix_red(self.toas, fqs_red, wgts_red, pshift=False, Tspan=Ttot) self.Ftot = np.append(self.Ftot, self.Fclk, axis=1) if makeBand: if fqs_band is None: fqs_tmp = fqs_red wgts_tmp = wgts_red else: fqs_tmp = fqs_band wgts_tmp = wgts_band ## if bands is None: bands = np.array([0.0, 1.0, 2.0, 3.0]) elif bands is not None: bands = np.array([float(item) for item in bands.split(',')]) Fband_tmp = utils.createFourierDesignmatrix_red(self.toas, fqs_tmp, wgts_tmp, pshift=False, Tspan=Ttot) for ii in range(len(bands)-1): Fband_dummy = Fband_tmp.copy() Fband_dummy[np.logical(self.obs_freqs > 1e9*bands[ii], self.obs_freqs <= 1e9*bands[ii+1]),:] = 0.0 self.Ftot = np.append(self.Ftot, Fband_dummy, axis=1) self.Te = np.append(self.Gc, self.Ftot, axis=1)
def makeFdm(self, fqs_dm, wgts_dm, obs_freqs, Ttot): self.Fdm = utils.createFourierDesignmatrix_dm(self.toas, fqs_dm, wgts_dm, obs_freqs=self.obs_freqs, Tspan=Ttot)
def modelIndependentFullPTANoisePL(x): """ Model Independent stochastic background likelihood function """ Agwb = 10.0**x[0] if args.fix_slope: gam_gwb = 13. / 3. ct = 1 else: gam_gwb = x[1] ct = 2 ##### Ared = 10.0**x[ct:ct + len(psr)] gam_red = x[ct + len(psr):ct + 2 * len(psr)] Adm = 10.0**x[ct + 2 * len(psr):ct + 3 * len(psr)] gam_dm = x[ct + 3 * len(psr):ct + 4 * len(psr)] EFAC = x[ct + 4 * len(psr):ct + 5 * len(psr)] Acm = 10.0**x[ct + 5 * len(psr)] gam_cm = x[ct + 5 * len(psr) + 1] Aun = 10.0**x[ct + 5 * len(psr) + 2] gam_un = x[ct + 5 * len(psr) + 3] ################### orf_coeffs = x[ct + 5 * len(psr) + 4:] orf_coeffs = orf_coeffs.reshape( (tmp_num_gwfreq_wins, ((args.LMAX + 1)**2) - 1)) clm = np.array([[0.0] * ((args.LMAX + 1)**2) for ii in range(tmp_num_gwfreq_wins)]) clm[:, 0] = 2.0 * np.sqrt(np.pi) physicality = 0. if args.LMAX != 0: for kk in range(tmp_num_gwfreq_wins): for ii in range(1, ((args.LMAX + 1)**2)): clm[kk, ii] = orf_coeffs[kk, ii - 1] if (utils.PhysPrior(clm[kk], harm_sky_vals) == 'Unphysical'): physicality += -10.0**7.0 else: physicality += 0. npsr = len(psr) ORF = [] for ii in range(tmp_num_gwfreq_wins): # number of frequency windows for jj in range(len( anis_modefreqs[ii])): # number of frequencies in this window ORF.append( sum(clm[ii, kk] * CorrCoeff[kk] for kk in range(len(CorrCoeff)))) for ii in range(tmp_num_gwfreq_wins): # number of frequency windows for jj in range(len( anis_modefreqs[ii])): # number of frequencies in this window ORF.append(np.zeros((npsr, npsr))) ORF = np.array(ORF) ORFtot = np.zeros( (4 * args.nmodes, npsr, npsr) ) # shouldn't be applying ORF to dmfreqs, but the projection of GW spec onto dmfreqs is defined as zero below ORFtot[0::2] = ORF ORFtot[1::2] = ORF loglike1 = 0 FtNF = [] for p in range(len(psr)): # compute d if p == 0: d = np.dot(F_prime[p].T, res_prime[p] / ((EFAC[p]**2.0) * Diag[p])) else: d = np.append( d, np.dot(F_prime[p].T, res_prime[p] / ((EFAC[p]**2.0) * Diag[p]))) # compute FT N F N = 1. / ((EFAC[p]**2.0) * Diag[p]) right = (N * F_prime[p].T).T FtNF.append(np.dot(F_prime[p].T, right)) # log determinant of N logdet_N = np.sum(np.log((EFAC[p]**2.0) * Diag[p])) # triple product in likelihood function dtNdt = np.sum(res_prime[p]**2.0 / ((EFAC[p]**2.0) * Diag[p])) loglike1 += -0.5 * (logdet_N + dtNdt) # parameterize intrinsic red noise as power law Tspan = (1 / fqs[0]) * 86400.0 f1yr = 1 / 3.16e7 rho = np.log10(Agwb**2 / 12 / np.pi**2 * f1yr**(gam_gwb - 3) * (fqs / 86400.0)**(-gam_gwb) / Tspan) # spectrum of common-mode cm = np.log10(Acm**2 / 12 / np.pi**2 * f1yr**(gam_cm - 3) * (fqs / 86400.0)**(-gam_cm) / Tspan) # spectrum of common uncorrelated red-noise un = np.log10(Aun**2 / 12 / np.pi**2 * f1yr**(gam_un - 3) * (fqs / 86400.0)**(-gam_un) / Tspan) # parameterize intrinsic red-noise and DM-variations as power law kappa = [] for ii in range(npsr): kappa.append(np.log10( np.append( Ared[ii]**2/12/np.pi**2 * f1yr**(gam_red[ii]-3) * (fqs/86400.0)**(-gam_red[ii])/Tspan,\ Adm[ii]**2/12/np.pi**2 * f1yr**(gam_dm[ii]-3) * (fqs/86400.0)**(-gam_dm[ii])/Tspan ) )) # construct elements of sigma array sigdiag = [] sigoffdiag = [] sigcm = [] for ii in range(npsr): tot = np.zeros(4 * args.nmodes) offdiag = np.zeros(4 * args.nmodes) commonmode = np.zeros(4 * args.nmodes) # off diagonal terms offdiag[0::2] = np.append(10**rho, np.zeros(len(rho))) offdiag[1::2] = np.append(10**rho, np.zeros(len(rho))) # diagonal terms tot[0::2] = ORF[:, ii, ii] * np.append(10**rho, np.zeros( len(rho))) + np.append(10**cm + 10**un, np.zeros( len(rho))) + 10**kappa[ii] tot[1::2] = ORF[:, ii, ii] * np.append(10**rho, np.zeros( len(rho))) + np.append(10**cm + 10**un, np.zeros( len(rho))) + 10**kappa[ii] # common-mode terms commonmode[0::2] = np.append(10**cm, np.zeros(len(rho))) commonmode[1::2] = np.append(10**cm, np.zeros(len(rho))) # fill in lists of arrays sigdiag.append(tot) sigoffdiag.append(offdiag) sigcm.append(commonmode) # compute Phi inverse from Lindley's code smallMatrix = np.zeros((4 * args.nmodes, npsr, npsr)) for ii in range(npsr): for jj in range(ii, npsr): if ii == jj: smallMatrix[:, ii, jj] = sigdiag[jj] else: smallMatrix[:, ii, jj] = ORFtot[:, ii, jj] * sigoffdiag[jj] + sigcm[jj] smallMatrix[:, jj, ii] = smallMatrix[:, ii, jj] # invert them logdet_Phi = 0 non_pos_def = 0 for ii in range(4 * args.nmodes): try: L = sl.cho_factor(smallMatrix[ii, :, :]) smallMatrix[ii, :, :] = sl.cho_solve(L, np.eye(npsr)) logdet_Phi += np.sum(2 * np.log(np.diag(L[0]))) except np.linalg.LinAlgError: print 'Cholesky Decomposition Failed!! Rejecting...' non_pos_def += 1 if non_pos_def > 0: return -np.inf else: nftot = 4 * args.nmodes Phi = np.zeros((npsr * nftot, npsr * nftot)) # now fill in real covariance matrix ind = [np.arange(kk * nftot, kk * nftot + nftot) for kk in range(npsr)] for ii in range(npsr): for jj in range(npsr): Phi[ind[ii], ind[jj]] = smallMatrix[:, ii, jj] # compute sigma Sigma = sl.block_diag(*FtNF) + Phi # cholesky decomp for second term in exponential if args.use_gpu: try: Sigma_gpu = gpuarray.to_gpu(Sigma.astype(np.float64).copy()) expval2_gpu = gpuarray.to_gpu(d.astype(np.float64).copy()) culinalg.cho_solve( Sigma_gpu, expval2_gpu ) # in-place linear-algebra: Sigma and expval2 overwritten logdet_Sigma = np.sum(2.0 * np.log(np.diag(Sigma_gpu.get()))) except cula.culaDataError: print 'Cholesky Decomposition Failed (GPU error!!!!!!!!!!)' return -np.inf logLike = -0.5 * (logdet_Phi + logdet_Sigma) + 0.5 * (np.dot( d, expval2_gpu.get())) + loglike1 else: try: cf = sl.cho_factor(Sigma) expval2 = sl.cho_solve(cf, d) logdet_Sigma = np.sum(2 * np.log(np.diag(cf[0]))) except np.linalg.LinAlgError: print 'Cholesky Decomposition Failed second time!! Using SVD instead' u, s, v = sl.svd(Sigma) expval2 = np.dot(v.T, 1 / s * np.dot(u.T, d)) logdet_Sigma = np.sum(np.log(s)) logLike = -0.5 * (logdet_Phi + logdet_Sigma) + 0.5 * (np.dot( d, expval2)) + loglike1 if args.limit_or_detect == 'limit': prior_factor = np.log(Agwb * np.log(10.0)) else: prior_factor = 0.0 return logLike + prior_factor + physicality
def makeSkyMap(samples, lmax, nside=32, cmap=None, strain=None, tex=True, psrs=None, axis=None): if tex == True: plt.rcParams['text.usetex'] = True npix = hp.nside2npix(nside) # number of pixels total # initialize theta and phi map coordinantes skypos = [] for ii in range(npix): skypos.append(np.array(hp.pix2ang(nside, ii))) skypos = np.array(skypos) harmvals = utils.SetupSkymapPlottingGrid(lmax, skypos) if np.atleast_2d(samples).shape[0] > 1: if strain is None: samples = np.mean(samples, axis=0) samples = np.append(2. * np.sqrt(np.pi), samples) elif strain is not None: samples = np.mean((samples.T * 10**(2.0 * strain)).T, axis=0) samples = np.append( np.mean(10**(2.0 * strain) * (2.0 * np.sqrt(np.pi))), samples) else: #### !!!!! samples = np.append(2. * np.sqrt(np.pi), samples) pwr = utils.GWpower(samples, harmvals) print pwr, samples if axis is None: ax = plt.subplot(111, projection='astro mollweide') ax.grid() plot.outline_text(ax) if cmap is not None: if strain is None: plot.healpix_heatmap(pwr, cmap=cmap) elif strain is not None: plot.healpix_heatmap(pwr, cmap=cmap) else: plot.healpix_heatmap(pwr) plt.colorbar(orientation='horizontal') if strain is None: plt.suptitle(r'$\langle P_{\mathrm{GWB}}(\hat\Omega)\rangle$', y=0.1) elif strain is not None: plt.suptitle( r'$\langle A_h^2 P_{\mathrm{GWB}}(\hat\Omega)\rangle$', y=0.1) # add pulsars locations if psrs is not None: ax.plot(psrs[:, 0], np.pi / 2. - psrs[:, 1], '*', color='w', markersize=15, mew=1, mec='k') elif axis is not None: axis.grid() plot.outline_text(axis) if cmap is not None: plot.healpix_heatmap(pwr, cmap=cmap) else: plot.healpix_heatmap(pwr) # add pulsars locations if psrs is not None: axis.plot(psrs[:, 0], np.pi / 2. - psrs[:, 1], '*', color='w', markersize=6, mew=1, mec='w')
################################################################################################################################ psr = [NX01_psr.PsrObj(t2psr[ii]) for ii in range(len(t2psr))] [psr[ii].grab_all_vars() for ii in range(len(psr))] psr_positions = [ np.array([psr[ii].psr_locs[0], np.pi / 2. - psr[ii].psr_locs[1]]) for ii in range(len(psr)) ] positions = np.array(psr_positions).copy() CorrCoeff = np.array(anis.CorrBasis( positions, args.LMAX)) # computing all the correlation basis-functions for the array harm_sky_vals = utils.SetupPriorSkyGrid( args.LMAX) # computing the values of the spherical-harmonics up to order # LMAX on a pre-specified grid if args.anis_modefile is None: gwfreqs_per_win = int(1. * args.nmodes / (1. * args.num_gwfreq_wins) ) # getting the number of GW frequencies per window anis_modefreqs = np.arange(1, args.nmodes + 1) anis_modefreqs = np.reshape(anis_modefreqs, (args.num_gwfreq_wins, gwfreqs_per_win)) tmp_num_gwfreq_wins = args.num_gwfreq_wins else: tmp_modefreqs = np.loadtxt(args.anis_modefile) tmp_num_gwfreq_wins = tmp_modefreqs.shape[0] anis_modefreqs = [] for ii in range(tmp_num_gwfreq_wins):
Adm_ML.append(float(f.readline().split()[3])) gam_dm_ML.append(float(f.readline().split()[3])) Ared_ML.append(float(f.readline().split()[3])) gam_red_ML.append(float(f.readline().split()[3])) for jj in range(len(backends[ii])): EFAC_ML[ii][jj] = float(f.readline().split()[3]) for jj in range(len(backends[ii])): EQUAD_ML[ii][jj] = float(f.readline().split()[3]) ################################################################################################################################ # MAKE FIXED NOISE MATRICES FROM MAXIMUM-LIKELIHOOD VALUES OF SINGLE-PULSAR ANALYSIS ################################################################################################################################ GGCGG = [] for ii in range(len(psr)): tgrid = utils.makeTimeGrid(psr[ii], psr[ii]) Cred = utils.makeRedTDcov(Ared_ML[ii], gam_red_ML[ii], tgrid) Cdm = utils.makeDmTDcov(psr[ii], Adm_ML[ii], gam_dm_ML[ii], tgrid) Cwhite = np.diag(psr[ii].toaerrs**2.0) ######## GCGnoise = np.dot(psr[ii].G.T, np.dot(Cred + Cdm + Cwhite, psr[ii].G)) GCGnoise = np.nan_to_num(GCGnoise) cho = sl.cho_factor(GCGnoise) GGCGG.append( np.dot(psr[ii].G, np.dot(sl.cho_solve(cho, np.eye(len(GCGnoise))), psr[ii].G.T))) ################################################################################################################################ # DEFINING THE PRIOR AND THE LOG-LIKELIHOOD ################################################################################################################################
def TF_OSupperLimit(psr, fqs, Tspan, F, GCGnoiseInv, ORF, OSsmbhb, ul_list=None, far=None, drlist=None, tex=True, nlims=70): if tex == True: plt.rcParams['text.usetex'] = True gam_bkgrd = np.linspace(0.01, 6.99, nlims) optStatList = [] ct = 0 for indx in gam_bkgrd: optStatList.append( utils.TFoptStat(psr, fqs, Tspan, F, GCGnoiseInv, ORF, gam_gwb=indx)[:3]) ct += 1 print "Finished {0}% of optimal-statistic upper-limit calculations...".format( 100.0 * ct / (1.0 * nlims)) optStatList = np.array(optStatList) fig, ax = plt.subplots() stylelist = ['solid', 'dashed', 'dotted'] if ul_list is not None: for ii in range(len(ul_list)): ax.plot( gam_bkgrd, np.sqrt(optStatList[:, 0] + optStatList[:, 1] * np.sqrt(2.0) * (ss.erfcinv(2.0 * (1. - ul_list[ii])))), linestyle=stylelist[ii], color='black', linewidth=3.0, label='{0}$\%$ upper-limit'.format(ul_list[ii] * 100)) plt.hlines(y=np.sqrt(OSsmbhb[0] + OSsmbhb[1] * np.sqrt(2.0) * (ss.erfcinv(2.0 * (1. - ul_list[ii])))), xmin=gam_bkgrd.min(), xmax=13. / 3., linewidth=3.0, linestyle='solid', color='red') plt.vlines(x=13. / 3., ymin=0.0, ymax=np.sqrt(OSsmbhb[0] + OSsmbhb[1] * np.sqrt(2.0) * (ss.erfcinv(2.0 * (1. - ul_list[ii])))), linewidth=3.0, linestyle='solid', color='red') else: for ii in range(len(drlist)): ax.plot( gam_bkgrd, np.sqrt( optStatList[:, 1] * np.sqrt(2.0) * (ss.erfcinv(2.0 * far) - ss.erfcinv(2.0 * drlist[ii]))), linestyle=stylelist[ii], color='black', linewidth=3.0, label='$A$ ({0}$\%$ FAR, {1}$\%$ DR)'.format( far * 100, drlist[ii] * 100)) plt.hlines(y=np.sqrt( OSsmbhb * np.sqrt(2.0) * (ss.erfcinv(2.0 * far) - ss.erfcinv(2.0 * drlist[ii]))), xmin=gam_bkgrd.min(), xmax=13. / 3., linewidth=3.0, linestyle='solid', color='red') plt.vlines( x=13. / 3., ymin=0.0, ymax=np.sqrt( OSsmbhb * np.sqrt(2.0) * (ss.erfcinv(2.0 * far) - ss.erfcinv(2.0 * drlist[ii]))), linewidth=3.0, linestyle='solid', color='red') ax.set_yscale('log') ax.set_xlabel(r'$\gamma\equiv 3-2\alpha$', fontsize=20) ax.set_ylabel(r'$A$', fontsize=20) ax.minorticks_on() plt.tick_params(labelsize=18) plt.grid(which='major') plt.grid(which='minor') plt.title('Optimal-statistic bounds') plt.legend(loc='lower left', shadow=True, frameon=True, prop={'size': 15}) plt.show()
EQUAD_ML[ii][jj] = float(f.readline().split()[3]) ################################################################################################################################ # MAKE FIXED NOISE MATRICES FROM MAXIMUM-LIKELIHOOD VALUES OF SINGLE-PULSAR ANALYSIS ################################################################################################################################ GCGnoiseInv = [] for ii in range(len(psr)): #################################################################### # For each pulsar, obtain the ML A_h value with scalar maximisation #################################################################### #func = lambda x: -utils.singlePsrLL(psr[ii], x, gam_gwb=13./3.) #fbounded = sciopt.minimize_scalar(func, bounds=(0.0, utils.sigma_gwRMS(psr[ii]), 1.0e-13), method='Golden') #Agwb_ML = fbounded.x tgrid = utils.makeTimeGrid(psr[ii], psr[ii]) #Cgwb_ML = utils.makeRedTDcov(Agwb_ML, 13./3., tgrid) Cred = utils.makeRedTDcov(Ared_ML[ii], gam_red_ML[ii], tgrid) Cdm = utils.makeDmTDcov(psr[ii], Adm_ML[ii], gam_dm_ML[ii], tgrid) Cwhite = np.diag(psr[ii].toaerrs**2.0) ######## #GCGnoise = np.dot(psr[ii].G.T, np.dot(Cgwb_ML+Cred+Cdm+Cwhite, psr[ii].G)) GCGnoise = np.dot(psr[ii].G.T, np.dot(Cred + Cdm + Cwhite, psr[ii].G)) GCGnoise = np.nan_to_num(GCGnoise) cho = sl.cho_factor(GCGnoise) GCGnoiseInv.append(sl.cho_solve(cho, np.eye(len(GCGnoise)))) gam_bkgrd = 4.33333 optimalStat = utils.optStat(psr, GCGnoiseInv, HnD, gam_gwb=gam_bkgrd) print "\n A^2 = {0}, std = {1}, SNR = {2}\n".format(optimalStat[0],