MfCumulative::MfCumulative(Sigma* const s, const double a) :
n(1001)
{
M_array= (double*) malloc(sizeof(double)*n*2); assert(M_array);
nM_array= M_array + n;
rho_m= cosmology_rho_m();
const double z= 1.0/a - 1.0;
MF* const mf= mf_alloc();
mf_set_redshift(mf, a);
const double D= growth_D(a);
MfcParams params;
params.mf= mf;
params.s= s;
params.D= D;
gsl_integration_cquad_workspace* const w=
gsl_integration_cquad_workspace_alloc(100);
gsl_function F;
F.function= &integrand_n_cumulative;
F.params= (void*) ¶ms;
const double logMmin= log(s->M_min);
const double logMmax= log(s->M_max);
const double nu_min= delta_c*s->sinv_min;
const double nu_max= delta_c*s->sinv_max;
for(int i=0; i<n; ++i) {
double MM= exp(logMmin + (n-i-1)*(logMmax - logMmin)/(n-1));
M_array[i]= MM;
double nu= delta_c/D*s->sigma0_inv(MM); assert(nu >= nu_min);
double result;
gsl_integration_cquad(&F, 1.0e-8, nu_max, 1.0e-5, 1.0e-5, w, &result, 0, 0);
nM_array[i]= result;
}
nM_max= nM_array[n-1];
interp= gsl_interp_alloc(gsl_interp_cspline, n);
acc= gsl_interp_accel_alloc();
//gsl_interp_init(interp, M_array, nM_array, n);
gsl_interp_init(interp, nM_array, M_array, n);
gsl_integration_cquad_workspace_free(w);
mf_free(mf);
}
PetscReal ct_integrand(PetscReal mu_local, void * int_params)
{
struct int_params * iparams = (struct int_params *)int_params;
size_t neval;
PetscReal a,b,abserr,result_coul;
gsl_function F;
iparams->mu1 = mu_local;
a =-1.0;
b = 1.0;
F.function = &ct_function;
F.params = iparams;
gsl_integration_cquad_workspace *work = gsl_integration_cquad_workspace_alloc(iparams->N_work);
gsl_integration_cquad(&F,a,b,iparams->epsabs,iparams->epsrel,work,&result_coul,&abserr,&neval);
gsl_integration_cquad_workspace_free(work);
return result_coul;
}
double IntegrandCC_ndiag ( const double x, void *userdata)
{ // for non-diagonal part, we eliminate one integration over k using delta(E)
const std::complex<double> I(0,1);
CInfPass_SBECC *cubpass=static_cast<CInfPass_SBECC*>(userdata);
cubpass->arr[9]=x; //theta_ka
int flag =(int)cubpass->arr[7];
double kmin=0.0; double kmax=3e9;
double res, abserr, fval=0.0; size_t neval;
gsl_integration_cquad_workspace *ws = NULL ;
if ( ( ws = gsl_integration_cquad_workspace_alloc( 200 ) ) == NULL )
{
printf( "call to gsl_integration_cquad_workspace_alloc failed.\n" );
abort();
}
gsl_function F;
F.params = cubpass;
switch (flag)
{
case 1:
F.function = &Integrand1d_cquadn1;
gsl_integration_cquad(&F, kmin,kmax,0, 5e-3, ws, &res, &abserr, &neval);
fval=res;
break;
case 2:
F.function = &Integrand1d_cquadn2;
gsl_integration_cquad(&F, kmin,kmax,0, 5e-3, ws, &res, &abserr, &neval);
fval=res;
break;
case 3:
F.function = &Integrand1d_cquadn3;
gsl_integration_cquad(&F, kmin,kmax,0, 5e-3, ws, &res, &abserr, &neval);
fval=res;
break;
case 4:
F.function = &Integrand1d_cquadn4;
gsl_integration_cquad(&F, kmin,kmax,0, 5e-3, ws, &res, &abserr, &neval);
fval=res;
break;
case 5:
F.function = &Integrand1d_cquadn5;
gsl_integration_cquad(&F, kmin,kmax,0, 5e-3, ws, &res, &abserr, &neval);
fval=res;
break;
case 6:
F.function = &Integrand1d_cquadn6;
gsl_integration_cquad(&F, kmin,kmax,0, 5e-3, ws, &res, &abserr, &neval);
fval=res;
break;
default:
printf( "type illegal !" );
}
gsl_integration_cquad_workspace_free( ws);
return fval;
}
int IntegrandCC2d_diag(unsigned ndim, const double *x, void *fdata, unsigned fdim, double *fval)
{ // for diagonal part, we eliminate one integration over theta using delta(E)
const std::complex<double> I(0,1);
std::complex<double> K4, QD;
double k4,qD,Ek1,Ek4;
CInfPass_SBECC *cubpass=static_cast<CInfPass_SBECC*>(fdata);
double K1 =cubpass->arr[0];
int flag =(int)cubpass->arr[7];
cubpass->arr[8]=x[0];//qD
cubpass->arr[9]=x[1];//theta
qD= x[0];
QD= qD*exp(I*x[1]);
K4 = K1 - QD;
k4= std::abs(K4);
if(flag==1||flag==3)
{ // Ek1,Ek4->c
Ek1= cubpass->gPPEc.interp(K1);
Ek4= cubpass->gPPEc.interp(k4);
}
else
{ // Ek1,Ek4->v
Ek1= cubpass->gPPEv.interp(K1);
Ek4= cubpass->gPPEv.interp(k4);
}
double k2min=0.0; double k2max=3e9;
double res, abserr; size_t neval;
gsl_integration_cquad_workspace *ws = NULL ;
if ( ( ws = gsl_integration_cquad_workspace_alloc( 200 ) ) == NULL )
{
printf( "call to gsl_integration_cquad_workspace_alloc failed.\n" );
abort();
}
gsl_function F;
F.params = cubpass;
switch (flag)
{
case 1:
F.function = &Integrand1d_cquad1;
gsl_integration_cquad(&F, k2min,k2max,0, 1e-3, ws, &res, &abserr, &neval);
fval[0]=res;
break;
case 2:
F.function = &Integrand1d_cquad2;
gsl_integration_cquad(&F, k2min,k2max,0, 1e-3, ws, &res, &abserr, &neval);
fval[0]=res;
break;
case 3:
F.function = &Integrand1d_cquad3;
gsl_integration_cquad(&F, k2min,k2max,0, 1e-3, ws, &res, &abserr, &neval);
fval[0]=res;
break;
case 4:
F.function = &Integrand1d_cquad4;
gsl_integration_cquad(&F, k2min,k2max,0, 1e-3, ws, &res, &abserr, &neval);
fval[0]=res;
break;
default: //debugging by plotting the 1d-integrand
{
int nk2=10001; double xx, yy;
fval[0]=0.0;
for (int ii=0; ii<nk2; ii++)
{
xx=3e9*ii/(nk2-1.0);
yy=Integrand1d_cquad3(xx,cubpass);
fval[0]+=yy*3e9/(nk2-1.0);
}
printf("->check ,%e \n",fval[0]);
}
}
if(std::isinf(fval[0])||std::isnan(fval[0])) // in case return NaN/Inf
{
printf( "->divergence experienced,call InfPeak !\n" );
try
{
InfPeak_diag Peak_ftor{Ek1,Ek4,QD,flag,cubpass->EC,cubpass->EV,cubpass->KGRID};
k2min=zbrent(Peak_ftor, k2min, k2max, 1e-1);
}
//catch(NRerror s)
catch(const char* p) // by S.Z.
{
//NRcatch(s);
printf("%s\n", p);
fval[0]=0.0; return 0; // no solution found by Peakfinder
}
gsl_function F;
F.params = cubpass;
switch (flag) {
case 1:
F.function = &Integrand1d_cquad1;
gsl_integration_cquad(&F, 0,k2min,0, 1e-3, ws, &res, &abserr, &neval);
fval[0]=res;
gsl_integration_cquad(&F, k2min,k2max,0, 1e-3, ws, &res, &abserr, &neval);
fval[0]+=res;
break;
case 2:
F.function = &Integrand1d_cquad2;
gsl_integration_cquad(&F, 0,k2min,0, 1e-3, ws, &res, &abserr, &neval);
fval[0]=res;
gsl_integration_cquad(&F, k2min,k2max,0, 1e-3, ws, &res, &abserr, &neval);
fval[0]+=res;
break;
case 3:
F.function = &Integrand1d_cquad3;
gsl_integration_cquad(&F, 0,k2min,0, 1e-3, ws, &res, &abserr, &neval);
fval[0]=res;
gsl_integration_cquad(&F, k2min,k2max,0, 1e-3, ws, &res, &abserr, &neval);
fval[0]+=res;
break;
case 4:
F.function = &Integrand1d_cquad4;
gsl_integration_cquad(&F, 0,k2min,0, 1e-3, ws, &res, &abserr, &neval);
fval[0]=res;
gsl_integration_cquad(&F, k2min,k2max,0, 1e-3, ws, &res, &abserr, &neval);
fval[0]+=res;
break;
default:
printf( "type illegal !" );
}
}
gsl_integration_cquad_workspace_free( ws);
return 0;
}
scalar SASFITqrombIQdR(Tcl_Interp *interp,
int *dF_dpar,
scalar l[],
scalar s[],
scalar Q,
scalar a[],
sasfit_function* SD,
sasfit_function* FF,
sasfit_function* SQ,
int distr,
scalar Len_start,
scalar Len_end,
bool *error)
{
scalar *aw, res,err;
scalar cubxmin[1], cubxmax[1], fval[1], ferr[1];
gsl_integration_workspace * w;
gsl_integration_cquad_workspace * wcquad;
gsl_integration_glfixed_table * wglfixed;
gsl_function F;
size_t neval;
int lenaw=4000;
sasfit_param4int param4int;
param4int.dF_dpar=dF_dpar;
param4int.l=l;
param4int.s=s;
param4int.Q=Q;
param4int.a=a;
param4int.SD=SD;
param4int.FF=FF;
param4int.SQ=SQ;
param4int.distr=distr;
param4int.error=error;
switch(sasfit_get_int_strategy()) {
case OOURA_DOUBLE_EXP_QUADRATURE: {
aw = (scalar *)malloc((lenaw)*sizeof(scalar));
sasfit_intdeini(lenaw, GSL_DBL_MIN, sasfit_eps_get_nriq(), aw);
sasfit_intde(&IQ_IntdLen, Len_start,Len_end, aw, &res, &err,¶m4int);
free(aw);
break;
}
case OOURA_CLENSHAW_CURTIS_QUADRATURE: {
aw = (scalar *)malloc((lenaw+1)*sizeof(scalar));
sasfit_intccini(lenaw, aw);
sasfit_intcc(&IQ_IntdLen, Len_start,Len_end, sasfit_eps_get_nriq(), lenaw, aw, &res, &err,¶m4int);
free(aw);
break;
}
case GSL_CQUAD: {
wcquad = gsl_integration_cquad_workspace_alloc(lenaw);
F.function=&IQ_IntdLen;
F.params = ¶m4int;
gsl_integration_cquad (&F, Len_start, Len_end, 0, sasfit_eps_get_nriq(), wcquad, &res, &err,&neval);
gsl_integration_cquad_workspace_free(wcquad);
break;
}
case GSL_QAG: {
w = gsl_integration_workspace_alloc(lenaw);
F.function=&IQ_IntdLen;
F.params = ¶m4int;
gsl_integration_qag (&F, Len_start, Len_end, 0, sasfit_eps_get_nriq(), lenaw, 3,
w, &res, &err);
gsl_integration_workspace_free (w);
break;
}
case H_CUBATURE: {
param4int.function=&IQ_IntdLen;
cubxmin[0]=Len_start;
cubxmax[0]=Len_end;
hcubature(1, &f1D_cubature,¶m4int,1, cubxmin, cubxmax,
10000, 0.0, sasfit_eps_get_nriq(),
ERROR_INDIVIDUAL, fval, ferr);
res = fval[0];
break;
}
case P_CUBATURE: {
param4int.function=&IQ_IntdLen;
cubxmin[0]=Len_start;
cubxmax[0]=Len_end;
pcubature(1, &f1D_cubature, ¶m4int,1, cubxmin, cubxmax,
10000,0.0, sasfit_eps_get_nriq(),
ERROR_INDIVIDUAL, fval, ferr);
res = fval[0];
break;
}
case NR_QROMB: {
res = SASFITqrombIQdR_old(interp,dF_dpar,l,s,Q,a,
SD,FF,SQ,
distr,Len_start, Len_end,error);
break;
}
default: {
sasfit_err("Unknown integration strategy\n");
break;
}
}
if (err < 0) {
sasfit_err("Integration Int[N(R)I(Q,R),R=0,Infty] did not converged for Q=%lf",Q);
}
return res;
}
int lua_integration_integrate(lua_State * L) {
double a=0.0;
double b=1.0;
double c=0.5;
double epsabs=0.0;
double epsrel=0.0000001;
double alpha=0.0;
double beta=0.0;
int mu=0;
int nu=0;
size_t limit=100;
size_t n=0;
int key=1;
double result=0;
double abserr=0;
size_t neval=0;
gsl_integration_workspace * w=0;
multi_param mp;
mp.L=L;
lua_pushstring(L,"f");
lua_gettable(L,-2);
if(lua_isfunction(L,-1)) {
mp.f_index=luaL_ref(L, LUA_REGISTRYINDEX);
} else {
luaL_error(L,"%s\n","missing function");
}
gsl_function F;
F.function = &int_f_cb;
F.params = ∓
lua_pushstring(L,"epsabs");
lua_gettable(L,-2);
if(lua_isnumber(L,-1)) {
epsabs=lua_tonumber(L,-1);
}
lua_pop(L,1);
lua_pushstring(L,"epsrel");
lua_gettable(L,-2);
if(lua_isnumber(L,-1)) {
epsrel=lua_tonumber(L,-1);
}
lua_pop(L,1);
lua_pushstring(L,"a");
lua_gettable(L,-2);
if(lua_isnumber(L,-1)) {
a=lua_tonumber(L,-1);
}
lua_pop(L,1);
lua_pushstring(L,"b");
lua_gettable(L,-2);
if(lua_isnumber(L,-1)) {
b=lua_tonumber(L,-1);
}
lua_pop(L,1);
lua_pushstring(L,"c");
lua_gettable(L,-2);
if(lua_isnumber(L,-1)) {
c=lua_tonumber(L,-1);
}
lua_pop(L,1);
lua_pushstring(L,"limit");
lua_gettable(L,-2);
if(lua_isnumber(L,-1)) {
limit=(size_t)lua_tonumber(L,-1);
}
lua_pop(L,1);
lua_pushstring(L,"n");
lua_gettable(L,-2);
if(lua_isnumber(L,-1)) {
n=(size_t)lua_tonumber(L,-1);
}
lua_pop(L,1);
if(limit>n) n=limit;
lua_pushstring(L,"key");
lua_gettable(L,-2);
if(lua_isnumber(L,-1)) {
key=(int)lua_tonumber(L,-1);
}
lua_pop(L,1);
lua_pushstring(L,"alpha");
lua_gettable(L,-2);
if(lua_isnumber(L,-1)) {
alpha=(double)lua_tonumber(L,-1);
}
lua_pop(L,1);
lua_pushstring(L,"beta");
lua_gettable(L,-2);
if(lua_isnumber(L,-1)) {
beta=(double)lua_tonumber(L,-1);
}
lua_pop(L,1);
lua_pushstring(L,"mu");
lua_gettable(L,-2);
if(lua_isnumber(L,-1)) {
mu=(int)lua_tonumber(L,-1);
}
lua_pop(L,1);
lua_pushstring(L,"nu");
lua_gettable(L,-2);
if(lua_isnumber(L,-1)) {
nu=(int)lua_tonumber(L,-1);
}
lua_pop(L,1);
lua_pushstring(L,"algorithm");
lua_gettable(L,-2);
if(lua_isstring(L,-1)) {
if(!strcmp(lua_tostring(L,-1),"qng")) {
gsl_integration_qng(&F,a,b,epsabs,epsrel,&result,&abserr,&neval);
} else if(!strcmp(lua_tostring(L,-1),"qag")) {
w=gsl_integration_workspace_alloc(n);
gsl_integration_qag(&F,a,b,epsabs,epsrel,limit,key,w,&result,&abserr);
} else if(!strcmp(lua_tostring(L,-1),"qags")) {
w=gsl_integration_workspace_alloc(n);
gsl_integration_qags(&F,a,b,epsabs,epsrel,limit,w,&result,&abserr);
} else if(!strcmp(lua_tostring(L,-1),"qagi")) {
w=gsl_integration_workspace_alloc(n);
gsl_integration_qagi(&F,epsabs,epsrel,limit,w,&result,&abserr);
} else if(!strcmp(lua_tostring(L,-1),"qagiu")) {
w=gsl_integration_workspace_alloc(n);
gsl_integration_qagiu(&F,a,epsabs,epsrel,limit,w,&result,&abserr);
} else if(!strcmp(lua_tostring(L,-1),"qagil")) {
w=gsl_integration_workspace_alloc(n);
gsl_integration_qagil(&F,b,epsabs,epsrel,limit,w,&result,&abserr);
} else if(!strcmp(lua_tostring(L,-1),"qawc")) {
w=gsl_integration_workspace_alloc(n);
gsl_integration_qawc(&F,a,b,c,epsabs,epsrel,limit,w,&result,&abserr);
} else if(!strcmp(lua_tostring(L,-1),"qaws")) {
w=gsl_integration_workspace_alloc(n);
gsl_integration_qaws_table * table=gsl_integration_qaws_table_alloc(alpha,beta,mu,nu);
gsl_integration_qaws(&F,a,b,table,epsabs,epsrel,limit,w,&result,&abserr);
gsl_integration_qaws_table_free(table);
} else if(!strcmp(lua_tostring(L,-1),"cquad")) {
gsl_integration_cquad_workspace * w=gsl_integration_cquad_workspace_alloc(n);
gsl_integration_cquad(&F,a,b,epsabs,epsrel,w,&result,&abserr,&neval);
gsl_integration_cquad_workspace_free(w);
} else {
luaL_error(L,"%s\n","invalid algorithm");
}
} else {
gsl_integration_cquad_workspace * w=gsl_integration_cquad_workspace_alloc(n);
gsl_integration_cquad(&F,a,b,epsabs,epsrel,w,&result,&abserr,&neval);
gsl_integration_cquad_workspace_free(w);
}
lua_pop(L,1);
lua_pop(L,1);
lua_pushnumber(L,result);
lua_pushnumber(L,abserr);
lua_pushnumber(L,neval);
if(mp.fdf_index>=0) luaL_unref(L, LUA_REGISTRYINDEX, mp.fdf_index);
if(w) gsl_integration_workspace_free(w);
return 3;
}
void coulomb_trick(PetscErrorCode ierr, params *params)
{
size_t neval;
PetscReal a,b,abserr,coul_result;
PetscReal mf2,mu2,th2;
PetscInt start,end;
PetscInt rank;
PetscReal *_mu;
PetscReal *_th;
Vec MU_SEQ;
Vec TH_SEQ;
VecScatter ctm;
VecScatter ctt;
int_params int_params;
ierr = PetscPrintf(PETSC_COMM_WORLD,"---Beginning Coulomb Trick---\n");CHKERRV(ierr);
print_progress_header(ierr);
int_params.epsabs=1e-4;
int_params.epsrel=1e-8;
int_params.N_work=4000;
int_params.flag_asy=params->flag_asy;
MPI_Comm_rank(PETSC_COMM_WORLD,&rank);
for(PetscInt i=0;i<params->nf;i++)
{
int_params.p_bohr.push_back(params->p_bohr[i]);
}
gsl_function F;
F.function = &ct_integrand;
F.params=&int_params;
ierr = VecScatterCreateToAll(params->mu,&ctm,&MU_SEQ);CHKERRV(ierr);
ierr = VecScatterBegin(ctm,params->mu,MU_SEQ,INSERT_VALUES,SCATTER_FORWARD);CHKERRV(ierr);
ierr = VecScatterEnd(ctm,params->mu,MU_SEQ,INSERT_VALUES,SCATTER_FORWARD);CHKERRV(ierr);
ierr = VecGetArray(MU_SEQ,&_mu);CHKERRV(ierr);
ierr = VecScatterCreateToAll(params->theta,&ctt,&TH_SEQ);CHKERRV(ierr);
ierr = VecScatterBegin(ctt,params->theta,TH_SEQ,INSERT_VALUES,SCATTER_FORWARD);CHKERRV(ierr);
ierr = VecScatterEnd(ctt,params->theta,TH_SEQ,INSERT_VALUES,SCATTER_FORWARD);CHKERRV(ierr);
ierr = VecGetArray(TH_SEQ,&_th);CHKERRV(ierr);
ierr = VecGetOwnershipRange(params->CT,&start,&end);CHKERRV(ierr);
PetscInt step;
step=1;
if(params->Jz==0){step=2;start=start+(start%2);}
gsl_integration_cquad_workspace *work = gsl_integration_cquad_workspace_alloc(int_params.N_work);
for (PetscInt i=start; i<end; i+=step)
{
//if((i-start)%((end-start)/10)==0){ierr = PetscPrintf(PETSC_COMM_SELF,"----Cc: r%d -> %d\\%d\n",rank,(i-start),(end-start));CHKERRV(ierr);}
// if(params->Jz !=0 || i%2==0){
get_index(i,&int_params,params);
int_params.mu2 = _mu[params->nm_tot[int_params.index_f]+int_params.index_m];
int_params.th2 = _th[params->nt_tot[int_params.index_f]+int_params.index_t];
// ierr = PetscPrintf(PETSC_COMM_SELF,"Pts: %d %d %f %f\n",int_params.index_m,int_params.index_t,int_params.mu2,int_params.th2);CHKERRV(ierr);
if(int_params.index_s<2){int_params.Jzc = params->Jz;}
else{int_params.Jzc= -params->Jz;}
// if (int_params.Jzc !=0 || int_params.index_s%2==0)
// {
int_params.mf = params->m[int_params.index_f];
mf2=int_params.mf*int_params.mf;
mu2=int_params.mu2;
th2=int_params.th2;
int_params.x2 = (1.0+mu2*th2/sqrt(mf2+mu2*mu2))/2.0;
int_params.k2 = mu2*sqrt(1.0-th2*th2);
a = 0.0;
b = params->lambda[int_params.index_f]/2.0;
// if (int_params.Jzc !=0 || int_params.index_s%2==0)
// {
// gsl_integration_cquad_workspace *work = gsl_integration_cquad_workspace_alloc(int_params.N_work);
gsl_integration_cquad(&F,a,b,int_params.epsabs,int_params.epsrel,work,&coul_result,&abserr,&neval);
// gsl_integration_cquad_workspace_free(work);
ierr = VecSetValues(params->CT,1,&i,&coul_result,ADD_VALUES);CHKERRV(ierr);
if (params->Jz==0)
{
PetscInt ishift;
ishift=i+(3-2*int_params.index_s);
ierr = VecSetValues(params->CT,1,&ishift,&coul_result,ADD_VALUES);CHKERRV(ierr);
}
// }
// ierr = PetscPrintf(PETSC_COMM_SELF,"Pts: %d %d %f %f %f\n",int_params.index_m,int_params.index_t,int_params.mu2,int_params.th2,coul_result);CHKERRV(ierr);
if((i-start)%((end-start)/4)==0){ierr = PetscPrintf(PETSC_COMM_SELF,"|");CHKERRV(ierr);}
}
gsl_integration_cquad_workspace_free(work);
ierr = VecRestoreArray(MU_SEQ,&_mu);CHKERRV(ierr);
ierr = VecScatterDestroy(&ctm);CHKERRV(ierr);
ierr = VecDestroy(&MU_SEQ);CHKERRV(ierr);
ierr = VecRestoreArray(TH_SEQ,&_th);CHKERRV(ierr);
ierr = VecScatterDestroy(&ctt);CHKERRV(ierr);
ierr = VecDestroy(&TH_SEQ);CHKERRV(ierr);
ierr = VecAssemblyBegin(params->CT);CHKERRV(ierr);
ierr = VecAssemblyEnd(params->CT);CHKERRV(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"\n---Finishing Coulomb Trick---\n");CHKERRV(ierr);
}
