def run_MCMC_ex(which_par,niter,save_title, renorm_var,firstiter=0,seed="none",guess="random"):
"""
Functions that runs the MCMC for a given set of parameters
Keyword Arguments:
which_par -- a list of indices, corresponding to the order defined above, exemple [0,2] means ombh2,tau if order is [ombh2,omch2,tau,As,ns,H0]
niter -- number of iterations in MCMC
renorm_var -- factor multipling the variance, to play around for better acceptance rate.
"""
cov_new_temp = cov_new[which_par,:][:,which_par] * renorm_var
string_temp = strings[which_par]
titles_temp = titles[which_par]
x_mean_temp = x_mean[which_par]
priors_central_temp = priors_central[which_par]
priors_invvar_temp = priors_invvar[which_par]
print titles_temp
sys.stdout.flush()
dd2 = cb.update_dic(dd,x_mean_temp,string_temp)
cl = cb.generate_spectrum(dd2)[:lmax+1,1]
cl[:2] = 1.e-35
if guess=="random":
guess_param = PS2P.prop_dist_form_params(x_mean_temp,cov_new_temp)
else :
guess_param = guess
tt1 = time.time()
save_string = "outputs/chain_ex_%s_%s_%d_%d"%(save_title,str(which_par).replace(',','').replace('[','').replace(']','').replace(' ',''),np.random.randint(0,100000),niter)
print save_string
sys.stdout.flush()
testss = np.array(MH.MCMC_log(guess_param, JJi.functional_form_params_n,PS2P.prop_dist_form_params, PS2P.prop_func_form_params,niter,PS2P.Gaussian_priors_func,firstiter,seed,save_string,[dlm,string_temp,dd,nl,bl,cl],[x_mean_temp*0,np.matrix(cov_new_temp)],[priors_central_temp,priors_invvar_temp]))
print time.time() - tt1
np.save(save_string+".npy",testss)
return testss
def run_MCMC(which_par,niter,save_title, renorm_var):
"""
Functions that runs the MCMC for a given set of parameters
Keyword Arguments:
which_par -- a list of indices, corresponding to the order defined above, exemple [0,2] means ombh2,tau if order is [ombh2,omch2,tau,As,ns,H0]
niter -- number of iterations in MCMC
renorm_var -- factor multipling the variance, to play around for better acceptance rate.
"""
cov_new_temp = cov_new[which_par,:][:,which_par] * renorm_var
string_temp = strings[which_par]
titles_temp = titles[which_par]
x_mean_temp = x_mean[which_par]
priors_central_temp = priors_central[which_par]
priors_invvar_temp = priors_invvar[which_par]
print titles_temp
# generate first guess parameters
guess_param = PS2P.prop_dist_form_params(x_mean_temp,cov_new_temp)
# generate first fluctuation map
dd2 = cb.update_dic(dd,guess_param,string_temp)
cl = cb.generate_spectrum(dd2)[:,1]
cl[:2] = 1.e-35
renorm = CG.renorm_term(cl,bl,nl)
fluc = hp.almxfl(CG.generate_w1term(cl[:lmax+1],bl[:lmax+1],nl[:lmax+1]) + CG.generate_w0term(cl[:lmax+1]),renorm)
# the core of the MCMC
testss = np.array(MH.MCMC_log_Jeff_test(guess_param, JJi.target_distrib_newrescale,PS2P.prop_dist_form_params, PS2P.prop_func_form_params,niter,PS2P.Gaussian_priors_func,[[dlm,string_temp,dd,nl[:lmax+1],bl[:lmax+1]],[cl[:lmax+1],fluc]],[x_mean_temp*0,np.matrix(cov_new_temp)],[priors_central_temp,priors_invvar_temp]))
np.save("chain_%s_%s_%d_%d.npy"%(save_title,str(which_par).replace(',','').replace('[','').replace(']','').replace(' ',''),np.random.randint(0,100000),niter),testss)
return testss
def Step_MC(guess, *arg):
"""
Keyword Arguments:
x -- the vector of params
*args are:
arg[0] -- a target class object
arg[1] -- Cl_old, fluc_lm_old
"""
##print guess, arg
dlm,strings,params,nl,bl = arg[0]
Cl_old, fluc_lm_GS,mf_old = arg[1]
dd = cb.update_dic(params,guess,strings)
#generate new spectrum from new params
lmax = len(Cl_old)
Cl_new = cb.generate_spectrum(dd)[:lmax,1]
# avoid dividing by 0
Cl_new[:2] = 1.e-35
#print "new = ",Cl_new[50]
#print "old = ",Cl_old[50]
# renormalization, i.e. lhs part of eq (24) and (25)
renorm = CG.renorm_term(Cl_new,bl,nl)
# generate mean field map using new PS
mf_lm_new = hp.almxfl(CG.generate_mfterm(dlm,Cl_new,bl,nl),renorm)
# get deterministic fluctuation map (new rescaling with noise)
fluc_lm_determ = hp.almxfl(fluc_lm_GS,np.sqrt((1./Cl_old))/np.sqrt((1./Cl_new)))
# get GS fluctuation map "for next iteration"
fluc_lm_GS_next = hp.almxfl(CG.generate_w1term(Cl_new,bl,nl)+CG.generate_w0term(Cl_new),renorm)
# Chi2 part of the likelihood
return fluc_lm_determ,mf_lm_new, fluc_lm_GS_next, Cl_new
def target_distrib(guess, *arg):
"""
Keyword Arguments:
x -- the vector of params
*args are:
arg[0] -- a target class object
arg[1] -- Cl_old, fluc_lm_old
"""
#print guess, arg
dlm,strings,params,nl,bl = arg[0]
Cl_old, fluc_lm_old = arg[1]
dd = cb.update_dic(params,guess,strings)
Cl_new = cb.generate_spectrum(dd)[:,1]
Cl_new[:2] = 1.e-35
#print "new = ",Cl_new[50]
#print "old = ",Cl_old[50]
renorm = CG.renorm_term(Cl_new,bl,nl)
mf_lm_new = hp.almxfl(CG.generate_mfterm(dlm,Cl_new,bl,nl),renorm)
fluc_lm_type2 = hp.almxfl(CG.generate_w1term(Cl_new,bl,nl)+CG.generate_w0term(Cl_new),renorm)
#print "new = ",fluc_lm_type2[50]
#print "old = ",fluc_lm_old[50]
fluc_lm_determ = hp.almxfl(fluc_lm_old,np.sqrt(Cl_new/Cl_old))
tt1 = -1/2.*np.real(np.vdot((dlm-hp.almxfl(mf_lm_new,bl)).T,hp.almxfl((dlm-hp.almxfl(mf_lm_new,bl)),1/nl)))
#print tt1
tt2 = -1/2. *np.real(np.vdot((mf_lm_new).T,hp.almxfl((mf_lm_new),1./Cl_new)))
#print tt2
tt3 = -1/2. *np.real(np.vdot((fluc_lm_determ).T,hp.almxfl((fluc_lm_determ),1/nl*bl**2)))
#print tt3
#tt4 = - 1./2 *(np.arange(1,np.size(Cl_new)+1)*np.log(Cl_new)).sum()
##print tt4
return [tt1,tt2,tt3],Cl_new,fluc_lm_type2
def test_fluctuation_term(guess, *arg):
"""
Keyword Arguments:
x -- the vector of params
*args are:
arg[0] -- a target class object
arg[1] -- Cl_old, fluc_lm_old
"""
##print guess, arg
dlm,strings,params,nl,bl = arg[0]
Cl_old, fluc_lm_old = arg[1]
dd = cb.update_dic(params,guess,strings)
#generate new spectrum from new params
lmax = len(Cl_old)
Cl_new = cb.generate_spectrum(dd)[:lmax,1]
# avoid dividing by 0
Cl_new[:2] = 1.e-35
#print "new = ",Cl_new[50]
#print "old = ",Cl_old[50]
# renormalization, i.e. lhs part of eq (24) and (25)
renorm = CG.renorm_term(Cl_new,bl,nl)
# generate fluctuation map using new PS, this is actually the 'step 2', with acceptance 1, won't be used anymore in this function
fluc_lm_type2 = hp.almxfl(CG.generate_w1term(Cl_new,bl,nl)+CG.generate_w0term(Cl_new),renorm)
#print "new = ",fluc_lm_type2[50]
#print "old = ",fluc_lm_old[50]
# get deterministic fluctuation map (new rescaling with noise)
fluc_lm_determ = hp.almxfl(fluc_lm_old,np.sqrt((1./Cl_old+bl**2/nl))/np.sqrt((1./Cl_new+bl**2/nl)))
# "fluctuation part" of the likelihood
tt3 = -1/2. *np.real(np.vdot((fluc_lm_determ).T,hp.almxfl((fluc_lm_determ),1/nl*bl**2)))
#print tt3
# we return Cl_new and fluc_lm_type2 for next iteration.
return tt3,Cl_new,fluc_lm_type2,fluc_lm_determ
def functional_form_params_n(x,*arg):
"""
Keyword Arguments:
x -- the vector of params
*args are:
dlm -- input map
x_str -- the dictionary strings corresponding to x
params -- a camber dictionnary
noise -- a noise power spectrum
beam -- a beam power spectrum
"""
dlm = arg[0]
strings = arg[1]
params = arg[2].copy()
noise = arg[3]
beam = arg[4]
Cl_old = arg[5]
lmax = len(Cl_old)-1
#params["output_root"] = '../Codes/CG_git/MH_MCMC/camb_ini/test%d'%np.random.randint(100)
for i in range(np.size(x)):
##print strings[i]
if strings[i]=='scalar_amp(1)':
##print params[strings[i]]
params[strings[i]]=np.exp(x[i])*1e-10
##print params[strings[i]]
else:
params[strings[i]]=x[i]
Cl = cb.generate_spectrum(params)
#lmax = Cl.shape[0]-1
tt = -1./2 * np.real(np.vdot(CG.complex2real_alm(dlm.T),CG.complex2real_alm(hp.almxfl(dlm,1/(beam[:lmax+1]**2*Cl[:lmax+1,1]+noise[:lmax+1])))))
#determinant is the product of the diagonal element: in log:
tt2 = - 1./2 *((2*np.arange(2,lmax+1)+1)*np.log(noise[2:lmax+1]+Cl[2:lmax+1,1]*beam[2:lmax+1]**2)).sum()
return tt+tt2,Cl[:,1]
def solve_CG(params_i,dd):
dd = cb.update_dic(dd,params_i,strings)
cl = cb.generate_spectrum(dd)[:,1]
# define the first guess, the b from eq 25 since the code was design with this at first (might not be best idea ever)
b_mf = CG.generate_mfterm(dlm_filt,cl[:lmax+1],bl[:lmax+1],nl[:lmax+1])
b_w1 = CG.generate_w1term(cl[:lmax+1],bl[:lmax+1],nl[:lmax+1])
b_w0 = CG.generate_w0term(cl[:lmax+1])
b = b_mf + b_w1 + b_w0
###### left hand side factor
renorm= np.sqrt(cl[:lmax+1])/(1+cl[:lmax+1]*bl[:lmax+1]**2/(nl[:lmax+1]))
out = hp.almxfl(b,renorm)
out_mf = hp.almxfl(b_mf,renorm)
out_w1 = hp.almxfl(b_w1,renorm)
out_w0 = hp.almxfl(b_w0,renorm)
return out,out_mf,out_w0,out_w1
def test_3rd_Term(list_guess):
#initial guess
guess_param = PS2P.prop_dist_form_params(x_mean,cov_new)
# generate first fluctuation map
dd2 = cb.update_dic(dd,guess_param,strings)
cl = cb.generate_spectrum(dd2)[:,1]
cl[:2] = 1.e-35
renorm = CG.renorm_term(cl,bl,nl)
fluc = hp.almxfl(CG.generate_w1term(cl[:lmax+1],bl[:lmax+1],nl[:lmax+1]) + CG.generate_w0term(cl[:lmax+1]),renorm)
Cl_i,fluc_i = [cl,fluc]
list_save=[]
for i in range(len(list_guess)):
print i
test_param = list_guess[i]
Like_3,Cl_ip1,fluc_ip1,fluc_i_rescaled = test_fluctuation_term(test_param,[dlm,strings,dd2,nl[:lmax+1],bl[:lmax+1]],[Cl_i, fluc_i])
Cl_i,fluc_i = [Cl_ip1,fluc_ip1]
list_save.append([Like_3,Cl_ip1,fluc_ip1,fluc_i_rescaled])
return list_save
########### Here we simulate the data set ############
# White noise spectrum, (Commander level, so low)
#nl = 1.7504523623688016e-16*1e12 * np.ones(2500)
#nl = 1.7504523623688016e-16*1e12 * np.ones(2500) *2
# Gaussian beam fwhm 5 arcmin
#bl = CG.gaussian_beam(2500,5)
#bl = CG.gaussian_beam(2500,5*np.sqrt(hp.nside2pixarea(nside,degrees=True))*60)
bl = CG.gaussian_beam(2500,13)
# Spectrum according to parameter defined above
if generate_new_data==1:
Cl = cb.generate_spectrum(dd)
# White noise level defined so that SNR=1 at \ell of 1700
nl = Cl[900,1]*bl[900]**2*np.ones(2500)
lmax_temp = Cl.shape[0]-1
alm = hp.synalm(Cl[:,1])
dlm = hp.almxfl(alm,bl[:lmax_temp+1])
nlm = hp.synalm(nl[:lmax_temp+1])
dlm = dlm+nlm
#np.save("Dataset_planck2015_900SNR1_13arcmin.npy",dlm)
plt.figure()
ell = np.arange(lmax)*np.arange(1,lmax+1)
plt.plot(ell*(Cl[:lmax,1]*bl[:lmax]**2),label = "$C_\ell b_\ell^2$")
plt.plot(ell*(nl[:lmax]),label="$n_\ell$")
plt.plot(ell*(Cl[:lmax,1]*bl[:lmax]**2+nl[:lmax]),"--",label = "$C_\ell b_\ell^2 + n_\ell$")
plt.ylabel("$\ell (\ell +1) C_\ell$")
plt.xlabel("$\ell$")
def get_spec(self,x):
parameters = cb.update_dic(self.params,x,self.strings)
return cb.generate_spectrum(parameters)
