void MC_Integration::Integrate(vector<double> constants){ size_t calls = numOfCalls; int dimension = (int) dim; //setting integral dimension int numOfConstants = constants.size(); double a[numOfConstants]; double xl[dimension]; double xu[dimension]; for (int i = 0; i < numOfConstants; i++){ a[i] = constants.at(i); } for (int i = 0; i < dimension; i++){ xl[i] = lowerLimits.at(i); xu[i] = upperLimits.at(i); } struct paramstruct params = {a}; gsl_monte_function G = {&Integrand,dim,¶ms}; gsl_monte_vegas_state *s = gsl_monte_vegas_alloc (dim); gsl_monte_vegas_integrate (&G, xl, xu, dim, calls, r, s, &result, &error); //vegas warm up do{ gsl_monte_vegas_integrate (&G, xl, xu, dim, calls*10, r, s, &result, &error); }while (fabs (gsl_monte_vegas_chisq (s) - 1.0) > 0.5); if(fabs (gsl_monte_vegas_chisq (s) - 1.0) > 0.5) cout << "Chi-squared larger too far away from 1. Use more calls" << endl; gsl_monte_vegas_free (s); gsl_rng_free (r); }
CAMLprim value ml_gsl_monte_vegas_integrate(value fun, value xlo, value xup, value calls, value rng, value state) { CAMLparam2(rng, state); double result,abserr; size_t dim=Double_array_length(xlo); LOCALARRAY(double, c_xlo, dim); LOCALARRAY(double, c_xup, dim); struct callback_params *params=CallbackParams_val(state); if(params->gslfun.mf.dim != dim) GSL_ERROR("wrong number of dimensions for function", GSL_EBADLEN); if(Double_array_length(xup) != dim) GSL_ERROR("array sizes differ", GSL_EBADLEN); params->closure=fun; memcpy(c_xlo, Double_array_val(xlo), dim*sizeof(double)); memcpy(c_xup, Double_array_val(xup), dim*sizeof(double)); gsl_monte_vegas_integrate(¶ms->gslfun.mf, c_xlo, c_xup, dim, Int_val(calls), Rng_val(rng), GSLVEGASSTATE_VAL(state), &result, &abserr); CAMLreturn(copy_two_double_arr(result, abserr)); }
virtual int exec(double* integral,double* error){ assert(ncomp==1); // gsl mc integration does only single component yo! gsl_monte_integrand_wrapper iw; iw.ncomp = ncomp; iw.params = params; iw.integrand = integrand; gsl_monte_function G; G.f = gsl_monte_integrand_wrapper::f; G.dim = ndim; G.params = (void*) &iw; double xl[ndim]; double xu[ndim]; std::fill(xl,xl+ndim,0.); // unit cube! std::fill(xu,xu+ndim,1.); // unit cube! const gsl_rng_type* T; gsl_rng* r; gsl_rng_env_setup(); T = gsl_rng_default; r = gsl_rng_alloc(T); gsl_monte_vegas_state* s = gsl_monte_vegas_alloc(ndim); gsl_monte_vegas_integrate(&G,xl,xu,ndim,calls,r,s,integral,error); gsl_monte_vegas_free(s); gsl_rng_free(r); return 0; // succes! }
int main (int argc, char *argv[]) { double psr; ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// // number of potentially observable pulsars double res_x,err_x; double xl_x[3]={0.0,0.0,-3.1415926/2.0}; double xu_x[3]={13.0,2.0*3.1415926,3.1415926/2.0}; const gsl_rng_type *T_x; gsl_rng *r_x; gsl_monte_function G_x={&g_psr,3,0}; size_t calls_x=5000000; T_x=gsl_rng_default; // calculation r_x=gsl_rng_alloc(T_x); gsl_monte_vegas_state *s_x = gsl_monte_vegas_alloc (3); gsl_monte_vegas_integrate (&G_x, xl_x, xu_x, 3, 10000, r_x, s_x,&res_x, &err_x); do { gsl_monte_vegas_integrate (&G_x, xl_x, xu_x, 3, calls_x/5, r_x, s_x,&res_x, &err_x); } while (fabs (gsl_monte_vegas_chisq (s_x) - 1.0) > 0.5); ///////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////// psr = res_x; printf ("psr event rate: %e\n", psr); gsl_monte_vegas_free (s_x); gsl_rng_free (r_x); return 0; }
double error (double x, void *p, size_t N) // calculate the error of chi, then use it to derive the error of jitter parameter { //printf ("Integrating...\n"); struct my_params *fp=(struct my_params *)p; //printf ("error: %lf %lf\n", fp->a, fp->b); double F; double res,err; double xl[1]={0.0}; double xu[1]={x}; const gsl_rng_type *T; gsl_rng *r; gsl_monte_function G={&chi_distribution,1,fp}; size_t calls = N; gsl_rng_env_setup (); T=gsl_rng_default; r = gsl_rng_alloc (T); gsl_monte_vegas_state *s = gsl_monte_vegas_alloc (1); gsl_monte_vegas_integrate (&G, xl, xu, 1, 10000, r, s, &res, &err); //printf ("result0: %lf %lf\n", res, err); do { gsl_monte_vegas_integrate (&G, xl, xu, 1, calls/5, r, s, &res, &err); } while (fabs (gsl_monte_vegas_chisq (s) - 1.0) > 0.5); //printf ("result of integration is: %e\n", res); gsl_monte_vegas_free (s); gsl_rng_free (r); F=res-0.682; // 1 sigma //F=res-0.9; return F; }
void monte_carlo_integration() { double res, err; double xl[3] = { 0, 0, 0 }; double xu[3] = { M_PI, M_PI, M_PI }; gsl_monte_function G = { &local::g, 3, NULL }; const std::size_t calls = 500000; gsl_rng_env_setup(); const gsl_rng_type *T = gsl_rng_default; gsl_rng *r = gsl_rng_alloc(T); // { gsl_monte_plain_state *s = gsl_monte_plain_alloc(3); gsl_monte_plain_integrate(&G, xl, xu, 3, calls, r, s, &res, &err); gsl_monte_plain_free(s); local::display_results("plain", res, err); } // { gsl_monte_miser_state *s = gsl_monte_miser_alloc(3); gsl_monte_miser_integrate(&G, xl, xu, 3, calls, r, s, &res, &err); gsl_monte_miser_free(s); local::display_results("miser", res, err); } // { gsl_monte_vegas_state *s = gsl_monte_vegas_alloc(3); gsl_monte_vegas_integrate(&G, xl, xu, 3, 10000, r, s, &res, &err); local::display_results("vegas warm-up", res, err); std::cout << "converging..." << std::endl; do { gsl_monte_vegas_integrate(&G, xl, xu, 3, calls/5, r, s, &res, &err); std::cout << "result = " << res << " sigma = " << err << " chisq/dof = " << s->chisq << std::endl; } while (std::fabs(s->chisq - 1.0) > 0.5); local::display_results("vegas final", res, err); gsl_monte_vegas_free(s); } }
int main (void) { double res, err; double a= 0.; double b= 2.; int dim=9; double xl[9] = { a,a,a,a,a,a,a,a,a}; double xu[9] = { b,b,b,b,b,b,b,b,b}; gsl_monte_function G = { &f, dim, 0 }; size_t calls =1e6*dim; gsl_rng_env_setup (); gsl_rng *r = gsl_rng_alloc (gsl_rng_taus2); gsl_rng_set (r, 30776); gsl_monte_vegas_state *s = gsl_monte_vegas_alloc (dim); gsl_monte_vegas_integrate (&G, xl, xu, dim, 1e4, r, s, &res, &err); //display_results ("vegas warm-up", res, err,0); //printf ("converging...\n"); int i=0; do { gsl_monte_vegas_integrate (&G, xl, xu, dim, calls/5, r, s, &res, &err); //printf ("result = % .6f sigma = % .6f chisq/dof = %.1f\n", // res, err, gsl_monte_vegas_chisq (s)); i=i+1; } while (fabs (gsl_monte_vegas_chisq (s) - 1.0) > 0.5); display_results ("vegas final", res, err, i); gsl_monte_vegas_free (s); return 0; }
void mc_integrate1(gsl_monte_function *G, gsl_rng *r, double *xl, double *xu, double *_res,double *_err, MCConfig *config) { double res, err; size_t i; size_t calls = config->calls; gsl_monte_vegas_state *s = gsl_monte_vegas_alloc (G->dim); gsl_monte_vegas_integrate (G, xl, xu, G->dim, config->warmup, r, s, &res, &err); display_results ("vegas warm-up", res, err); fprintf(stderr,"converging...\n"); int tries=0; do { gsl_monte_vegas_integrate (G, xl, xu, G->dim, calls, r, s, &res, &err); fprintf(stderr,"result = %.4g sigma = %.4g " "chisq/dof = %.1f\n", res, err, s->chisq); } while (fabs(s->chisq - 1.0) > 0.5 && (tries++ < 10)); display_results ("vegas final", res, err); gsl_monte_vegas_free (s); *_res=res; *_err=err; }
double MCCalculatorSkewTriple::I(const double qx, const double qz, double & err) { static double result, abserr; m_qx = qx; m_qz = qz / m_sinPsi; result = 0.0; gsl_monte_vegas_init(m_mc_vegas_state); /*int gsl_monte_vegas_integrate (gsl_monte_function * f, const double xl[], const double xu[], size_t dim, size_t calls, gsl_rng * r, gsl_monte_vegas_state * s, double * result, double * abserr)*/ gsl_monte_vegas_integrate(&m_function, m_rl, m_ru, m_integral_dimension, m_nbCallsTotal, m_rng, m_mc_vegas_state, &result, &abserr); err = abserr; return result; }
int main (int argc, char *argv[]) { double ns; int i; int id; // process rank int p; // number of processes MPI_Init (&argc, &argv); MPI_Comm_rank (MPI_COMM_WORLD, &id); MPI_Comm_size (MPI_COMM_WORLD, &p); // neutron stars, pulsar to bulge double res_x,err_x; //double xl_x[4]={3.0,0.0,-1200.0,-1200.0}; //double xu_x[4]={13.0,13.0,1200.0,1200.0}; double xl_x[8]={3.0,0.0,-2000.0,-2000.0,-2000.0,-550.0,-450.0,-350.0}; double xu_x[8]={13.0,13.0,2000.0,2000.0,2000.0,550.0,450.0,350.0}; const gsl_rng_type *T_x; gsl_rng *r_x; gsl_monte_function G_x={&g_psr,8,0}; size_t calls_x=500000000; T_x=gsl_rng_default; // neutron stars, pulsar to disk double res_xd,err_xd; //double xl_x[4]={3.0,0.0,-2000.0,-2000.0}; //double xu_x[4]={13.0,13.0,2000.0,2000.0}; double xl_xd[8]={0.0,0.0,-2000.0,-2000.0,-2000.0,-100.0,-150.0,-100.0}; double xu_xd[8]={13.0,13.0,2000.0,2000.0,2000.0,100.0,150.0,100.0}; const gsl_rng_type *T_xd; gsl_rng *r_xd; gsl_monte_function G_xd={&g_psr_disk,8,0}; size_t calls_xd=500000000; T_xd=gsl_rng_default; //////////////////////////////////////////////////////////////////////////////////////////// // source double res_s,err_s; double xl_s[1]={3.0}; double xu_s[1]={13.0}; const gsl_rng_type *T_s; gsl_rng *r_s; gsl_monte_function G_s={&source,1,0}; size_t calls_s=500000000; T_s=gsl_rng_default; r_s = gsl_rng_alloc (T_s); gsl_monte_vegas_state *s_s = gsl_monte_vegas_alloc (1); gsl_monte_vegas_integrate (&G_s, xl_s, xu_s, 1, 10000, r_s, s_s, &res_s, &err_s); do { gsl_monte_vegas_integrate (&G_s, xl_s, xu_s, 1, calls_s/5, r_s, s_s, &res_s, &err_s); } while (fabs (gsl_monte_vegas_chisq (s_s) - 1.0) > 0.5); gsl_monte_vegas_free (s_s); gsl_rng_free (r_s); ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// // source disk double res_sd,err_sd; double xl_sd[1]={0.0}; double xu_sd[1]={13.0}; const gsl_rng_type *T_sd; gsl_rng *r_sd; gsl_monte_function G_sd={&source_disk,1,0}; size_t calls_sd=500000000; T_sd=gsl_rng_default; r_sd = gsl_rng_alloc (T_sd); gsl_monte_vegas_state *s_sd = gsl_monte_vegas_alloc (1); gsl_monte_vegas_integrate (&G_sd, xl_sd, xu_sd, 1, 10000, r_sd, s_sd, &res_sd, &err_sd); do { gsl_monte_vegas_integrate (&G_sd, xl_sd, xu_sd, 1, calls_sd/5, r_sd, s_sd, &res_sd, &err_sd); } while (fabs (gsl_monte_vegas_chisq (s_sd) - 1.0) > 0.5); gsl_monte_vegas_free (s_sd); gsl_rng_free (r_sd); ////////////////////////////////////////////////////////////////////////////////////////////////////// r_x=gsl_rng_alloc(T_x); gsl_monte_vegas_state *s_x = gsl_monte_vegas_alloc (8); r_xd=gsl_rng_alloc(T_xd); gsl_monte_vegas_state *s_xd = gsl_monte_vegas_alloc (8); // calculation for (i=id;i<=200;i+=p) { //t=pow(10.0,0.015*i); t=-0.5+0.0175*i; gsl_monte_vegas_integrate (&G_x, xl_x, xu_x, 8, 10000, r_x, s_x,&res_x, &err_x); do { gsl_monte_vegas_integrate (&G_x, xl_x, xu_x, 8, calls_x/5, r_x, s_x,&res_x, &err_x); } while (fabs (gsl_monte_vegas_chisq (s_x) - 1.0) > 0.5); ///////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////// gsl_monte_vegas_integrate (&G_xd, xl_xd, xu_xd, 8, 10000, r_xd, s_xd, &res_xd, &err_xd); // display_results ("vegas warm-up", res, err); // printf ("converging...\n"); do { gsl_monte_vegas_integrate (&G_xd, xl_xd, xu_xd, 8, calls_xd/5, r_xd, s_xd, &res_xd, &err_xd); //printf ("result = % .6ef sigma = % .6ef chisq/dof = %.1f\n", res, err, gsl_monte_vegas_chisq (s)); } while (fabs (gsl_monte_vegas_chisq (s_xd) - 1.0) > 0.5); // display_results ("vegas final", res, err); ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// ns = (fabs(res_x)+fabs(res_xd))/(fabs(res_s)+fabs(res_sd)); printf ("%e %e\n", t, ns); fflush(stdout); } gsl_monte_vegas_free (s_x); gsl_rng_free (r_x); gsl_monte_vegas_free (s_xd); gsl_rng_free (r_xd); fflush (stdout); MPI_Finalize (); return 0; }
int main (void) { double bd,ms,wd,ns,bh; // mfunc double res,err; double xl[1]={0.03}; double xu[1]={120.0}; const gsl_rng_type *T; gsl_rng *r; gsl_monte_function G={&g_x,1,0}; size_t calls=50000000; gsl_rng_env_setup (); T=gsl_rng_default; // mfunc: ns double resn,errn; double xln[1]={8.0}; double xun[1]={40.0}; const gsl_rng_type *Tn; gsl_rng *rn; gsl_monte_function Gn={&g_x,1,0}; size_t callsn=50000000; Tn=gsl_rng_default; // mfunc: bd double resbd,errbd; double xlbd[1]={0.03}; double xubd[1]={0.08}; const gsl_rng_type *Tbd; gsl_rng *rbd; gsl_monte_function Gbd={&g_x,1,0}; size_t callsbd=50000000; Tbd=gsl_rng_default; // mfunc: ms double resms,errms; double xlms[1]={0.08}; double xums[1]={1.0}; const gsl_rng_type *Tms; gsl_rng *rms; gsl_monte_function Gms={&g_x,1,0}; size_t callsms=50000000; Tms=gsl_rng_default; // mfunc: wd double reswd,errwd; double xlwd[1]={1.0}; double xuwd[1]={8.0}; const gsl_rng_type *Twd; gsl_rng *rwd; gsl_monte_function Gwd={&g_x,1,0}; size_t callswd=50000000; Twd=gsl_rng_default; // mfunc: bh double resbh,errbh; double xlbh[1]={40.0}; double xubh[1]={120.0}; const gsl_rng_type *Tbh; gsl_rng *rbh; gsl_monte_function Gbh={&g_x,1,0}; size_t callsbh=50000000; Tbh=gsl_rng_default; ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// // calculation mfunc r = gsl_rng_alloc (T); gsl_monte_vegas_state *s = gsl_monte_vegas_alloc (1); gsl_monte_vegas_integrate (&G, xl, xu, 1, 10000, r, s, &res, &err); do { gsl_monte_vegas_integrate (&G, xl, xu, 1, calls/5, r, s,&res, &err); } while (fabs (gsl_monte_vegas_chisq (s) - 1.0) > 0.5); ////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////// rn = gsl_rng_alloc (Tn); gsl_monte_vegas_state *sn = gsl_monte_vegas_alloc (1); gsl_monte_vegas_integrate (&Gn, xln, xun, 1, 10000, rn, sn, &resn, &errn); do { gsl_monte_vegas_integrate (&Gn, xln, xun, 1, callsn/5, rn, sn, &resn, &errn); } while (fabs (gsl_monte_vegas_chisq (sn) - 1.0) > 0.5); ////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////// rbd = gsl_rng_alloc (Tbd); gsl_monte_vegas_state *sbd = gsl_monte_vegas_alloc (1); gsl_monte_vegas_integrate (&Gbd, xlbd, xubd, 1, 10000, rbd, sbd, &resbd, &errbd); do { gsl_monte_vegas_integrate (&Gbd, xlbd, xubd, 1, callsbd/5, rbd, sbd, &resbd, &errbd); } while (fabs (gsl_monte_vegas_chisq (sbd) - 1.0) > 0.5); ////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////// rms = gsl_rng_alloc (Tms); gsl_monte_vegas_state *sms = gsl_monte_vegas_alloc (1); gsl_monte_vegas_integrate (&Gms, xlms, xums, 1, 10000, rms, sms, &resms, &errms); do { gsl_monte_vegas_integrate (&Gms, xlms, xums, 1, callsms/5, rms, sms, &resms, &errms); } while (fabs (gsl_monte_vegas_chisq (sms) - 1.0) > 0.5); ////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////// rwd = gsl_rng_alloc (Twd); gsl_monte_vegas_state *swd = gsl_monte_vegas_alloc (1); gsl_monte_vegas_integrate (&Gwd, xlwd, xuwd, 1, 10000, rwd, swd, &reswd, &errwd); do { gsl_monte_vegas_integrate (&Gwd, xlwd, xuwd, 1, callswd/5, rwd, swd, &reswd, &errwd); } while (fabs (gsl_monte_vegas_chisq (swd) - 1.0) > 0.5); ////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////// rbh = gsl_rng_alloc (Tbh); gsl_monte_vegas_state *sbh = gsl_monte_vegas_alloc (1); gsl_monte_vegas_integrate (&Gbh, xlbh, xubh, 1, 10000, rbh, sbh, &resbh, &errbh); do { gsl_monte_vegas_integrate (&Gbh, xlbh, xubh, 1, callsbh/5, rbh, sbh, &resbh, &errbh); } while (fabs (gsl_monte_vegas_chisq (sbh) - 1.0) > 0.5); ////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////// ns = resn/res; bd = resbd/res; ms = resms/res; wd = reswd/res; bh = resbh/res; printf ("ns: %e\n", ns); printf ("bd: %e\n", bd); printf ("ms: %e\n", ms); printf ("wd: %e\n", wd); printf ("bh: %e\n", bh); fflush(stdout); gsl_monte_vegas_free (s); gsl_rng_free (r); gsl_monte_vegas_free (sn); gsl_rng_free (rn); gsl_monte_vegas_free (sbd); gsl_rng_free (rbd); gsl_monte_vegas_free (sms); gsl_rng_free (rms); gsl_monte_vegas_free (swd); gsl_rng_free (rwd); gsl_monte_vegas_free (sbh); gsl_rng_free (rbh); return 0; }
int main (int argc, char *argv[]) { double timescale,re,event; // neutron stars, pulsar to bulge double res_x,err_x; //double xl_x[4]={3.0,0.0,-1200.0,-1200.0}; //double xu_x[4]={13.0,13.0,1200.0,1200.0}; double xl_x[8]={4.5,0.0,-2000.0,-2000.0,-2000.0,-550.0,-450.0,-350.0}; double xu_x[8]={11.5,11.5,2000.0,2000.0,2000.0,550.0,450.0,350.0}; const gsl_rng_type *T_x; gsl_rng *r_x; gsl_monte_function G_x={&g_psr,8,0}; size_t calls_x=50000000; gsl_rng_env_setup (); T_x=gsl_rng_default; // neutron stars, pulsar to disk double res_xd,err_xd; //double xl_x[4]={3.0,0.0,-2000.0,-2000.0}; //double xu_x[4]={13.0,13.0,2000.0,2000.0}; double xl_xd[8]={0.0,0.0,-2000.0,-2000.0,-2000.0,-100.0,-150.0,-100.0}; double xu_xd[8]={11.5,11.5,2000.0,2000.0,2000.0,100.0,150.0,100.0}; const gsl_rng_type *T_xd; gsl_rng *r_xd; gsl_monte_function G_xd={&g_psr_disk,8,0}; size_t calls_xd=50000000; T_xd=gsl_rng_default; //////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////// r_x=gsl_rng_alloc(T_x); gsl_monte_vegas_state *s_x = gsl_monte_vegas_alloc (8); r_xd=gsl_rng_alloc(T_xd); gsl_monte_vegas_state *s_xd = gsl_monte_vegas_alloc (8); ////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////// // timescale, re/v // neutron stars, pulsar to bulge double res_xr,err_xr; //double xl_x[4]={3.0,0.0,-1200.0,-1200.0}; //double xu_x[4]={13.0,13.0,1200.0,1200.0}; double xl_xr[8]={4.5,0.0,-2000.0,-2000.0,-2000.0,-550.0,-450.0,-350.0}; double xu_xr[8]={11.5,11.5,2000.0,2000.0,2000.0,550.0,450.0,350.0}; const gsl_rng_type *T_xr; gsl_rng *r_xr; gsl_monte_function G_xr={&g_psrr,8,0}; size_t calls_xr=50000000; T_xr=gsl_rng_default; // neutron stars, pulsar to disk double res_xdr,err_xdr; //double xl_x[4]={3.0,0.0,-2000.0,-2000.0}; //double xu_x[4]={13.0,13.0,2000.0,2000.0}; double xl_xdr[8]={0.0,0.0,-2000.0,-2000.0,-2000.0,-100.0,-150.0,-100.0}; double xu_xdr[8]={11.5,11.5,2000.0,2000.0,2000.0,100.0,150.0,100.0}; const gsl_rng_type *T_xdr; gsl_rng *r_xdr; gsl_monte_function G_xdr={&g_psr_diskr,8,0}; size_t calls_xdr=50000000; T_xdr=gsl_rng_default; //////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////// r_xr=gsl_rng_alloc(T_xr); gsl_monte_vegas_state *s_xr = gsl_monte_vegas_alloc (8); r_xdr=gsl_rng_alloc(T_xdr); gsl_monte_vegas_state *s_xdr = gsl_monte_vegas_alloc (8); ////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////// // calculation gsl_monte_vegas_integrate (&G_x, xl_x, xu_x, 8, 10000, r_x, s_x,&res_x, &err_x); do { gsl_monte_vegas_integrate (&G_x, xl_x, xu_x, 8, calls_x/5, r_x, s_x,&res_x, &err_x); } while (fabs (gsl_monte_vegas_chisq (s_x) - 1.0) > 0.5); ///////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////// gsl_monte_vegas_integrate (&G_xd, xl_xd, xu_xd, 8, 10000, r_xd, s_xd, &res_xd, &err_xd); do { gsl_monte_vegas_integrate (&G_xd, xl_xd, xu_xd, 8, calls_xd/5, r_xd, s_xd, &res_xd, &err_xd); } while (fabs (gsl_monte_vegas_chisq (s_xd) - 1.0) > 0.5); ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// // timescale, re/v gsl_monte_vegas_integrate (&G_xr, xl_xr, xu_xr, 8, 10000, r_xr, s_xr, &res_xr, &err_xr); do { gsl_monte_vegas_integrate (&G_xr, xl_xr, xu_xr, 8, calls_xr/5, r_xr, s_xr,&res_xr, &err_xr); } while (fabs (gsl_monte_vegas_chisq (s_xr) - 1.0) > 0.5); ///////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////// gsl_monte_vegas_integrate (&G_xdr, xl_xdr, xu_xdr, 8, 10000, r_xdr, s_xdr, &res_xdr, &err_xdr); do { gsl_monte_vegas_integrate (&G_xdr, xl_xdr, xu_xdr, 8, calls_xdr/5, r_xdr, s_xdr, &res_xdr, &err_xdr); } while (fabs (gsl_monte_vegas_chisq (s_xdr) - 1.0) > 0.5); ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// re = res_xr+res_xdr; event = res_x+res_xd; timescale = re/event; printf ("%e %e %e\n", l, b, timescale); gsl_monte_vegas_free (s_x); gsl_rng_free (r_x); gsl_monte_vegas_free (s_xd); gsl_rng_free (r_xd); ///////////////////////////////////////////////////////////////////////////////////////////////// gsl_monte_vegas_free (s_xr); gsl_rng_free (r_xr); gsl_monte_vegas_free (s_xdr); gsl_rng_free (r_xdr); return 0; }
int main (int argc, char *argv[]) { double ratio,ns; // neutron stars, pulsar to bulge double res_x,err_x; double xl_x[8]={4.5,0.0,-2000.0,-2000.0,-2000.0,-550.0,-450.0,-350.0}; double xu_x[8]={11.5,11.5,2000.0,2000.0,2000.0,550.0,450.0,350.0}; const gsl_rng_type *T_x; gsl_rng *r_x; gsl_monte_function G_x={&g_psr,8,0}; size_t calls_x=5000000; gsl_rng_env_setup (); T_x=gsl_rng_default; // neutron stars, pulsar to disk double res_xd,err_xd; double xl_xd[8]={0.0,0.0,-2000.0,-2000.0,-2000.0,-100.0,-150.0,-100.0}; double xu_xd[8]={11.5,11.5,2000.0,2000.0,2000.0,100.0,150.0,100.0}; const gsl_rng_type *T_xd; gsl_rng *r_xd; gsl_monte_function G_xd={&g_psr_disk,8,0}; size_t calls_xd=5000000; T_xd=gsl_rng_default; //////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////// // source bulge double res_s,err_s; double xl_s[1]={4.5}; double xu_s[1]={11.5}; const gsl_rng_type *T_s; gsl_rng *r_s; gsl_monte_function G_s={&source,1,0}; size_t calls_s=5000000; T_s=gsl_rng_default; r_s = gsl_rng_alloc (T_s); gsl_monte_vegas_state *s_s = gsl_monte_vegas_alloc (1); gsl_monte_vegas_integrate (&G_s, xl_s, xu_s, 1, 10000, r_s, s_s, &res_s, &err_s); do { gsl_monte_vegas_integrate (&G_s, xl_s, xu_s, 1, calls_s/5, r_s, s_s, &res_s, &err_s); } while (fabs (gsl_monte_vegas_chisq (s_s) - 1.0) > 0.5); gsl_monte_vegas_free (s_s); gsl_rng_free (r_s); ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// // source disk double res_sd,err_sd; double xl_sd[1]={0.0}; double xu_sd[1]={11.5}; const gsl_rng_type *T_sd; gsl_rng *r_sd; gsl_monte_function G_sd={&source_d,1,0}; size_t calls_sd=5000000; T_sd=gsl_rng_default; r_sd = gsl_rng_alloc (T_sd); gsl_monte_vegas_state *s_sd = gsl_monte_vegas_alloc (1); gsl_monte_vegas_integrate (&G_sd, xl_sd, xu_sd, 1, 10000, r_sd, s_sd, &res_sd, &err_sd); do { gsl_monte_vegas_integrate (&G_sd, xl_sd, xu_sd, 1, calls_sd/5, r_sd, s_sd, &res_sd, &err_sd); } while (fabs (gsl_monte_vegas_chisq (s_sd) - 1.0) > 0.5); gsl_monte_vegas_free (s_sd); gsl_rng_free (r_sd); ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// r_x=gsl_rng_alloc(T_x); gsl_monte_vegas_state *s_x = gsl_monte_vegas_alloc (8); r_xd=gsl_rng_alloc(T_xd); gsl_monte_vegas_state *s_xd = gsl_monte_vegas_alloc (8); // calculation gsl_monte_vegas_integrate (&G_x, xl_x, xu_x, 8, 10000, r_x, s_x,&res_x, &err_x); do { gsl_monte_vegas_integrate (&G_x, xl_x, xu_x, 8, calls_x/5, r_x, s_x,&res_x, &err_x); } while (fabs (gsl_monte_vegas_chisq (s_x) - 1.0) > 0.5); ///////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////// gsl_monte_vegas_integrate (&G_xd, xl_xd, xu_xd, 8, 10000, r_xd, s_xd, &res_xd, &err_xd); do { gsl_monte_vegas_integrate (&G_xd, xl_xd, xu_xd, 8, calls_xd/5, r_xd, s_xd, &res_xd, &err_xd); } while (fabs (gsl_monte_vegas_chisq (s_xd) - 1.0) > 0.5); ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// ns = res_x+res_xd; ratio = ns/(res_s+res_sd); printf ("%e\n", ratio); gsl_monte_vegas_free (s_x); gsl_rng_free (r_x); gsl_monte_vegas_free (s_xd); gsl_rng_free (r_xd); return 0; }
int main (int argc, char *argv[]) { double psr; // source double res_s,err_s; double xl_s[3]={4.5,0.0,-3.1415926/2.0}; double xu_s[3]={11.5,2.0*3.1415926,3.1415926/2.0}; const gsl_rng_type *T_s; gsl_rng *r_s; gsl_monte_function G_s={&source,3,0}; size_t calls_s=50000000; gsl_rng_env_setup (); T_s=gsl_rng_default; r_s = gsl_rng_alloc (T_s); gsl_monte_vegas_state *s_s = gsl_monte_vegas_alloc (3); gsl_monte_vegas_integrate (&G_s, xl_s, xu_s, 3, 10000, r_s, s_s, &res_s, &err_s); do { gsl_monte_vegas_integrate (&G_s, xl_s, xu_s, 3, calls_s/5, r_s, s_s, &res_s, &err_s); } while (fabs (gsl_monte_vegas_chisq (s_s) - 1.0) > 0.5); gsl_monte_vegas_free (s_s); gsl_rng_free (r_s); ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// // neutron stars, pulsar to disk double res_x,err_x; //double xl_x[4]={3.0,0.0,-1200.0,-1200.0}; //double xu_x[4]={13.0,13.0,1200.0,1200.0}; double xl_x[10]={4.5,0.01,-2000.0,-2000.0,-2000.0,-550.0,-450.0,-350.0,0.0,-3.1415926/2.0}; double xu_x[10]={11.5,8.0,2000.0,2000.0,2000.0,550.0,450.0,350.0,2.0*3.1415926,3.1415926/2.0}; const gsl_rng_type *T_x; gsl_rng *r_x; gsl_monte_function G_x={&g_psr,10,0}; size_t calls_x=50000000; T_x=gsl_rng_default; // calculation r_x=gsl_rng_alloc(T_x); gsl_monte_vegas_state *s_x = gsl_monte_vegas_alloc (10); gsl_monte_vegas_integrate (&G_x, xl_x, xu_x, 10, 10000, r_x, s_x,&res_x, &err_x); do { gsl_monte_vegas_integrate (&G_x, xl_x, xu_x, 10, calls_x/5, r_x, s_x,&res_x, &err_x); } while (fabs (gsl_monte_vegas_chisq (s_x) - 1.0) > 0.5); ///////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////// psr = fabs(res_x)/fabs(res_s); printf ("psr event rate:%e %e %e\n", res_x, res_s, psr); //printf ("psr event rate: %e\n", psr); gsl_monte_vegas_free (s_x); gsl_rng_free (r_x); return 0; }
int main (void) { double res, err; double xl[3] = { 0, 0, 0 }; double xu[3] = { M_PI, M_PI, M_PI }; const gsl_rng_type *T; gsl_rng *r; gsl_monte_function G = { &g, 3, 0 }; size_t calls = 500000; gsl_rng_env_setup (); T = gsl_rng_default; r = gsl_rng_alloc (T); { gsl_monte_plain_state *s = gsl_monte_plain_alloc (3); gsl_monte_plain_integrate (&G, xl, xu, 3, calls, r, s, &res, &err); gsl_monte_plain_free (s); display_results ("plain", res, err); } { gsl_monte_miser_state *s = gsl_monte_miser_alloc (3); gsl_monte_miser_integrate (&G, xl, xu, 3, calls, r, s, &res, &err); gsl_monte_miser_free (s); display_results ("miser", res, err); } { gsl_monte_vegas_state *s = gsl_monte_vegas_alloc (3); gsl_monte_vegas_integrate (&G, xl, xu, 3, 10000, r, s, &res, &err); display_results ("vegas warm-up", res, err); printf ("converging...\n"); do { gsl_monte_vegas_integrate (&G, xl, xu, 3, calls/5, r, s, &res, &err); printf ("result = % .6f sigma = % .6f " "chisq/dof = %.1f\n", res, err, gsl_monte_vegas_chisq (s)); } while (fabs (gsl_monte_vegas_chisq (s) - 1.0) > 0.5); display_results ("vegas final", res, err); gsl_monte_vegas_free (s); } gsl_rng_free (r); return 0; }
int main (void) { //double bd,ms,wd,ns,bh; // mfunc double res,err; double xl[1]={0.03}; double xu[1]={120.0}; const gsl_rng_type *T; gsl_rng *r; gsl_monte_function G={&g_x,1,0}; size_t calls=5000000; gsl_rng_env_setup (); T=gsl_rng_default; // mfunc: ns double resn,errn; double xln[1]={8.0}; double xun[1]={40.0}; const gsl_rng_type *Tn; gsl_rng *rn; gsl_monte_function Gn={&g,1,0}; //gsl_monte_function Gn={&g_x,1,0}; size_t callsn=5000000; Tn=gsl_rng_default; ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// // calculation mfunc r = gsl_rng_alloc (T); gsl_monte_vegas_state *s = gsl_monte_vegas_alloc (1); gsl_monte_vegas_integrate (&G, xl, xu, 1, 10000, r, s, &res, &err); do { gsl_monte_vegas_integrate (&G, xl, xu, 1, calls/5, r, s,&res, &err); } while (fabs (gsl_monte_vegas_chisq (s) - 1.0) > 0.5); ////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////// rn = gsl_rng_alloc (Tn); gsl_monte_vegas_state *sn = gsl_monte_vegas_alloc (1); gsl_monte_vegas_integrate (&Gn, xln, xun, 1, 10000, rn, sn, &resn, &errn); do { gsl_monte_vegas_integrate (&Gn, xln, xun, 1, callsn/5, rn, sn, &resn, &errn); } while (fabs (gsl_monte_vegas_chisq (sn) - 1.0) > 0.5); ////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////// //ns = resn/res; printf ("resn: %e\n", resn); printf ("res: %e\n", res); fflush(stdout); gsl_monte_vegas_free (s); gsl_rng_free (r); gsl_monte_vegas_free (sn); gsl_rng_free (rn); return 0; }
int main (int argc, char *argv[]) { double psr; // source bulge double res_s,err_s; double xl_s[1]={4.5}; double xu_s[1]={11.5}; const gsl_rng_type *T_s; gsl_rng *r_s; gsl_monte_function G_s={&source,1,0}; size_t calls_s=50000000; gsl_rng_env_setup (); T_s=gsl_rng_default; r_s = gsl_rng_alloc (T_s); gsl_monte_vegas_state *s_s = gsl_monte_vegas_alloc (1); gsl_monte_vegas_integrate (&G_s, xl_s, xu_s, 1, 10000, r_s, s_s, &res_s, &err_s); do { gsl_monte_vegas_integrate (&G_s, xl_s, xu_s, 1, calls_s/5, r_s, s_s, &res_s, &err_s); } while (fabs (gsl_monte_vegas_chisq (s_s) - 1.0) > 0.5); gsl_monte_vegas_free (s_s); gsl_rng_free (r_s); ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// // neutron stars, pulsar to bulge double res_x,err_x; //double xl_x[4]={3.0,0.0,-1200.0,-1200.0}; //double xu_x[4]={13.0,13.0,1200.0,1200.0}; double xl_x[8]={4.5,0.01,-2000.0,-2000.0,-2000.0,-550.0,-450.0,-350.0}; double xu_x[8]={11.5,8.0,2000.0,2000.0,2000.0,550.0,450.0,350.0}; const gsl_rng_type *T_x; gsl_rng *r_x; gsl_monte_function G_x={&g_psr,8,0}; size_t calls_x=50000000; T_x=gsl_rng_default; // calculation r_x=gsl_rng_alloc(T_x); gsl_monte_vegas_state *s_x = gsl_monte_vegas_alloc (8); gsl_monte_vegas_integrate (&G_x, xl_x, xu_x, 8, 10000, r_x, s_x,&res_x, &err_x); do { gsl_monte_vegas_integrate (&G_x, xl_x, xu_x, 8, calls_x/5, r_x, s_x,&res_x, &err_x); } while (fabs (gsl_monte_vegas_chisq (s_x) - 1.0) > 0.5); ///////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////// // source disk double res_sd,err_sd; double xl_sd[1]={0.0}; double xu_sd[1]={11.5}; const gsl_rng_type *T_sd; gsl_rng *r_sd; gsl_monte_function G_sd={&source_d,1,0}; size_t calls_sd=50000000; T_sd=gsl_rng_default; r_sd = gsl_rng_alloc (T_sd); gsl_monte_vegas_state *s_sd = gsl_monte_vegas_alloc (1); gsl_monte_vegas_integrate (&G_sd, xl_sd, xu_sd, 1, 10000, r_sd, s_sd, &res_sd, &err_sd); do { gsl_monte_vegas_integrate (&G_sd, xl_sd, xu_sd, 1, calls_sd/5, r_sd, s_sd, &res_sd, &err_sd); } while (fabs (gsl_monte_vegas_chisq (s_sd) - 1.0) > 0.5); gsl_monte_vegas_free (s_sd); gsl_rng_free (r_sd); ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// // neutron stars, pulsar to disk double res_xd,err_xd; //double xl_x[4]={3.0,0.0,-1200.0,-1200.0}; //double xu_x[4]={13.0,13.0,1200.0,1200.0}; double xl_xd[8]={0.0,0.01,-2000.0,-2000.0,-2000.0,-100.0,-150.0,-100.0}; double xu_xd[8]={11.5,8.0,2000.0,2000.0,2000.0,100.0,150.0,100.0}; const gsl_rng_type *T_xd; gsl_rng *r_xd; gsl_monte_function G_xd={&g_psr_d,8,0}; size_t calls_xd=50000000; T_xd=gsl_rng_default; // calculation r_xd=gsl_rng_alloc(T_xd); gsl_monte_vegas_state *s_xd = gsl_monte_vegas_alloc (8); gsl_monte_vegas_integrate (&G_xd, xl_xd, xu_xd, 8, 10000, r_xd, s_xd, &res_xd, &err_xd); do { gsl_monte_vegas_integrate (&G_xd, xl_xd, xu_xd, 8, calls_xd/5, r_xd, s_xd, &res_xd, &err_xd); } while (fabs (gsl_monte_vegas_chisq (s_xd) - 1.0) > 0.5); ///////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////// psr = (fabs(res_x)+fabs(res_xd))/(fabs(res_s)+fabs(res_sd)); printf ("bulge:%e %e %e\n", res_x, res_s, res_x/res_s); printf ("disk:%e %e %e\n", res_xd, res_sd, res_xd/res_sd); printf ("psr event rate:%e\n", psr); //printf ("psr event rate: %e\n", psr); gsl_monte_vegas_free (s_x); gsl_rng_free (r_x); gsl_monte_vegas_free (s_xd); gsl_rng_free (r_xd); return 0; }
void mc_dual_integrate(gsl_monte_function *G, gsl_monte_function *F, gsl_rng *r, double *_res1,double *_err1, double *_res2,double *_err2, MCConfig *config) { double res, err; size_t i; double *xl = (double*)malloc(G->dim*sizeof(double)); double *xu = (double*)malloc(G->dim*sizeof(double)); for (i=0;i<G->dim;i++) { xl[i]=0.00001; xu[i]=1.0; } size_t calls = config->calls; gsl_monte_vegas_state *s = gsl_monte_vegas_alloc (G->dim); gsl_monte_vegas_integrate (G, xl, xu, G->dim, config->warmup, r, s, &res, &err); display_results ("vegas warm-up", res, err); fprintf(stderr,"converging...\n"); int tries=0; do { gsl_monte_vegas_integrate (G, xl, xu, G->dim, calls, r, s, &res, &err); fprintf(stderr,"A: result = %.4g sigma = %.4g " "chisq/dof = %.1f\n", res, err, s->chisq); } while (fabs(s->chisq - 1.0) > 0.5 && (tries++ < 10)); display_results ("A: vegas final", res, err); *_res1=res; *_err1=err; s->stage=1; do { gsl_monte_vegas_integrate (F, xl, xu, G->dim, calls, r, s, &res, &err); fprintf(stderr,"B: result = %.4g sigma = %.4g " "chisq/dof = %.1f\n", res, err, s->chisq); } while (fabs(s->chisq - 1.0) > 0.5 && (tries++ < 10)); display_results ("B: vegas final", res, err); *_res2=res; *_err2=err; gsl_monte_vegas_free (s); free(xl); free(xu); }