int main (int argc, char *argv[])
{
double ratio,ns;
// 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[10]={4.5,0.0,-2000.0,-2000.0,-2000.0,-550.0,-450.0,-350.0,-3.1415926, -0.5*3.1415926};
double xl_x[10]={4.5,0.0,-2000.0,-2000.0,-2000.0,-550.0,-450.0,-350.0,0.0001, -0.5*3.1415926};
double xu_x[10]={11.5,11.5,2000.0,2000.0,2000.0,550.0,450.0,350.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;
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[10]={0.0,0.0,-2000.0,-2000.0,-2000.0,-100.0,-150.0,-100.0,-3.1415926, -3.1415926/2.0};
double xl_xd[10]={0.0,0.0,-2000.0,-2000.0,-2000.0,-100.0,-150.0,-100.0,0.0001, -3.1415926/2.0};
double xu_xd[10]={11.5,11.5,2000.0,2000.0,2000.0,100.0,150.0,100.0,3.1415926, 3.1415926/2.0};
const gsl_rng_type *T_xd;
gsl_rng *r_xd;
gsl_monte_function G_xd={&g_psr_disk,10,0};
size_t calls_xd=50000000;
T_xd=gsl_rng_default;
////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
// source bulge
double res_s,err_s;
double xl_s[3]={4.5,-3.1415926, -3.1415926/2.0};
double xu_s[3]={11.5,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;
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);
//////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
// source disk
double res_sd,err_sd;
double xl_sd[3]={0.0,-3.1415926, -3.1415926/2.0};
double xu_sd[3]={11.5,3.1415926, 3.1415926/2.0};
const gsl_rng_type *T_sd;
gsl_rng *r_sd;
gsl_monte_function G_sd={&source_d,3,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 (3);
gsl_monte_vegas_integrate (&G_sd, xl_sd, xu_sd, 3, 10000, r_sd, s_sd, &res_sd, &err_sd);
do
{
gsl_monte_vegas_integrate (&G_sd, xl_sd, xu_sd, 3, 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 (10);
r_xd=gsl_rng_alloc(T_xd);
gsl_monte_vegas_state *s_xd = gsl_monte_vegas_alloc (10);
// calculation
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);
/////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
gsl_monte_vegas_integrate (&G_xd, xl_xd, xu_xd, 10, 10000, r_xd, s_xd, &res_xd, &err_xd);
do
{
gsl_monte_vegas_integrate (&G_xd, xl_xd, xu_xd, 10, 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;
}
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);
}
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=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 ratio;
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,-2000.0,-2000.0};
//double xu_x[4]={13.0,13.0,2000.0,2000.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=5000000;
gsl_rng_env_setup ();
T_x=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=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);
//////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
// 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=5000000;
T_xd=gsl_rng_default;
// 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=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);
//////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
// calculation
for (i=id;i<=200.0;i+=p)
{
//t=pow(10.0,0.015*i);
t=-0.5+0.0175*i;
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);
// display_results ("vegas warm-up", res, err);
// printf ("converging...\n");
do
{
gsl_monte_vegas_integrate (&G_x, xl_x, xu_x, 8, calls_x/5, r_x, s_x,&res_x, &err_x);
//printf ("result = % .6ef sigma = % .6ef chisq/dof = %.1f\n", res, err, gsl_monte_vegas_chisq (s));
}
while (fabs (gsl_monte_vegas_chisq (s_x) - 1.0) > 0.5);
// display_results ("vegas final", res, err);
//////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
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);
// 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);
//////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
ratio = fabs(res_x)/fabs(res_s)+fabs(res_xd)/fabs(res_sd);
printf ("%e %e\n", t,ratio);
fflush(stdout);
gsl_monte_vegas_free (s_x);
gsl_rng_free (r_x);
gsl_monte_vegas_free (s_xd);
gsl_rng_free (r_xd);
}
//printf ("Process %d is done\n", id);
fflush (stdout);
MPI_Finalize ();
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;
}
