// 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; } */ }