double guess_EBV_max(TImgStack &img_stack) { cv::Mat stack, row_avg, col_avg; // Stack images img_stack.stack(stack); // Normalize at each distance /*cv::reduce(stack, col_avg, 1, CV_REDUCE_MAX); double tmp; for(size_t i=0; i<col_avg.rows; i++) { tmp = col_avg.at<double>(i, 0); if(tmp > 0) { stack.row(i) /= tmp; } }*/ // Sum across each EBV cv::reduce(stack, row_avg, 0, CV_REDUCE_AVG); double max_sum = *std::max_element(row_avg.begin<double>(), row_avg.end<double>()); int max = 1; /*for(int i = row_avg.cols - 1; i >= 0; i--) { std::cout << i << "\t" << row_avg.at<double>(0, i) << std::endl; }*/ //std::cout << std::endl; for(int i = row_avg.cols - 1; i > 0; i--) { //std::cout << i << "\t" << row_avg.at<double>(0, i) << std::endl; if(row_avg.at<double>(0, i) > 0.001 * max_sum) { max = i; break; } } // Convert bin index to E(B-V) return max * img_stack.rect->dx[1] + img_stack.rect->min[1]; }
// Guess upper limit for E(B-V) based on stacked probability surfaces double guess_EBV_max(TImgStack &img_stack) { cv::Mat stack, row_avg, col_avg; // Stack images img_stack.stack(stack); // Sum across each EBV cv::reduce(stack, row_avg, 0, CV_REDUCE_AVG); double max_sum = *std::max_element(row_avg.begin<double>(), row_avg.end<double>()); int max = 1; for(int i = row_avg.cols - 1; i > 0; i--) { if(row_avg.at<double>(0, i) > 0.001 * max_sum) { max = i; break; } } // Convert bin index to E(B-V) return max * img_stack.rect->dx[1] + img_stack.rect->min[1]; }
void sample_indiv_emp(std::string &out_fname, TMCMCOptions &options, TGalacticLOSModel& galactic_model, TStellarModel& stellar_model, TExtinctionModel& extinction_model, TStellarData& stellar_data, TImgStack& img_stack, std::vector<bool> &conv, std::vector<double> &lnZ, double RV_sigma, bool saveSurfs) { unsigned int N_DM = 20; double DM_min = 5.; double DM_max = 20.; TMCMCParams params(&galactic_model, NULL, &stellar_model, &extinction_model, &stellar_data, N_DM, DM_min, DM_max); if(RV_sigma > 0.) { params.vary_RV = true; params.RV_variance = RV_sigma*RV_sigma; } std::string dim_name[5] = {"E(B-V)", "DM", "Mr", "FeH", "R_V"}; double min[2] = {5., 0.}; double max[2] = {20., 5.}; unsigned int N_bins[2] = {120, 500}; TRect rect(min, max, N_bins); img_stack.resize(params.N_stars); img_stack.set_rect(rect); TImgWriteBuffer *imgBuffer = NULL; if(saveSurfs) { imgBuffer = new TImgWriteBuffer(rect, params.N_stars); } unsigned int max_attempts = 3; unsigned int N_steps = options.steps; unsigned int N_samplers = options.samplers; unsigned int N_threads = options.N_threads; unsigned int ndim; if(params.vary_RV) { ndim = 5; } else { ndim = 4; } double *GR = new double[ndim]; double GR_threshold = 1.1; TNullLogger logger; TAffineSampler<TMCMCParams, TNullLogger>::pdf_t f_pdf = &logP_indiv_simple_emp; TAffineSampler<TMCMCParams, TNullLogger>::rand_state_t f_rand_state = &gen_rand_state_indiv_emp; timespec t_start, t_write, t_end; std::cerr << std::endl; unsigned int N_nonconv = 0; TChainWriteBuffer chainBuffer(ndim, 100, params.N_stars); std::stringstream group_name; group_name << "/pixel " << stellar_data.healpix_index; for(size_t n=0; n<params.N_stars; n++) { params.idx_star = n; clock_gettime(CLOCK_MONOTONIC, &t_start); std::cout << "Star #" << n+1 << " of " << params.N_stars << std::endl; std::cout << "====================================" << std::endl; std::cout << "mags = "; for(unsigned int i=0; i<NBANDS; i++) { std::cout << std::setprecision(4) << params.data->star[n].m[i] << " "; } std::cout << std::endl; std::cout << "errs = "; for(unsigned int i=0; i<NBANDS; i++) { std::cout << std::setprecision(3) << params.data->star[n].err[i] << " "; } std::cout << std::endl; std::cout << "maglimit = "; for(unsigned int i=0; i<NBANDS; i++) { std::cout << std::setprecision(3) << params.data->star[n].maglimit[i] << " "; } std::cout << std::endl << std::endl; //std::cerr << "# Setting up sampler" << std::endl; TParallelAffineSampler<TMCMCParams, TNullLogger> sampler(f_pdf, f_rand_state, ndim, N_samplers*ndim, params, logger, N_threads); sampler.set_scale(1.5); sampler.set_replacement_bandwidth(0.2); //std::cerr << "# Burn-in" << std::endl; sampler.step(N_steps, false, 0., options.p_replacement, 0.); sampler.clear(); //std::cerr << "# Main run" << std::endl; bool converged = false; size_t attempt; for(attempt = 0; (attempt < max_attempts) && (!converged); attempt++) { sampler.step((1<<attempt)*N_steps, true, 0., options.p_replacement, 0.); converged = true; sampler.get_GR_diagnostic(GR); for(size_t i=0; i<ndim; i++) { if(GR[i] > GR_threshold) { converged = false; if(attempt != max_attempts-1) { sampler.clear(); //logger.clear(); } break; } } } clock_gettime(CLOCK_MONOTONIC, &t_write); // Compute evidence TChain chain = sampler.get_chain(); double lnZ_tmp = chain.get_ln_Z_harmonic(true, 10., 0.25, 0.05); if(isinf(lnZ_tmp)) { lnZ_tmp = -std::numeric_limits<double>::infinity(); } // Save thinned chain chainBuffer.add(chain, converged, lnZ_tmp); // Save binned p(DM, EBV) surface chain.get_image(*(img_stack.img[n]), rect, 1, 0, true, 0.1, 0.025, 500.); if(saveSurfs) { imgBuffer->add(*(img_stack.img[n])); } lnZ.push_back(lnZ_tmp); conv.push_back(converged); clock_gettime(CLOCK_MONOTONIC, &t_end); sampler.print_stats(); std::cout << std::endl; if(!converged) { N_nonconv++; std::cerr << "# Failed to converge." << std::endl; } std::cerr << "# Number of steps: " << (1<<(attempt-1))*N_steps << std::endl; std::cerr << "# ln Z: " << lnZ.back() << std::endl; std::cerr << "# Time elapsed: " << std::setprecision(2) << (t_end.tv_sec - t_start.tv_sec) + 1.e-9*(t_end.tv_nsec - t_start.tv_nsec) << " s" << std::endl; std::cerr << "# Sample time: " << std::setprecision(2) << (t_write.tv_sec - t_start.tv_sec) + 1.e-9*(t_write.tv_nsec - t_start.tv_nsec) << " s" << std::endl; std::cerr << "# Write time: " << std::setprecision(2) << (t_end.tv_sec - t_write.tv_sec) + 1.e-9*(t_end.tv_nsec - t_write.tv_nsec) << " s" << std::endl << std::endl; } chainBuffer.write(out_fname, group_name.str(), "stellar chains"); if(saveSurfs) { imgBuffer->write(out_fname, group_name.str(), "stellar pdfs"); } std::cerr << "====================================" << std::endl; std::cerr << std::endl; std::cerr << "# Failed to converge " << N_nonconv << " of " << params.N_stars << " times (" << std::setprecision(2) << 100.*(double)N_nonconv/(double)(params.N_stars) << " %)." << std::endl; std::cerr << std::endl; std::cerr << "====================================" << std::endl; if(imgBuffer != NULL) { delete imgBuffer; } delete[] GR; }
void monotonic_guess(TImgStack &img_stack, unsigned int N_regions, std::vector<double>& Delta_EBV, TMCMCOptions& options) { std::cout << "stacking images" << std::endl; // Stack images cv::Mat stack; img_stack.stack(stack); std::cout << "calculating weighted mean at each distance" << std::endl; // Weighted mean of each distance double * dist_y_sum = new double[stack.rows]; double * dist_y2_sum = new double[stack.rows]; double * dist_sum = new double[stack.rows]; for(int k = 0; k < stack.rows; k++) { dist_y_sum[k] = 0.; dist_y2_sum[k] = 0.; dist_sum[k] = 0.; } double y = 0.5; for(int j = 0; j < stack.cols; j++, y += 1.) { for(int k = 0; k < stack.rows; k++) { dist_y_sum[k] += y * stack.at<double>(k,j); dist_y2_sum[k] += y*y * stack.at<double>(k,j); dist_sum[k] += stack.at<double>(k,j); } } for(int k = 0; k < stack.rows; k++) { std::cout << k << "\t" << dist_y_sum[k]/dist_sum[k] << "\t" << sqrt(dist_y2_sum[k]/dist_sum[k]) << "\t" << dist_sum[k] << std::endl; } std::cout << "calculating weighted mean about each anchor" << std::endl; // Weighted mean in region of each anchor point std::vector<double> y_sum(N_regions+1, 0.); std::vector<double> y2_sum(N_regions+1, 0.); std::vector<double> w_sum(N_regions+1, 0.); int kStart = 0; int kEnd; double width = (double)(stack.rows) / (double)(N_regions); for(int n = 0; n < N_regions+1; n++) { std::cout << "n = " << n << std::endl; if(n == N_regions) { kEnd = stack.rows; } else { kEnd = ceil(((double)n + 0.5) * width); } for(int k = kStart; k < kEnd; k++) { y_sum[n] += dist_y_sum[k]; y2_sum[n] += dist_y2_sum[k]; w_sum[n] += dist_sum[k]; } kStart = kEnd + 1; } delete[] dist_sum; delete[] dist_y_sum; delete[] dist_y2_sum; std::cout << "Covert to EBV and sigma_EBV" << std::endl; // Create non-monotonic guess Delta_EBV.resize(N_regions+1); std::vector<double> sigma_EBV(N_regions+1, 0.); for(int i=0; i<N_regions+1; i++) { Delta_EBV[i] = 0; } for(int n = 0; n < N_regions+1; n++) { Delta_EBV[n] = img_stack.rect->min[1] + img_stack.rect->dx[1] * y_sum[n] / w_sum[n]; sigma_EBV[n] = img_stack.rect->dx[1] * sqrt( (y2_sum[n] - (y_sum[n] * y_sum[n] / w_sum[n])) / w_sum[n] ); std::cout << n << "\t" << Delta_EBV[n] << "\t+-" << sigma_EBV[n] << std::endl; } // Fit monotonic guess unsigned int N_steps = 100; unsigned int N_samplers = 2 * N_regions; unsigned int N_threads = options.N_threads; unsigned int ndim = N_regions + 1; std::cout << "Setting up params" << std::endl; TEBVGuessParams params(Delta_EBV, sigma_EBV, w_sum, img_stack.rect->max[1]); TNullLogger logger; TAffineSampler<TEBVGuessParams, TNullLogger>::pdf_t f_pdf = &lnp_monotonic_guess; TAffineSampler<TEBVGuessParams, TNullLogger>::rand_state_t f_rand_state = &gen_rand_monotonic; std::cout << "Setting up sampler" << std::endl; TParallelAffineSampler<TEBVGuessParams, TNullLogger> sampler(f_pdf, f_rand_state, ndim, N_samplers*ndim, params, logger, N_threads); sampler.set_scale(1.1); sampler.set_replacement_bandwidth(0.75); std::cout << "Stepping" << std::endl; sampler.step(int(N_steps*40./100.), true, 0., 0.5, 0.); sampler.step(int(N_steps*10./100), true, 0., 1., 0.); sampler.step(int(N_steps*40./100.), true, 0., 0.5, 0.); sampler.step(int(N_steps*10./100), true, 0., 1., 0., true); sampler.print_stats(); std::cout << "Getting best value" << std::endl; Delta_EBV.clear(); sampler.get_chain().get_best(Delta_EBV); std::cout << "Monotonic guess" << std::endl; double EBV_sum = 0.; for(size_t i=0; i<Delta_EBV.size(); i++) { EBV_sum += Delta_EBV[i]; std::cout << EBV_sum << std::endl; Delta_EBV[i] = log(Delta_EBV[i]); } std::cout << std::endl; }