def Hubble_teorico_2(params_fisicos, b_crit=0.15, all_analytic=False,
eval_data=False, z_data=None, epsilon=10**(-10), n=1,
cantidad_zs=int(10**5), max_step=10**(-4),
z_min=0, z_max=10, sistema_ec=dX_dz,
verbose=False, model='HS', method='RK45'):
[omega_m,b,H0] = params_fisicos
if model=='LCDM':
zs_modelo = np.linspace(z_min,z_max,cantidad_zs)
Hs_modelo = H_LCDM(zs_modelo, omega_m, H0)
return zs_modelo, Hs_modelo
elif model=='EXP': #b critico para el modelo exponencial
method='LSODA'
log_eps_inv = -np.log10(epsilon)
b_crit = (4 + omega_m/(1-omega_m)) / log_eps_inv
else:
pass
if (b <= b_crit) or (all_analytic==True): #Aproximacion analitica
if eval_data == False:
zs_modelo = np.linspace(z_min,z_max,cantidad_zs)
else:
zs_modelo = z_data
if model=='HS':
Hs_modelo = Taylor_HS(zs_modelo, omega_m, b, H0)
elif model=='ST':
Hs_modelo = Taylor_ST(zs_modelo, omega_m, b, H0)
elif model=='EXP': #Devuelvo LCDM
Hs_modelo = H_LCDM(zs_modelo, omega_m, H0)
else: #Integro
if eval_data == False:
zs_modelo, Hs_modelo = integrador(params_fisicos,
cantidad_zs=cantidad_zs, max_step=max_step,
z_inicial=z_max, z_final=z_min, sistema_ec=sistema_ec,
verbose=verbose, model=model)
else:
zs_modelo, Hs_modelo = integrador(params_fisicos,
cantidad_zs=cantidad_zs, max_step=max_step,
z_inicial=z_max, z_final=z_min, sistema_ec=sistema_ec,
verbose=verbose, eval_data=True, z_data = z_data,
model=model)
return zs_modelo, Hs_modelo
def params_to_chi2_BAO_old_data(theta,
params_fijos,
dataset,
cantidad_zs=int(10**6),
num_datasets=5):
'''Dados los parámetros libres del modelo (omega, b y H0) y
los que quedan params_fijos (n), devuelve un chi2 para los datos
de BAO'''
[omega_m, H_0] = theta
zs_modelo = np.linspace(0.01, 3, cantidad_zs)
H_modelo = H_LCDM(zs_modelo, omega_m, H_0)
rd = r_drag_camb(omega_m, H_0) #Calculo del rd
chies = np.zeros(num_datasets)
for i in range(num_datasets):
(z_data, valores_data, errores_data, rd_fid) = dataset[i]
if i == 0: #Dato de Da
valores_data_2 = valores_data * (rd / rd_fid)
errores_data_2 = errores_data * (rd / rd_fid)
pass
elif i == 4: #Datos de H
valores_data_2 = np.zeros(len(valores_data))
errores_data_2 = np.zeros(len(errores_data))
for j in range(len(z_data)):
valores_data_2[j] = valores_data[j] * (rd / rd_fid[j])
errores_data_2[j] = errores_data[j] * (rd / rd_fid[j])
else:
valores_data_2 = np.zeros(len(valores_data))
errores_data_2 = np.zeros(len(errores_data))
for j in range(len(z_data)):
if rd_fid[j] != 1:
valores_data_2[j] = valores_data[j] * (rd_fid[j] / rd)
errores_data_2[j] = errores_data[j] * (rd_fid[j] / rd)
else: #No hay que multiplicar x ningun factor
valores_data_2[j] = valores_data[j]
errores_data_2[j] = errores_data[j]
outs = Hs_to_Ds_old_data(zs_modelo, H_modelo, z_data, i)
chies[i] = chi_2_BAO(outs, valores_data_2, errores_data_2)
if np.isnan(sum(chies)) == True:
print('Hay errores!')
print(omega_m, H_0, rd)
return np.sum(chies)
def params_to_chi2_AGN_nuisance(theta,
params_fijos,
dataset_AGN,
n=1,
cantidad_zs=int(10**6),
model='HS',
less_z=False,
all_analytic=False):
'''
Dados los parámetros del modelo devuelvo el estadítico chi2 para
los datos de AGN.
'''
#Defino los parámetros que voy a utilizar
if model == 'LCDM':
if isinstance(theta, float):
#print(theta)
omega_m = theta
[beta, gamma, delta, H_0] = params_fijos
zs_modelo = np.linspace(0, 10, 10**5)
Hs_modelo = H_LCDM(zs_modelo, omega_m, H_0)
else:
if len(theta) == 4:
[omega_m, beta, gamma,
delta] = theta #Este beta es distinto al otro!
H_0 = params_fijos
zs_modelo = np.linspace(0, 10, 10**5)
Hs_modelo = H_LCDM(zs_modelo, omega_m, H_0)
else:
if len(theta) == 5:
[omega_m, b, beta, gamma,
delta] = theta #Este beta es distinto al otro!
H_0 = params_fijos
elif len(theta) == 4:
[omega_m, b] = theta #Este beta es distinto al otro!
[beta, gamma, delta, H_0] = params_fijos
params_fisicos = [omega_m, b, H_0]
zs_modelo, Hs_modelo = Hubble_teorico_1(params_fisicos,
n=n,
model=model,
z_min=0,
z_max=10,
cantidad_zs=cantidad_zs,
all_analytic=all_analytic)
#Importo los datos
z_data_unmasked, logFuv_unmasked, eFuv_unmasked, logFx_unmasked, eFx_unmasked = dataset_AGN
if less_z == True:
mask = z_data_unmasked < 1.5
z_data = z_data_unmasked[mask]
logFuv = logFuv_unmasked[mask]
eFuv = eFuv_unmasked[mask]
logFx = logFx_unmasked[mask]
eFx = eFx_unmasked[mask]
else:
z_data = z_data_unmasked
logFuv = logFuv_unmasked
eFuv = eFuv_unmasked
logFx = logFx_unmasked
eFx = eFx_unmasked
Dl_teo = Hs_2_logDl(zs_modelo, Hs_modelo, z_data) #Mpc
Dl_teo_cm = Dl_teo - np.log10(3.24) + 25
psi = beta + gamma * logFuv + 2 * (gamma - 1) * (Dl_teo_cm +
0.5 * np.log10(4 * np.pi))
si_2 = eFx**2 + gamma**2 * eFuv**2 + np.exp(
2 * np.log(delta)) #El cuadrado de los errores
chi2_AGN = chi2_AGN_nuisance(psi, logFx, si_2)
return chi2_AGN
z, valores_data, errores_data, rd_fid = np.loadtxt(archivo_BAO,
usecols=(0, 1, 2,
4),
unpack=True)
return z, valores_data, errores_data, rd_fid
dataset_BAO = []
for i in range(5):
aux = leer_data_BAO(archivo_BAO[i])
dataset_BAO.append(aux)
#%%
num_datasets = 5
#[omega_m,H_0] = [0.33013649504023296, 66.48702802652504]
[omega_m, H_0] = [0.298, 73.5]
zs_modelo = np.linspace(0.01, 3, 10**6)
H_modelo = H_LCDM(zs_modelo, omega_m, H_0)
rd = r_drag_camb(omega_m, H_0) #Calculo del rd
legends = ['Da', 'Dh', 'Dm', 'Dv', 'H']
chies = np.zeros(num_datasets)
for i in range(5):
(z_data, valores_data, errores_data, rd_fid) = dataset_BAO[i]
if i == 0: #Dato de Da
valores_data_2 = valores_data * (rd / rd_fid)
errores_data_2 = errores_data * (rd / rd_fid)
elif i == 4: #Datos de H
valores_data_2 = np.zeros(len(valores_data))
errores_data_2 = np.zeros(len(errores_data))
for j in range(len(z_data)):
valores_data_2[j] = valores_data[j] * (rd_fid[j] / rd)
errores_data_2[j] = errores_data[j] * (rd_fid[j] / rd)
def testeo_supernovas(theta,
params_fijos,
zcmb,
zhel,
Cinv,
mb0,
x1,
color,
hmass,
cantidad_zs=int(10**5),
model='HS',
lcdm=False):
'''
DEPRECATED
Dados los parámetros del modelo devuelve un chi2 para los datos
de supernovas. 1 parámetro fijo y 4 variables'''
if lcdm == True:
if len(theta) == 5:
[Mabs, omega_m, alpha, beta, gamma] = theta
[H_0, n] = params_fijos
if len(theta) == 4:
[Mabs, alpha, beta, gamma] = theta
[omega_m, H_0, n] = params_fijos
zs = np.linspace(0, 3, cantidad_zs)
H_modelo = H_LCDM(zs, omega_m, H_0)
else:
if len(theta) == 7:
[Mabs, omega_m, b, H_0, alpha, beta, gamma] = theta
n = params_fijos
elif len(theta) == 6:
[Mabs, omega_m, b, alpha, beta, gamma] = theta
[H_0, n] = params_fijos
elif len(theta) == 4:
[Mabs, alpha, beta, gamma] = theta
[omega_m, b, H_0, n] = params_fijos
if (0 <= b < 0.2):
zs = np.linspace(0, 3, cantidad_zs)
if model == 'HS':
H_modelo = Taylor_HS(zs, omega_m, b, H_0)
else:
H_modelo = Taylor_ST(zs, omega_m, b, H_0)
else:
params_fisicos = [omega_m, b, H_0]
zs, H_modelo = integrador(params_fisicos,
n,
cantidad_zs=cantidad_zs,
model=model)
alpha_0 = 0.154
beta_0 = 3.02
gamma_0 = 0.053
mstep0 = 10.13
#tau0 = 0.001
#DeltaM_0=gamma_0*np.power((1.+np.exp((mstep0-hmass)/tau0)),-1)
#DeltaM=gamma*np.power((1.+np.exp((mstep0-hmass)/tau0)),-1)
#DeltaM_0 = gamma_0 * np.heaviside(hmass-mstep0, 1)
#DeltaM = gamma * np.heaviside(hmass-mstep0, 1)
muobs = mb0 - Mabs + x1 * (alpha - alpha_0) - color * (
beta - beta_0) + np.heaviside(hmass - mstep0, 1) * (gamma - gamma_0)
muth = magn_aparente_teorica(zs, H_modelo, zcmb, zhel)
deltamu = muobs - muth
transp = np.transpose(deltamu)
aux = np.dot(Cinv, deltamu)
chi2 = np.dot(transp, aux)
return chi2
H0 = 73.48
#%%
params_fisicos = [omega_m, b, H0]
zs_ode, H_ST = integrador(params_fisicos, verbose=True, model='ST')
_, H_ST_1 = Hubble_teorico_1(params_fisicos, verbose=True, model='ST')
#%% Exponencial
b = 2
omega_m = 0.5
H0 = 73.48
params_fisicos = [omega_m, b, H0]
zs_ode, H_EXP = integrador(params_fisicos, verbose=True, model='EXP')
_, H_EXP_1 = Hubble_teorico_1(params_fisicos, verbose=True, model='EXP')
#%% Graficamos todos los datos juntos
#%matplotlib qt5
plt.figure()
plt.title('Integrador $f(R)$')
plt.xlabel('z (redshift)')
plt.ylabel('H(z) ((km/seg)/Mpc)')
plt.plot(zs_ode, H_HS, '.', label='HS')
plt.plot(zs_ode, H_ST, '.', label='ST')
plt.plot(zs_ode, H_EXP, '.', label='Exp')
plt.plot(zs_ode, H_LCDM(zs_ode, omega_m, H0), '.', label='LCDM')
plt.legend(loc='best')
plt.grid(True)
# %%
#%matplotlib qt5
import sys
import os
from os.path import join as osjoin
from pc_path import definir_path
path_git, path_datos_global = definir_path()
os.chdir(path_git)
sys.path.append('./Software/Funcionales/')
from funciones_LambdaCDM import H_LCDM
omega_m = 0.24
b = 0.2
H0 = 73.48
zs = np.linspace(0,1,10000);
H_LCDM = H_LCDM(zs,omega_m,H0)
# Hu-Sawicki
H_HS_taylor = Taylor_HS(zs,omega_m,b,H0)
# Starobinsky
H_ST_taylor = Taylor_ST(zs,omega_m,b,H0)
plt.close()
plt.figure()
plt.grid(True)
plt.xlabel('z (redshift)')
plt.ylabel('H(z)')
plt.plot(zs,H_LCDM/H0,label='LCDM')
plt.plot(zs,H_HS_taylor/H0,'-.',label='HS')
plt.plot(zs,H_ST_taylor/H0,'-.',label='ST')