// Natural logarithm of posterior probability density for one star, given parameters x, where
//
// x = {DM, Log_10(Mass_init), Log_10(Age), [Fe/H]}
double logP_single_star_synth(const double *x, double EBV, double RV,
const TGalacticLOSModel &gal_model, const TSyntheticStellarModel &stellar_model,
TExtinctionModel &ext_model, const TStellarData::TMagnitudes &d, TSED *tmp_sed) {
#define neginf -std::numeric_limits<double>::infinity()
double logP = 0.;
/*
* Likelihood
*/
bool del_sed = false;
if(tmp_sed == NULL) {
del_sed = true;
tmp_sed = new TSED(true);
}
if(!stellar_model.get_sed(x+1, *tmp_sed)) {
if(del_sed) { delete tmp_sed; }
return neginf;
}
double logL = 0.;
double tmp;
for(unsigned int i=0; i<NBANDS; i++) {
if(d.err[i] < 1.e9) {
tmp = tmp_sed->absmag[i] + x[_DM] + EBV * ext_model.get_A(RV, i); // Model apparent magnitude
logL += log( 0.5 - 0.5 * erf((tmp - d.maglimit[i] + 0.5) / 0.25) ); // Completeness fraction
tmp = (d.m[i] - tmp) / d.err[i];
logL -= 0.5*tmp*tmp;
}
}
logP += logL - d.lnL_norm;
if(del_sed) { delete tmp_sed; }
/*
* Priors
*/
logP += gal_model.log_prior_synth(x);
//double lnp0 = -100.;
//tmp = exp(logP - lnp0);
//logP = lnp0 + log(tmp + exp(-tmp)); // p --> p + p0 exp(-p/p0) (Smooth floor on outliers)
#undef neginf
return logP;
}
void sample_model_synth(TGalacticLOSModel &galactic_model, TSyntheticStellarModel &stellar_model, TExtinctionModel &extinction_model, TStellarData &stellar_data) {
unsigned int N_DM = 20;
double DM_min = 5.;
double DM_max = 20.;
TMCMCParams params(&galactic_model, &stellar_model, NULL, &extinction_model, &stellar_data, N_DM, DM_min, DM_max);
TMCMCParams params_tmp(&galactic_model, &stellar_model, NULL, &extinction_model, &stellar_data, N_DM, DM_min, DM_max);
// Random number generator
gsl_rng *r;
seed_gsl_rng(&r);
// Vector describing position in probability space
size_t length = 1 + params.N_DM + 4*params.N_stars;
// x = {RV, Delta_EBV_1, ..., Delta_EBV_M, Theta_1, ..., Theta_N}, where Theta = {DM, logMass, logtau, FeH}.
double *x = new double[length];
// Random starting point for reddening profile
x[0] = 3.1;// + gsl_ran_gaussian_ziggurat(r, 0.2); // RV
for(size_t i=0; i<params.N_DM; i++) { x[i+1] = params.data->EBV / (double)N_DM * gsl_ran_chisq(r, 1.); } // Delta_EBV
// Random starting point for each star
TSED sed_tmp(true);
for(size_t i = 1 + params.N_DM; i < 1 + params.N_DM + 4*params.N_stars; i += 4) {
x[i] = 5. + 13.*gsl_rng_uniform(r);
double logMass, logtau, FeH, tau;
bool in_lib = false;
while(!in_lib) {
logMass = gsl_ran_gaussian_ziggurat(r, 0.5);
tau = -1.;
while(tau <= 0.) {
tau = 1.e9 * (5. + gsl_ran_gaussian_ziggurat(r, 2.));
}
logtau = log10(tau);
FeH = -1.0 + gsl_ran_gaussian_ziggurat(r, 1.);
in_lib = stellar_model.get_sed(logMass, logtau, FeH, sed_tmp);
}
x[i+1] = logMass;
x[i+2] = logtau;
x[i+3] = FeH;
}
params.update_EBV_interp(x);
double *lnp_star = new double[params.N_stars];
double lnp_los = logP_los_synth(x, length, params, lnp_star);
std::cerr << "# ln p(x_0) = " << lnp_los << std::endl;
double *x_tmp = new double[length];
double Theta_tmp[4];
double sigma_Theta[4] = {0.1, 0.1, 0.1, 0.1};
double sigma_RV = 0.05;
double sigma_lnEBV = 0.1;
double lnp_tmp;
double *lnp_star_tmp = new double[params.N_stars];
double p;
unsigned int N_steps = 1000000;
TChain chain(length, N_steps);
TStats EBV_stats(N_DM);
// In each step
unsigned int N_star = 0;
unsigned int N_accept_star = 0;
unsigned int N_los = 0;
unsigned int N_accept_los = 0;
bool accept;
bool burn_in = true;
for(unsigned int i=0; i<N_steps; i++) {
if(i == N_steps/2) {
sigma_Theta[0] = 0.05;
sigma_Theta[1] = 0.05;
sigma_Theta[2] = 0.05;
sigma_Theta[3] = 0.05;
sigma_RV = 0.005;
sigma_lnEBV = 0.05;
burn_in = false;
}
// Step each star
for(unsigned int n=0; n<params.N_stars; n++) {
if(!burn_in) { N_star++; }
rand_gaussian_vector(&Theta_tmp[0], &x[1+N_DM+4*n], &sigma_Theta[0], 4, r);
lnp_tmp = logP_single_star_synth(&Theta_tmp[0], params.get_EBV(Theta_tmp[_DM]), x[0], galactic_model, stellar_model, extinction_model, stellar_data.star[n]);
accept = false;
if(lnp_tmp > lnp_star[n]) {
accept = true;
} else {
p = gsl_rng_uniform(r);
if((p > 0.) && (log(p) < lnp_tmp - lnp_star[n])) {
accept = true;
}
}
if(accept) {
if(!burn_in) { N_accept_star++; }
for(size_t k=0; k<4; k++) { x[1+N_DM+4*n+k] = Theta_tmp[k]; }
lnp_los += lnp_tmp - lnp_star[n];
lnp_star[n] = lnp_tmp;
}
}
// Step reddening profile
if(!burn_in) { N_los++; }
for(size_t k=0; k<length; k++) { x_tmp[k] = x[k]; }
//if(!burn_in) { x_tmp[0] += gsl_ran_gaussian_ziggurat(r, sigma_RV); }
for(unsigned int m=0; m<params.N_DM; m++) { x_tmp[1+m] += gsl_ran_gaussian_ziggurat(r, sigma_lnEBV); }
params_tmp.update_EBV_interp(x_tmp);
lnp_tmp = logP_los_synth(x_tmp, length, params_tmp, lnp_star_tmp);
//if(isinf(lnp_tmp)) {
// lnp_tmp = logP_los(x, length, params_tmp, lnp_star_tmp);
//}
//std::cerr << "# ln p(y) = " << lnp_tmp << std::endl;
accept = false;
if(lnp_tmp > lnp_los) {
accept = true;
} else if(log(gsl_rng_uniform(r)) < lnp_tmp - lnp_los) {
accept = true;
}
if(accept) {
if(!burn_in) { N_accept_los++; }
for(size_t k=0; k<1+N_DM; k++) { x[k] = x_tmp[k]; }
for(size_t k=0; k<params.N_stars; k++) { lnp_star[k] = lnp_star_tmp[k]; }
lnp_los = lnp_tmp;
params.update_EBV_interp(x);
//std::cerr << "# ln p(x) = " << lnp_los << std::endl;
}
if(!burn_in) {
chain.add_point(x, lnp_los, 1.);
x_tmp[0] = exp(x[1]);
for(size_t k=1; k<N_DM; k++) {
x_tmp[k] = x_tmp[k-1] + exp(x[k]);
}
EBV_stats(x_tmp, 1);
}
}
std::cerr << "# ln p(x) = " << lnp_los << std::endl;
std::cout.precision(4);
std::cerr << std::endl;
std::cerr << "# % acceptance: " << 100. * (double)N_accept_star / (double)N_star << " (stars)" << std::endl;
std::cerr << " " << 100. * (double)N_accept_los / (double)N_los << " (extinction)" << std::endl;
std::cerr << "# R_V = " << x[0] << std::endl << std::endl;
std::cerr << "# DM E(B-V)" << std::endl;
std::cerr << "# =============" << std::endl;
for(double DM=5.; DM<20.; DM+=1.) {
std::cerr << "# " << DM << " " << params.get_EBV(DM) << std::endl;
}
std::cerr << std::endl;
EBV_stats.print();
std::cerr << std::endl;
delete[] x;
delete[] x_tmp;
delete[] lnp_star;
delete[] lnp_star_tmp;
}
void draw_from_synth_model(size_t nstars, double RV, TGalacticLOSModel& gal_model, TSyntheticStellarModel& stellar_model,
TStellarData& stellar_data, TExtinctionModel& ext_model, double (&mag_limit)[5]) {
unsigned int samples = 1000;
void* gal_model_ptr = static_cast<void*>(&gal_model);
double DM_min = 0.;
double DM_max = 25.;
TDraw1D draw_DM(&log_dNdmu_draw, DM_min, DM_max, gal_model_ptr, samples, true);
double logMass_min = -0.9;
double logMass_max = 1.1;
TDraw1D draw_logMass_disk(&disk_IMF_draw, logMass_min, logMass_max, gal_model_ptr, samples, false);
TDraw1D draw_logMass_halo(&halo_IMF_draw, logMass_min, logMass_max, gal_model_ptr, samples, false);
double tau_min = 1.e6;
double tau_max = 13.e9;
TDraw1D draw_tau_disk(&disk_SFR_draw, tau_min, tau_max, gal_model_ptr, samples, false);
TDraw1D draw_tau_halo(&halo_SFR_draw, tau_min, tau_max, gal_model_ptr, samples, false);
double FeH_min = -2.5;
double FeH_max = 1.;
TDraw1D draw_FeH_disk(&disk_FeH_draw, FeH_min, FeH_max, gal_model_ptr, samples, false);
TDraw1D draw_FeH_halo(&halo_FeH_draw, FeH_min, FeH_max, gal_model_ptr, samples, false);
stellar_data.clear();
gal_model.get_lb(stellar_data.l, stellar_data.b);
gsl_rng *r;
seed_gsl_rng(&r);
double EBV, DM, logtau, logMass, FeH;
double f_halo;
bool halo, in_lib, observed;
TSED sed;
double mag[NBANDS];
double err[NBANDS];
std::cout << "Component E(B-V) DM log(Mass) log(tau) [Fe/H] g r i z y " << std::endl;
std::cout << "=============================================================================================================" << std::endl;
std::cout.flags(std::ios::left);
std::cout.precision(3);
for(size_t i=0; i<nstars; i++) {
observed = false;
while(!observed) {
// Draw E(B-V)
EBV = gsl_ran_chisq(r, 1.);
// Draw DM
DM = draw_DM();
// Draw stellar type
f_halo = gal_model.f_halo(DM);
halo = (gsl_rng_uniform(r) < f_halo);
in_lib = false;
while(!in_lib) {
if(halo) {
logMass = draw_logMass_halo();
logtau = log10(draw_tau_halo());
FeH = draw_FeH_halo();
} else {
logMass = draw_logMass_disk();
logtau = log10(draw_tau_disk());
FeH = draw_FeH_disk();
}
in_lib = stellar_model.get_sed(logMass, logtau, FeH, sed);
}
// Generate magnitudes
observed = true;
unsigned int N_nonobs = 0;
for(size_t k=0; k<NBANDS; k++) {
mag[k] = sed.absmag[k] + DM + EBV * ext_model.get_A(RV, k);
err[k] = 0.02 + 0.1*exp(mag[i]-mag_limit[i]-1.5);
mag[k] += gsl_ran_gaussian_ziggurat(r, err[k]);
// Require detection in g band and 3 other bands
if(mag[k] > mag_limit[k]) {
N_nonobs++;
if((k == 0) || N_nonobs > 1) {
observed = false;
break;
}
}
}
}
std::cout << (halo ? "halo" : "disk") << " ";
std::cout << std::setw(9) << EBV << " ";
std::cout << std::setw(9) << DM << " ";
std::cout << std::setw(9) << logMass << " ";
std::cout << std::setw(9) << logtau << " ";
std::cout << std::setw(9) << FeH << " ";
for(size_t k=0; k<NBANDS; k++) {
std::cout << std::setw(9) << mag[k] << " ";
}
std::cout << std::endl;
TStellarData::TMagnitudes mag_tmp(mag, err);
mag_tmp.obj_id = i;
mag_tmp.l = stellar_data.l;
mag_tmp.b = stellar_data.b;
stellar_data.star.push_back(mag_tmp);
}
std::cout << std::endl;
gsl_rng_free(r);
/*std::vector<bool> filled;
DM_of_P.get_filled(filled);
for(std::vector<bool>::iterator it = filled.begin(); it != filled.end(); ++it) {
std::cout << *it << std::endl;
}
*/
}
