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"
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)
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 makeFdm(self, nmodes, Ttot):
self.Fdm = utils.createFourierDesignmatrix_dm(self.toas, nmodes, self.obs_freqs, 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')
def makeFeph(self, nmodes, Ttot):
self.Fephx, self.Fephy, self.Fephz = \
utils.createFourierDesignmatrix_eph(self.toas, nmodes, self.psr_locs, Tspan=Ttot)
################################################################################################################################
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):
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)
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 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 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],
