Beispiel #1
0
TDraw1D::TDraw1D(func_ptr_t func, double _x_min, double _x_max, void* _params, unsigned int samples, bool is_log)
	: x_of_P(NULL), r(NULL), params(_params)
{
	assert(samples > 1);
	
	x_min = _x_min;
	x_max = _x_max;
	double dx = (x_max - x_min) / (double)(samples - 1);
	
	// Construct an interpolator for P(x)
	double fill = -1.;
	TMultiLinearInterp<double> P_of_x(&x_min, &x_max, &samples, 1, fill);
	double x;
	double P = 0.;
	for(unsigned int i=0; i<samples; i++) {
		x = x_min + (double)i * dx;
		P_of_x.set(&x, P);
		if(i < samples - 1) {
			if(is_log) { P += dx * exp(func(x, params)); } else { P += dx * func(x, params); }
		}
	}
	double P_norm = P;
	
	// Invert the interpolator for get x(P)
	double P_min = 0.;
	double P_max = 1.;
	double dP = 1. / (double)(samples - 1);
	x_of_P = new TMultiLinearInterp<double>(&P_min, &P_max, &samples, 1, fill);
	unsigned int k_last = 0;
	double P_tmp, dPdx;
	for(unsigned int i=0; i<samples; i++) {
		P = (double)i * dP;
		for(unsigned int k=k_last+1; k<samples; k++) {
			x = x_min + (double)k * dx;
			P_tmp = P_of_x(&x) / P_norm;
			if(P_tmp >= P) {
				dPdx = (P_tmp - (double)(i-1)*dP) / dx;
				x = x_min + (double)(k-1) * dx + dP / dPdx;
				k_last = k - 1;
				break;
			}
		}
		
		x_of_P->set(&P, x);
	}
	P_tmp = 1.;
	x_of_P->set(&P_tmp, x_max);
	
	seed_gsl_rng(&r);
}
Beispiel #2
0
// Find a point in space with high density.
void TChain::find_center(double* const center, gsl_matrix *const cov, gsl_matrix *const inv_cov, double* det_cov, double dmax, unsigned int iterations) const {
	// Check that the matrices are the correct size
	/*assert(cov->size1 == N);
	assert(cov->size2 == N);
	assert(inv_cov->size1 == N);
	assert(inv_cov->size2 == N);*/
	
	// Choose random point in chain as starting point
	gsl_rng *r;
	seed_gsl_rng(&r);
	
	long unsigned int index_tmp = gsl_rng_uniform_int(r, length);
	const double *x_tmp = get_element(index_tmp);
	for(unsigned int i=0; i<N; i++) { center[i] = x_tmp[i]; }
	
	// Iterate
	double *sum = new double[N];
	double weight;
	for(unsigned int i=0; i<iterations; i++) {
		// Set mean of nearby points as center
		weight = 0.;
		for(unsigned int n=0; n<N; n++) { sum[n] = 0.; }
		for(unsigned int k=0; k<length; k++) {
			x_tmp = get_element(k);
			if(metric_dist2(inv_cov, x_tmp, center, N) < dmax*dmax) {
				for(unsigned int n=0; n<N; n++) { sum[n] += w[k] * x_tmp[n]; }
				weight += w[k];
			}
		}
		for(unsigned int n=0; n<N; n++) { center[n] = sum[n] / (double)weight; }
		
		dmax *= 0.9;
	}
	
	//for(unsigned int n=0; n<N; n++) { std::cout << " " << center[n]; }
	//std::cout << std::endl;
	
	gsl_rng_free(r);
	delete[] sum;
}
Beispiel #3
0
TGaussianMixture::TGaussianMixture(unsigned int _ndim, unsigned int _nclusters) 
	: ndim(_ndim), nclusters(_nclusters)
{
	w = new double[nclusters];
	mu = new double[ndim*nclusters];
	cov = new gsl_matrix*[nclusters];
	inv_cov = new gsl_matrix*[nclusters];
	sqrt_cov = new gsl_matrix*[nclusters];
	for(unsigned int k=0; k<nclusters; k++) {
		cov[k] = gsl_matrix_alloc(ndim, ndim);
		inv_cov[k] = gsl_matrix_alloc(ndim, ndim);
		sqrt_cov[k] = gsl_matrix_alloc(ndim, ndim);
	}
	det_cov = new double[nclusters];
	LU = gsl_matrix_alloc(ndim, ndim);
	p = gsl_permutation_alloc(ndim);
	esv = gsl_eigen_symmv_alloc(ndim);
	eival = gsl_vector_alloc(ndim);
	eivec = gsl_matrix_alloc(ndim, ndim);
	sqrt_eival = gsl_matrix_alloc(ndim, ndim);
	seed_gsl_rng(&r);
}
Beispiel #4
0
TChainWriteBuffer::TChainWriteBuffer(unsigned int nDim, unsigned int nSamples, unsigned int nReserved)
	: buf(NULL), nDim_(nDim+1), nSamples_(nSamples), nReserved_(0), length_(0), samplePos(nSamples, 0)
{
	reserve(nReserved);
	seed_gsl_rng(&r);
}
Beispiel #5
0
bool TChain::save(std::string fname, std::string group_name, size_t index,
                  std::string dim_name, int compression, int subsample,
                  bool converged, float lnZ) const {
	if((compression<0) || (compression > 9)) {
		std::cerr << "! Invalid gzip compression level: " << compression << std::endl;
		return false;
	}
	
	H5::Exception::dontPrint();
	
	H5::H5File *file = H5Utils::openFile(fname);
	if(file == NULL) { return false; }
	
	/*
	try {
		file->unlink(group_name);
	} catch(...) {
		// pass
	}
	*/
	
	H5::Group *group = H5Utils::openGroup(file, group_name);
	if(group == NULL) {
		delete file;
		return false;
	}
	
	/*
	 *  Attributes
	 */
	
	// Datatype
	H5::CompType att_type(sizeof(TChainAttribute));
	hid_t tid = H5Tcopy(H5T_C_S1);
	H5Tset_size(tid, H5T_VARIABLE);
	att_type.insertMember("dim_name", HOFFSET(TChainAttribute, dim_name), tid);
	//att_type.insertMember("total_weight", HOFFSET(TChainAttribute, total_weight), H5::PredType::NATIVE_FLOAT);
	//att_type.insertMember("ndim", HOFFSET(TChainAttribute, ndim), H5::PredType::NATIVE_UINT64);
	//att_type.insertMember("length", HOFFSET(TChainAttribute, length), H5::PredType::NATIVE_UINT64);
	
	// Dataspace
	int att_rank = 1;
	hsize_t att_dim = 1;
	H5::DataSpace att_space(att_rank, &att_dim);
	
	// Dataset
	//H5::Attribute att = group->createAttribute("parameter names", att_type, att_space);
	
	TChainAttribute att_data;
	att_data.dim_name = new char[dim_name.size()+1];
	std::strcpy(att_data.dim_name, dim_name.c_str());
	//att_data.total_weight = total_weight;
	//att_data.ndim = N;
	//att_data.length = length;
	
	//att.write(att_type, &att_data);
	delete[] att_data.dim_name;
	
	//int att_rank = 1;
	//hsize_t att_dim = 1;
	
	H5::DataType conv_dtype = H5::PredType::NATIVE_UCHAR;
	H5::DataSpace conv_dspace(att_rank, &att_dim);
	//H5::Attribute conv_att = H5Utils::openAttribute(group, "converged", conv_dtype, conv_dspace);
	//conv_att.write(conv_dtype, &converged);
	
	H5::DataType lnZ_dtype = H5::PredType::NATIVE_FLOAT;
	H5::DataSpace lnZ_dspace(att_rank, &att_dim);
	//H5::Attribute lnZ_att = H5Utils::openAttribute(group, "ln Z", lnZ_dtype, lnZ_dspace);
	//lnZ_att.write(lnZ_dtype, &lnZ);
	
	// Creation property list to be used for all three datasets
	H5::DSetCreatPropList plist;
	//plist.setDeflate(compression);	// gzip compression level
	float fillvalue = 0;
	plist.setFillValue(H5::PredType::NATIVE_FLOAT, &fillvalue);
	
	H5D_layout_t layout = H5D_COMPACT;
	plist.setLayout(layout);
	
	/*
	 *  Choose subsample of points in chain
	 */
	size_t *el_idx = NULL;
	size_t *subsample_idx = NULL;
	if(subsample > 0) {
		size_t tot_weight_tmp = (size_t)ceil(total_weight);
		el_idx = new size_t[tot_weight_tmp];
		size_t unrolled_idx = 0;
		size_t chain_idx = 0;
		std::vector<double>::const_iterator it, it_end;
		it_end = w.end();
		for(it = w.begin(); it != it_end; ++it, chain_idx++) {
			for(size_t n = unrolled_idx; n < unrolled_idx + (size_t)(*it); n++) {
				el_idx[n] = chain_idx;
			}
			unrolled_idx += (size_t)(*it);
		}
		
		assert(chain_idx == length);
		
		gsl_rng *r;
		seed_gsl_rng(&r);
		subsample_idx = new size_t[tot_weight_tmp];
		for(size_t i=0; i<subsample; i++) {
			subsample_idx[i] = el_idx[gsl_rng_uniform_int(r, tot_weight_tmp)];
		}
	}
	
	
	/*
	 *  Coordinates
	 */
	
	// Dataspace
	hsize_t dim;
	if(subsample > 0) {
		dim = subsample;
	} else {
		dim = length;
	}
	// Chunking (required for compression)
	int rank = 2;
	hsize_t coord_dim[2] = {dim, N};
	//if(dim < chunk) {
	//plist.setChunk(rank, &(coord_dim[0]));
	//} else {
	//	plist.setChunk(rank, &chunk);
	//}
	H5::DataSpace x_dspace(rank, &(coord_dim[0]));
	
	// Dataset
	//std::stringstream x_dset_path;
	//x_dset_path << group_name << "/chain/coords";
	std::stringstream coordname;
	coordname << "coords " << index;
	H5::DataSet* x_dataset = new H5::DataSet(group->createDataSet(coordname.str(), H5::PredType::NATIVE_FLOAT, x_dspace, plist));
	
	// Write
	float *buf = new float[N*dim];
	if(subsample > 0) {
		size_t tmp_idx;
		for(size_t i=0; i<subsample; i++) {
			tmp_idx = subsample_idx[i];
			for(size_t k=0; k<N; k++) {
				buf[N*i+k] = x[N*tmp_idx+k];
			}
		}
	} else {
		for(size_t i=0; i<dim; i++) { buf[i] = x[i]; }
	}
	x_dataset->write(buf, H5::PredType::NATIVE_FLOAT);
	
	
	/*
	 *  Weights
	 */
	
	// Dataspace
	if(subsample <= 0) {
		dim = w.size();
		
		rank = 1;
		H5::DataSpace w_dspace(rank, &dim);
		
		// Dataset
		//std::stringstream w_dset_path;
		//w_dset_path << group_name << "/chain/weights";
		H5::DataSet* w_dataset = new H5::DataSet(group->createDataSet("weights", H5::PredType::NATIVE_FLOAT, w_dspace, plist));
		
		// Write
		if(subsample > 0) {
			for(size_t i=0; i<subsample; i++) { buf[i] = 1.; }
		} else {
			assert(w.size() < x.size());
			for(size_t i=0; i<w.size(); i++) { buf[i] = w[i]; }
		}
		w_dataset->write(buf, H5::PredType::NATIVE_FLOAT);
		
		delete w_dataset;
	}
	
	/*
	 *  Probability densities
	 */
	
	// Dataspace
	rank = 1;
	H5::DataSpace L_dspace(rank, &dim);
	
	// Dataset
	//std::stringstream L_dset_path;
	//L_dset_path << group_name << "/chain/probs";
	std::stringstream lnpname;
	lnpname << "ln_p " << index;
	H5::DataSet* L_dataset = new H5::DataSet(group->createDataSet(lnpname.str(), H5::PredType::NATIVE_FLOAT, L_dspace, plist));
	
	// Write
	if(subsample > 0) {
		for(size_t i=0; i<subsample; i++) { buf[i] = L[subsample_idx[i]]; }
	} else {
		assert(L.size() < x.size());
		for(size_t i=0; i<L.size(); i++) { buf[i] = L[i]; }
	}
	L_dataset->write(buf, H5::PredType::NATIVE_FLOAT);
	
	
	if(subsample > 0) {
		delete[] el_idx;
		delete[] subsample_idx;
	}
	
	delete[] buf;
	
	delete x_dataset;
	delete L_dataset;
	
	delete group;
	delete file;
	
	return true;
}
Beispiel #6
0
// Find a point in space with high density.
void TChain::find_center(double* const center, gsl_matrix *const cov, gsl_matrix *const inv_cov, double* det_cov, double dmax, unsigned int iterations) const {
	// Check that the matrices are the correct size
	/*assert(cov->size1 == N);
	assert(cov->size2 == N);
	assert(inv_cov->size1 == N);
	assert(inv_cov->size2 == N);*/
	
	// Choose random point in chain as starting point
	gsl_rng *r;
	seed_gsl_rng(&r);
	
	long unsigned int index_tmp = gsl_rng_uniform_int(r, length);
	const double *x_tmp = get_element(index_tmp);
	for(unsigned int i=0; i<N; i++) { center[i] = x_tmp[i]; }
	
	//std::cout << "center #0:";
	//for(unsigned int n=0; n<N; n++) { std::cout << " " << center[n]; }
	//std::cout << std::endl;
	
	/*double *E_k = new double[N];
	double *E_ij = new double[N*N];
	for(unsigned int n1=0; n1<N; n1++) {
		E_k[n1] = 0.;
		for(unsigned int n2=0; n2<N; n2++) { E_ij[n1 + N*n2] = 0.; }
	}*/
	
	// Iterate
	double *sum = new double[N];
	double weight;
	for(unsigned int i=0; i<iterations; i++) {
		// Set mean of nearby points as center
		weight = 0.;
		for(unsigned int n=0; n<N; n++) { sum[n] = 0.; }
		for(unsigned int k=0; k<length; k++) {
			x_tmp = get_element(k);
			if(metric_dist2(inv_cov, x_tmp, center, N) < dmax*dmax) {
				for(unsigned int n=0; n<N; n++) { sum[n] += w[k] * x_tmp[n]; }
				weight += w[k];
				
				// Calculate the covariance
				/*if(i == iterations - 1) {
					for(unsigned int n1=0; n1<N; n1++) {
						E_k[n1] += w[k] * x_tmp[n1];
						for(unsigned int n2=0; n2<N; n2++) { E_ij[n1 + N*n2] += w[k] * x_tmp[n1] * x_tmp[n2]; }
					}
				}*/
			}
		}
		//std::cout << "center #" << i+1 << ":";
		for(unsigned int n=0; n<N; n++) { center[n] = sum[n] / (double)weight; }//std::cout << " " << center[n]; }
		//std::cout << " (" << weight << ")" << std::endl;
		
		dmax *= 0.9;
	}
	
	for(unsigned int n=0; n<N; n++) { std::cout << " " << center[n]; }
	std::cout << std::endl;
	
	// Calculate the covariance matrix of the enclosed points
	/*double tmp;
	for(unsigned int i=0; i<N; i++) {
		for(unsigned int j=i; j<N; j++) {
			tmp = (E_ij[i + N*j] - E_k[i]*E_k[j]/(double)weight) / (double)weight;
			gsl_matrix_set(cov, i, j, tmp);
			if(i != j) { gsl_matrix_set(cov, j, i, tmp); }
		}
	}*/
	
	// Get the inverse of the covariance
	/*int s;
	gsl_permutation* p = gsl_permutation_alloc(N);
	gsl_matrix* LU = gsl_matrix_alloc(N, N);
	gsl_matrix_memcpy(LU, cov);
	gsl_linalg_LU_decomp(LU, p, &s);
	gsl_linalg_LU_invert(LU, p, inv_cov);
	
	// Get the determinant of the covariance
	*det_cov = gsl_linalg_LU_det(LU, s);
	
	// Cleanup
	gsl_matrix_free(LU);
	gsl_permutation_free(p);
	delete[] E_k;
	delete[] E_ij;*/
	
	gsl_rng_free(r);
	delete[] sum;
}
Beispiel #7
0
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;
}
Beispiel #8
0
void draw_from_emp_model(size_t nstars, double RV, TGalacticLOSModel& gal_model, TStellarModel& 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);
	void* stellar_model_ptr = static_cast<void*>(&stellar_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 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);
	
	double Mr_min = -1.;
	double Mr_max = mag_limit[1];
	TDraw1D draw_Mr(&Mr_draw, Mr_min, Mr_max, stellar_model_ptr, samples, true);
	
	stellar_data.clear();
	gal_model.get_lb(stellar_data.l, stellar_data.b);
	
	gsl_rng *r;
	seed_gsl_rng(&r);
	double EBV, DM, Mr, FeH;
	double f_halo;
	bool halo, in_lib, observed;
	TSED sed;
	double mag[NBANDS];
	double err[NBANDS];
	std::cout << "#         Component E(B-V)    DM        Mr        [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 DM
			DM = draw_DM();
			
			// Draw E(B-V)
			//EBV = gsl_ran_chisq(r, 1.);
			
			EBV = 0.;
			//if(DM > 5.) { EBV += 0.05; }
			if(DM > 10.) { EBV += 2.5; }
			
			// 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) {
					FeH = draw_FeH_halo();
				} else {
					FeH = draw_FeH_disk();
				}
				Mr = draw_Mr();
				in_lib = stellar_model.get_sed(Mr, FeH, sed);
			}
			
			// Generate magnitudes
			observed = true;
			unsigned int N_nonobs = 0;
			double p_det;
			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.3*exp(mag[k]-mag_limit[k]);
				if(err[k] > 1.) { err[k] = 1.; }
				mag[k] += gsl_ran_gaussian_ziggurat(r, err[k]);
				
				// Require detection in g band and 3 other bands
				p_det = 0.5 - 0.5 * erf((mag[k] - mag_limit[k] + 0.5) / 0.25);
				if(gsl_rng_uniform(r) > p_det) {
					mag[k] = 0.;
					err[k] = 1.e10;
					
					N_nonobs++;
					if((k == 0) || N_nonobs > 1) {
						observed = false;
						break;
					}
				}
			}
		}
		
		std::cout << std::setw(9) << i+1 << " ";
		std::cout << (halo ? "halo" : "disk") << "      ";
		std::cout << std::setw(9) << EBV << " ";
		std::cout << std::setw(9) << DM << " ";
		std::cout << std::setw(9) << Mr << " ";
		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;
	}
	*/
	
}
Beispiel #9
0
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;
	}
	*/
	
}