def solve(self, wt_n, y_nd, bend_coef, f_res):
if y_nd.shape[0] != self.n or y_nd.shape[1] != self.d:
raise RuntimeError(
"The dimensions of y_nd doesn't match the dimensions of x_nd")
if not y_nd.flags.c_contiguous:
raise RuntimeError("Expected y_nd to be c-contiguous but it isn't")
self.sqrtWQN_gpu.set_async(np.sqrt(wt_n)[:, None] * self.QN)
geam(self.NKN_gpu, self.NRN_gpu, self.lhs_gpu, alpha=bend_coef, beta=1)
gemm(self.sqrtWQN_gpu,
self.sqrtWQN_gpu,
self.lhs_gpu,
transa='T',
alpha=1,
beta=1)
drv.memcpy_dtod_async(self.rhs_gpu.gpudata, self.NR_gpu.gpudata,
self.rhs_gpu.nbytes)
self.y_dnW_gpu.set_async(
y_nd.T * wt_n) # use transpose so that it is f_contiguous
gemm(self.QN_gpu,
self.y_dnW_gpu,
self.rhs_gpu,
transa='T',
transb='T',
alpha=1,
beta=1)
if lfd.registration._has_cula:
culinalg.cho_solve(self.lhs_gpu, self.rhs_gpu)
z = self.rhs_gpu.get()
culinalg.dot(self.N_gpu, self.rhs_gpu, out=self.theta_gpu)
theta = self.theta_gpu.get()
else: # if cula is not install perform the last two computations in the CPU
z = np.linalg.solve(self.lhs_gpu.get(), self.rhs_gpu.get())
theta = self.N.dot(z)
f_res.update(self.x_nd,
y_nd,
bend_coef,
self.rot_coef,
wt_n,
theta,
N=self.N,
z=z)
def test_cho_solve_float32(self):
x = np.asarray(np.random.rand(4, 4), np.float32)
x = np.dot(x.T, x)
y = np.asarray(np.random.rand(4), np.float32)
c = np.linalg.inv(x).dot(y)
x_gpu = gpuarray.to_gpu(x)
y_gpu = gpuarray.to_gpu(y)
linalg.cho_solve(x_gpu, y_gpu)
assert np.allclose(c, y_gpu.get(), atol=1e-4)
x = np.asarray(np.random.rand(4, 4), np.float32)
x = np.dot(x.T, x).astype(np.float32, order="F", copy=True)
y = np.asarray(np.random.rand(4, 4), np.float32, order="F")
c = np.linalg.inv(x).dot(y)
x_gpu = gpuarray.to_gpu(x)
y_gpu = gpuarray.to_gpu(y)
linalg.cho_solve(x_gpu, y_gpu)
assert np.allclose(c, y_gpu.get(), atol=1e-4)
def test_cho_solve_float32(self):
x = np.asarray(np.random.rand(4, 4), np.float32)
x = np.dot(x.T, x)
y = np.asarray(np.random.rand(4), np.float32)
c = np.linalg.inv(x).dot(y)
x_gpu = gpuarray.to_gpu(x)
y_gpu = gpuarray.to_gpu(y)
linalg.cho_solve(x_gpu, y_gpu)
assert np.allclose(c, y_gpu.get(), atol=1e-5)
x = np.asarray(np.random.rand(4, 4), np.float32)
x = np.dot(x.T, x).astype(np.float32, order="F", copy=True)
y = np.asarray(np.random.rand(4, 4), np.float32, order="F")
c = np.linalg.inv(x).dot(y)
x_gpu = gpuarray.to_gpu(x)
y_gpu = gpuarray.to_gpu(y)
linalg.cho_solve(x_gpu, y_gpu)
assert np.allclose(c, y_gpu.get(), atol=1e-5)
def solve(self, wt_n, y_nd, bend_coef, f_res):
if y_nd.shape[0] != self.n or y_nd.shape[1] != self.d:
raise RuntimeError("The dimensions of y_nd doesn't match the dimensions of x_nd")
if not y_nd.flags.c_contiguous:
raise RuntimeError("Expected y_nd to be c-contiguous but it isn't")
self.sqrtWQN_gpu.set_async(np.sqrt(wt_n)[:,None] * self.QN)
geam(self.NKN_gpu, self.NRN_gpu, self.lhs_gpu, alpha=bend_coef, beta=1)
gemm(self.sqrtWQN_gpu, self.sqrtWQN_gpu, self.lhs_gpu, transa='T', alpha=1, beta=1)
drv.memcpy_dtod_async(self.rhs_gpu.gpudata, self.NR_gpu.gpudata, self.rhs_gpu.nbytes)
self.y_dnW_gpu.set_async(y_nd.T * wt_n) # use transpose so that it is f_contiguous
gemm(self.QN_gpu, self.y_dnW_gpu, self.rhs_gpu, transa='T', transb='T', alpha=1, beta=1)
if lfd.registration._has_cula:
culinalg.cho_solve(self.lhs_gpu, self.rhs_gpu)
culinalg.dot(self.N_gpu, self.rhs_gpu, out=self.theta_gpu)
theta = self.theta_gpu.get()
else: # if cula is not install perform the last two computations in the CPU
z = np.linalg.solve(self.lhs_gpu.get(), self.rhs_gpu.get())
theta = self.N.dot(z)
f_res.set_ThinPlateSpline(self.x_nd, y_nd, bend_coef, self.rot_coef, wt_n, theta=theta)
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 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((args.num_gwfreq_wins,((args.LMAX+1)**2)-1))
clm = np.array([[0.0]*((args.LMAX+1)**2) for ii in range(args.num_gwfreq_wins)])
clm[:,0] = 2.0*np.sqrt(np.pi)
physicality = 0.
if args.LMAX!=0:
for kk in range(args.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(args.num_gwfreq_wins): # number of frequency windows
for jj in range(gwfreqs_per_win): # number of frequencies in this window
ORF.append( sum(clm[ii,kk]*CorrCoeff[kk] for kk in range(len(CorrCoeff))) )
for ii in range(args.num_gwfreq_wins): # number of frequency windows
for jj in range(gwfreqs_per_win): # 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 = []
d = []
for p in range(len(psr)):
d.append( 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)
# 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]
# fill in lists of arrays
sigdiag.append(tot)
# invert them
logdet_Phi = 0
Sigma=[]
for ii in range(npsr):
logdet_Phi += np.sum(np.log(sigdiag[ii]))
Sigma.append( FtNF[ii] + np.diag(1./sigdiag[ii]) )
# cholesky decomp for second term in exponential
if args.use_gpu:
logdet_Sigma = 0.
dSigd = 0.
for ii in range(npsr):
try:
Sigma_gpu = gpuarray.to_gpu( Sigma[ii].astype(np.float64).copy() )
expval2_gpu = gpuarray.to_gpu( d[ii].astype(np.float64).copy() )
culinalg.cho_solve( Sigma_gpu, expval2_gpu ) # in-place linear-algebra: Sigma and expval2 overwritten
dSigd += np.dot(d[ii], expval2_gpu.get())
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 * dSigd + loglike1
else:
logdet_Sigma = 0.
dSigd = 0.
for ii in range(npsr):
try:
cf = sl.cho_factor(Sigma[ii])
expval2 = sl.cho_solve(cf, d[ii])
dSigd += np.dot(d[ii], expval2)
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[ii])
expval2 = np.dot(v.T, 1/s*np.dot(u.T, d[ii]))
dSigd += np.dot(d[ii], expval2)
logdet_Sigma += np.sum(np.log(s))
logLike = -0.5 * (logdet_Phi + logdet_Sigma) + 0.5 * dSigd + 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 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
#####
###################
orf_coeffs = x[ct:]
orf_coeffs = orf_coeffs.reshape((args.num_gwfreq_wins,((args.LMAX+1)**2)-1))
clm = np.array([[0.0]*((args.LMAX+1)**2) for ii in range(args.num_gwfreq_wins)])
clm[:,0] = 2.0*np.sqrt(np.pi)
physicality = 0.
if args.LMAX!=0:
for kk in range(args.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(args.num_gwfreq_wins): # number of frequency windows
for jj in range(gwfreqs_per_win): # number of frequencies in this window
ORF.append( sum(clm[ii,kk]*CorrCoeff[kk] for kk in range(len(CorrCoeff))) )
for ii in range(args.num_gwfreq_wins): # number of frequency windows
for jj in range(gwfreqs_per_win): # 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
# 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)
# parameterize intrinsic red-noise and DM-variations as power law
kappa = []
for ii in range(npsr):
kappa.append(np.log10( np.append( Ared_ML[ii]**2/12/np.pi**2 * f1yr**(gam_red_ML[ii]-3) * (fqs/86400.0)**(-gam_red_ML[ii])/Tspan,\
Adm_ML[ii]**2/12/np.pi**2 * f1yr**(gam_dm_ML[ii]-3) * (fqs/86400.0)**(-gam_dm_ML[ii])/Tspan ) ))
# construct elements of sigma array
sigdiag = []
sigoffdiag = []
for ii in range(npsr):
tot = np.zeros(4*args.nmodes)
offdiag = 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)) ) + 10**kappa[ii]
tot[1::2] = ORF[:,ii,ii]*np.append( 10**rho, np.zeros(len(rho)) ) + 10**kappa[ii]
# fill in lists of arrays
sigdiag.append(tot)
sigoffdiag.append(offdiag)
# 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]
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 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)]
###################
npsr = len(psr)
# 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)
# parameterize intrinsic red-noise and DM-variations as power law
kappa = []
for ii in range(npsr):
kappa.append(np.log10( Ared[ii]**2/12/np.pi**2 * f1yr**(gam_red[ii]-3) * (fqs/86400.0)**(-gam_red[ii])/Tspan ))
# construct elements of sigma array
sigdiag = []
sigoffdiag = []
for ii in range(npsr):
tot = np.zeros(2*args.nmodes)
offdiag = np.zeros(2*args.nmodes)
# off diagonal terms
offdiag[0::2] = 10**rho
offdiag[1::2] = 10**rho
# diagonal terms
tot[0::2] = ORF[ii,ii]*10**rho + 10**kappa[ii]
tot[1::2] = ORF[ii,ii]*10**rho + 10**kappa[ii]
# fill in lists of arrays
sigdiag.append(tot)
sigoffdiag.append(offdiag)
# compute Phi inverse from Lindley's code
smallMatrix = np.zeros((2*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]
smallMatrix[:,jj,ii] = smallMatrix[ii,jj]
# invert them
logdet_Phi = 0
non_pos_def = 0
for ii in range(2*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 = 2*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_gwb == 'limit':
prior_factor = np.log(Agwb * np.log(10.0))
else:
prior_factor = 0.0
if args.limit_or_detect_red == 'limit':
prior_factor += sum( np.log(Ared[ii] * np.log(10.0)) for ii in range(npsr) )
else:
prior_factor += 0.0
return logLike + prior_factor
