int spline_read(const char* filename, spline_p spline) {
int i, result;
FILE* file;
char buffer[1024];
spline_segment_t segment;
spline_init(spline);
file = fopen(filename, "r");
if (file == NULL)
return -SPLINE_ERROR_FILE_OPEN;
while (fgets(buffer, sizeof(buffer), file) != NULL) {
if (buffer[0] != '#') {
result = sscanf(buffer, "%lg %lg %lg %lg %lg",
&segment.a,
&segment.b,
&segment.c,
&segment.d,
&segment.arg_width);
if (result < 5) {
fclose(file);
return -SPLINE_ERROR_FILE_FORMAT;
}
spline_add_segment(spline, &segment);
}
}
fclose(file);
return spline->num_segments;
}
void era_trajectory_init(era_trajectory_p trajectory) {
int i;
spline_p spline_a = (spline_p)trajectory;
for (i = 0; i < sizeof(era_trajectory_t)/sizeof(spline_t); ++i)
spline_init(&spline_a[i]);
}
int processtask(task_t *ptask, task_t *prep, spline_t *pspline) {
prep->cmd = ptask->cmd;
switch(ptask->cmd) {
case SPLINE_INIT:
spline_init(pspline, (double_t*)ptask->px,
(double_t*)ptask->px + ptask->n/(sizeof(double_t)*2),
ptask->n/(sizeof(double_t)*2));
break;
case SPLINE_DESTROY:
spline_destroy(pspline);
break;
case SPLINE_GETVAL:
spline_getvaluev(pspline, (double_t*)ptask->px,
(double_t*)prep->px, ptask->n/sizeof(double_t));
break;
}
return 0;
}
int main() {
double_t xs[SIZE_SRC], ys[SIZE_SRC],
xt[SIZE_TAR], yt[SIZE_TAR], ye[SIZE_TAR],
v;
spline_t spline;
v=0;
for(size_t i=0; i<SIZE_SRC; ++i, v+=STEP_SRC) {
xs[i] = v;
ys[i] = sin(v) + 2;
}
spline_init(&spline, xs, ys, SIZE_SRC);
v=0;
for(size_t i=0; i<SIZE_TAR; ++i, v+=STEP_TAR) {
xt[i] = v;
yt[i] = sin(v) + 2;
ye[i] = spline_getvalue(&spline, v);
printf("x %f, target %f, spline %f, error %f\n", xt[i], yt[i], ye[i], yt[i]-ye[i]);
}
spline_destroy(&spline);
return EXIT_SUCCESS;
}
/* FUNCTION: Calculate opacities for the grid of wavenumber, radius,
and temperature arrays for each molecule. */
int
calcopacity(struct transit *tr,
FILE *fp){
struct opacity *op=tr->ds.op; /* Opacity struct */
struct isotopes *iso=tr->ds.iso; /* Isotopes struct */
struct molecules *mol=tr->ds.mol; /* Molecules struct */
struct lineinfo *li=tr->ds.li; /* Lineinfo struct */
long Nmol, Ntemp, Nlayer, Nwave; /* Opacity-grid dimension sizes */
int i, j, t, r, /* for-loop indices */
rn, iso1db;
double *z;
int k;
PREC_ATM *density = (PREC_ATM *)calloc(mol->nmol, sizeof(PREC_ATM));
double *Z = (double *)calloc(iso->n_i, sizeof(double));
/* Make temperature array from hinted values: */
maketempsample(tr);
Ntemp = op->Ntemp = tr->temp.n;
op->temp = (PREC_RES *)calloc(Ntemp, sizeof(PREC_RES));
for (i=0; i<Ntemp; i++)
op->temp[i] = tr->temp.v[i];
/* Temperature boundaries check: */
if (op->temp[0] < li->tmin) {
tr_output(TOUT_ERROR, "The opacity file attempted to sample a "
"temperature (%.1f K) below the lowest allowed "
"TLI temperature (%.1f K).\n", op->temp[0], li->tmin);
exit(EXIT_FAILURE);
}
if (op->temp[Ntemp-1] > li->tmax) {
tr_output(TOUT_ERROR, "The opacity file attempted to sample a "
"temperature (%.1f K) beyond the highest allowed "
"TLI temperature (%.1f K).\n", op->temp[Ntemp-1], li->tmax);
exit(EXIT_FAILURE);
}
tr_output(TOUT_RESULT, "There are %li temperature samples.\n", Ntemp);
/* Evaluate the partition at these temperatures: */
op->ziso = (PREC_ATM **)calloc(iso->n_i, sizeof(PREC_ATM *));
op->ziso[0] = (PREC_ATM *)calloc(iso->n_i*Ntemp, sizeof(PREC_ATM));
for(i=1; i<iso->n_i; i++)
op->ziso[i] = op->ziso[0] + i*Ntemp;
/* Interpolate the partition function: */
for(i=0; i<iso->n_db; i++){ /* For each database separately: */
iso1db = iso->db[i].s; /* Index of first isotope in current DB */
for(j=0; j < iso->db[i].i; j++){
transitASSERT(iso1db + j > iso->n_i-1, "Trying to reference an isotope "
"(%i) outside the extended limit (%i).\n", iso1db+j, iso->n_i-1);
z = calloc(li->db[i].t, sizeof(double));
spline_init(z, li->db[i].T, li->isov[iso1db+j].z, li->db[i].t);
for(k=0;k<Ntemp;k++)
op->ziso[iso1db+j][k] = splinterp_pt(z, li->db[i].t, li->db[i].T,
li->isov[iso1db+j].z, op->temp[k]);
free(z);
}
}
/* Get pressure array from transit (save in CGS units): */
Nlayer = op->Nlayer = tr->rads.n;
op->press = (PREC_RES *)calloc(Nlayer, sizeof(PREC_RES));
for (i=0; i<Nlayer; i++)
op->press[i] = tr->atm.p[i]*tr->atm.pfct;
tr_output(TOUT_RESULT, "There are %li radius samples.\n", Nlayer);
/* Make molecules array from transit: */
Nmol = op->Nmol = tr->ds.iso->nmol;
op->molID = (int *)calloc(Nmol, sizeof(int));
tr_output(TOUT_RESULT, "There are %li molecules with line "
"transitions.\n", Nmol);
for (i=0, j=0; i<iso->n_i; i++){
/* If this molecule is not yet in molID array, add it's universal ID: */
if (valueinarray(op->molID, mol->ID[iso->imol[i]], j) < 0){
op->molID[j++] = mol->ID[iso->imol[i]];
tr_output(TOUT_DEBUG, "Isotope's (%d) molecule ID: %d (%s) "
"added at position %d.\n", i, op->molID[j-1],
mol->name[iso->imol[i]], j-1);
}
}
/* Get wavenumber array from transit: */
Nwave = op->Nwave = tr->wns.n;
op->wns = (PREC_RES *)calloc(Nwave, sizeof(PREC_RES));
for (i=0; i<Nwave; i++)
op->wns[i] = tr->wns.v[i];
tr_output(TOUT_RESULT, "There are %li wavenumber samples.\n", Nwave);
/* Allocate opacity array: */
if (fp != NULL){
op->o = (PREC_RES ****) calloc(Nlayer, sizeof(PREC_RES ***));
for (r=0; r<Nlayer; r++){
op->o[r] = (PREC_RES ***) calloc(Ntemp, sizeof(PREC_RES **));
for (t=0; t<Ntemp; t++){
op->o[r][t] = (PREC_RES **) calloc(Nmol, sizeof(PREC_RES *));
for (i=0; i<Nmol; i++){
op->o[r][t][i] = (PREC_RES *)calloc(Nwave, sizeof(PREC_RES));
}
}
}
if (!op->o[0][0][0])
tr_output(TOUT_ERROR, "Allocation fail.\n");
/* Compute extinction: */
for (r=0; r<Nlayer; r++){ /* For each layer: */
tr_output(TOUT_DEBUG, "\nOpacity Grid at layer %03d/%03ld.\n",
r+1, Nlayer);
for (t=0; t<Ntemp; t++){ /* For each temperature: */
/* Get density and partition-function arrays: */
for (j=0; j < mol->nmol; j++)
density[j] = stateeqnford(tr->ds.at->mass, mol->molec[j].q[r],
tr->atm.mm[r], mol->mass[j], op->press[r], op->temp[t]);
for (j=0; j < iso->n_i; j++)
Z[j] = op->ziso[j][t];
if((rn=computemolext(tr, op->o[r][t], op->temp[t], density, Z, 1))
!= 0) {
tr_output(TOUT_ERROR, "extinction() returned error code %i.\n", rn);
exit(EXIT_FAILURE);
}
}
}
/* Save dimension sizes: */
fwrite(&Nmol, sizeof(long), 1, fp);
fwrite(&Ntemp, sizeof(long), 1, fp);
fwrite(&Nlayer, sizeof(long), 1, fp);
fwrite(&Nwave, sizeof(long), 1, fp);
/* Save arrays: */
fwrite(&op->molID[0], sizeof(int), Nmol, fp);
fwrite(&op->temp[0], sizeof(PREC_RES), Ntemp, fp);
fwrite(&op->press[0], sizeof(PREC_RES), Nlayer, fp);
fwrite(&op->wns[0], sizeof(PREC_RES), Nwave, fp);
/* Save opacity: */
for (r=0; r<Nlayer; r++)
for (t=0; t<Ntemp; t++)
for (i=0; i<Nmol; i++)
fwrite(op->o[r][t][i], sizeof(PREC_RES), Nwave, fp);
fclose(fp);
}
tr_output(TOUT_RESULT, "Done.\n");
return 0;
}
int main() {
XTextProperty title;
XEvent event;
XSizeHints *hints;
XWMHints *wm_hints;
KeySym key;
Pixmap pix;
pthread_t thread;
/* grepare toPlot function */
spline_init();
/* visual routines */
int pressed_1[3] = {0, 0, 0}; // pressed state of button1: condition and coordinates
char *caption = "Interpolation";
char *dpy_str = getenv("DISPLAY");
fprintf(stderr, "Connecting to %s\t ", dpy_str);
dpy = XOpenDisplay(dpy_str);
if( !dpy ) {
fprintf(stderr, "Unable to connect\n");
exit(EXIT_FAILURE);
} else {
fprintf(stderr, "OK\n");
}
scr = DefaultScreen(dpy);
getColors();
width = 2 * DisplayWidth(dpy, scr) / 3;
height = 2 * DisplayHeight(dpy, scr) / 3;
win = XCreateSimpleWindow(dpy,
RootWindow(dpy, scr),
0, 0,
width, height,
0,
black, white
);
XStringListToTextProperty(&caption, 1, &title);
XSetWMName(dpy, win, &title);
XSetWMIconName(dpy, win, &title);
cont = XCreateGC(dpy, win, 0, NULL);
if( cont<0 ) {
fprintf(stderr, "XCReateGC: unable to set GC");
exit(EXIT_FAILURE);
}
/* making window unresizeable */
hints = XAllocSizeHints();
if( !hints ) {
fprintf(stderr, "XAllocSizeHints: out of memory");
exit(EXIT_FAILURE);
}
hints->flags = PMaxSize | PMinSize;
hints->min_width = width;
hints->min_height = height;
hints->max_width = width;
hints->max_height = height;
XSetWMNormalHints(dpy, win, hints);
XFree(hints);
/* setting icon */
pix = XCreateBitmapFromData(dpy, win, icon_bits, icon_width, icon_height);
if( !pix ) {
fprintf(stderr, "XCreateBitmapFromData: cannot create icon");
exit(EXIT_FAILURE);
}
wm_hints = XAllocWMHints();
if( !wm_hints ) {
fprintf(stderr, "XAllocWMHints: out of memory");
exit(EXIT_FAILURE);
}
wm_hints->flags = IconPixmapHint | StateHint | IconPositionHint;
wm_hints->icon_pixmap = pix;
wm_hints->initial_state = IconicState;
wm_hints->icon_x = 0;
wm_hints->icon_y = 0;
XSetWMHints(dpy, win, wm_hints);
XFree(wm_hints);
/* making window visible */
XMapWindow(dpy, win);
draw(2,1);
XSelectInput(dpy, win, ExposureMask | KeyPressMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask);
while( 1 ) {
XNextEvent(dpy, &event);
switch( event.type ) {
case Expose:
if( event.xexpose.count>0 )
break;
draw(0,1);
XFlush(dpy);
break;
case KeyPress:
XLookupString((XKeyEvent*) &event, NULL, 0, &key, NULL);
/* moving window */
switch( key ) {
case XK_Down:
pthread_create(&thread, NULL, dec, (void*)&shift_y);
break;
case XK_Up:
pthread_create(&thread, NULL, inc, (void*)&shift_y);
break;
case XK_Right:
pthread_create(&thread, NULL, dec, (void*)&shift_x);
break;
case XK_Left:
pthread_create(&thread, NULL, inc, (void*)&shift_x);
break;
case XK_plus:
pthread_create(&thread, NULL, inc, (void*)&shift_pix);
break;
case XK_minus:
pthread_create(&thread, NULL, dec, (void*)&shift_pix);
break;
case XK_equal:
pthread_create(&thread, NULL, def, (void*)NULL);
break;
case XK_Escape:
XCloseDisplay(dpy);
exit(EXIT_SUCCESS);
default:
break;
}
break;
case ButtonPress:
switch( event.xbutton.button ) {
case Button1:
pressed_1[0]=1;
pressed_1[1]=event.xmotion.x;
pressed_1[2]=event.xmotion.y;
break;
default:
break;
}
break;
case ButtonRelease:
switch( event.xbutton.button ) {
case Button1:
pressed_1[0]=0;
break;
default:
break;
}
break;
case MotionNotify:
if( pressed_1[0] ) {
/* if button_1 is pressed while moving */
draw(1,0);
shift_x-=pressed_1[1]-event.xmotion.x;
shift_y-=pressed_1[2]-event.xmotion.y;
pressed_1[1]=event.xmotion.x;
pressed_1[2]=event.xmotion.y;
draw(1,1);
}
pos_x=event.xmotion.x;
pos_y=event.xmotion.y;
drawInfo();
break;
default:
break;
} /* switch(event.type) */
} /* endless loop */
XCloseDisplay(dpy);
return EXIT_SUCCESS;
}
RunParams *init_params(char *fname_ini)
{
FILE *fi;
int n,ii,stat,ibin;
double *x,*a,*y,dchi;
RunParams *par=param_new();
par->cpar=csm_params_new();
read_parameter_file(fname_ini,par);
csm_unset_gsl_eh();
if(par->has_bg) {
double hub;
csm_background_set(par->cpar,par->om,par->ol,par->ob,par->w0,par->wa,par->h0,D_TCMB);
par->chi_horizon=csm_radial_comoving_distance(par->cpar,0.);
par->chi_kappa=csm_radial_comoving_distance(par->cpar,1./(1+par->z_kappa));
par->chi_isw=csm_radial_comoving_distance(par->cpar,1./(1+par->z_isw));
hub=csm_hubble(par->cpar,1.);
par->prefac_lensing=1.5*hub*hub*par->om;
n=(int)(par->chi_horizon/par->dchi)+1;
dchi=par->chi_horizon/n;
par->dchi=dchi;
x=(double *)my_malloc(n*sizeof(double));
a=(double *)my_malloc(n*sizeof(double));
y=(double *)my_malloc(n*sizeof(double));
for(ii=0;ii<n;ii++)
x[ii]=dchi*ii;
printf("Setting up background splines\n");
//Set chi <-> a correspondence
const gsl_root_fdfsolver_type *T=gsl_root_fdfsolver_newton;
gsl_root_fdfsolver *s=gsl_root_fdfsolver_alloc(T);
double a_old=1.0;
for(ii=0;ii<n;ii++)
a[ii]=a_of_chi(x[ii],par->cpar,&a_old,s);
gsl_root_fdfsolver_free(s);
par->aofchi=spline_init(n,x,a,1.0,0.0);
//Compute redshift
for(ii=0;ii<n;ii++)
y[ii]=1./a[ii]-1;
par->zofchi=spline_init(n,x,y,y[0],y[n-1]);
//Compute hubble scale
for(ii=0;ii<n;ii++)
y[ii]=csm_hubble(par->cpar,a[ii]);
par->hofchi=spline_init(n,x,y,y[0],y[n-1]);
//Compute growth factor
double g0=csm_growth_factor(par->cpar,1.0);
for(ii=0;ii<n;ii++)
y[ii]=csm_growth_factor(par->cpar,a[ii])/g0;
par->gfofchi=spline_init(n,x,y,1.,0.);
//Compute growth rate
for(ii=0;ii<n;ii++)
y[ii]=csm_f_growth(par->cpar,a[ii]);
par->fgofchi=spline_init(n,x,y,y[0],1.);
free(x); free(a); free(y);
}
//Allocate power spectra
if(par->do_nc) {
par->cl_dd=(double *)my_malloc((par->lmax+1)*sizeof(double));
if(par->do_shear) {
par->cl_d1l2=(double *)my_malloc((par->lmax+1)*sizeof(double));
par->cl_d2l1=(double *)my_malloc((par->lmax+1)*sizeof(double));
}
if(par->do_cmblens)
par->cl_dc=(double *)my_malloc((par->lmax+1)*sizeof(double));
if(par->do_isw)
par->cl_di=(double *)my_malloc((par->lmax+1)*sizeof(double));
}
if(par->do_shear) {
par->cl_ll=(double *)my_malloc((par->lmax+1)*sizeof(double));
if(par->do_cmblens)
par->cl_lc=(double *)my_malloc((par->lmax+1)*sizeof(double));
if(par->do_isw)
par->cl_li=(double *)my_malloc((par->lmax+1)*sizeof(double));
}
if(par->do_cmblens) {
par->cl_cc=(double *)my_malloc((par->lmax+1)*sizeof(double));
if(par->do_isw)
par->cl_ci=(double *)my_malloc((par->lmax+1)*sizeof(double));
}
if(par->do_isw)
par->cl_ii=(double *)my_malloc((par->lmax+1)*sizeof(double));
if(par->do_w_theta) {
if(par->do_nc) {
par->wt_dd=(double *)my_malloc(par->n_th*sizeof(double));
if(par->do_shear) {
par->wt_d1l2=(double *)my_malloc(par->n_th*sizeof(double));
par->wt_d2l1=(double *)my_malloc(par->n_th*sizeof(double));
}
if(par->do_cmblens)
par->wt_dc=(double *)my_malloc(par->n_th*sizeof(double));
if(par->do_isw)
par->wt_di=(double *)my_malloc(par->n_th*sizeof(double));
}
if(par->do_shear) {
par->wt_ll_pp=(double *)my_malloc(par->n_th*sizeof(double));
par->wt_ll_mm=(double *)my_malloc(par->n_th*sizeof(double));
if(par->do_cmblens)
par->wt_lc=(double *)my_malloc(par->n_th*sizeof(double));
if(par->do_isw)
par->wt_li=(double *)my_malloc(par->n_th*sizeof(double));
}
if(par->do_cmblens) {
par->wt_cc=(double *)my_malloc(par->n_th*sizeof(double));
if(par->do_isw)
par->wt_ci=(double *)my_malloc(par->n_th*sizeof(double));
}
if(par->do_isw)
par->wt_ii=(double *)my_malloc(par->n_th*sizeof(double));
}
if(par->do_nc || par->do_shear || par->do_cmblens || par->do_isw)
csm_set_linear_pk(par->cpar,par->fname_pk,D_LKMIN,D_LKMAX,0.01,par->ns,par->s8);
if(par->do_nc || par->do_shear) {
par->wind_0=my_malloc(2*sizeof(SplPar *));
for(ibin=0;ibin<2;ibin++) {
printf("Reading window function %s\n",par->fname_window[ibin]);
fi=my_fopen(par->fname_window[ibin],"r");
n=my_linecount(fi); rewind(fi);
//Read unnormalized window
x=(double *)my_malloc(n*sizeof(double));
y=(double *)my_malloc(n*sizeof(double));
for(ii=0;ii<n;ii++) {
stat=fscanf(fi,"%lE %lE",&(x[ii]),&(y[ii]));
if(stat!=2)
report_error(1,"Error reading file, line %d\n",ii+1);
}
fclose(fi);
par->wind_0[ibin]=spline_init(n,x,y,0.,0.);
//Normalize window
double norm,enorm;
gsl_function F;
gsl_integration_workspace *w=gsl_integration_workspace_alloc(1000);
F.function=&speval_bis;
F.params=par->wind_0[ibin];
gsl_integration_qag(&F,x[0],x[n-1],0,1E-4,1000,GSL_INTEG_GAUSS41,w,&norm,&enorm);
gsl_integration_workspace_free(w);
for(ii=0;ii<n;ii++)
y[ii]/=norm;
spline_free(par->wind_0[ibin]);
par->wind_0[ibin]=spline_init(n,x,y,0.,0.);
double zmin,zmax;
double ymax=-1000;
for(ii=0;ii<n;ii++) {
if(y[ii]>ymax)
ymax=y[ii];
}
ii=0;
while(y[ii]<1E-3*ymax)
ii++;
zmin=x[ii];
ii=n-1;
while(y[ii]<1E-3*ymax)
ii--;
zmax=x[ii];
par->chimin_nc[ibin]=csm_radial_comoving_distance(par->cpar,1./(1+zmin));
par->chimax_nc[ibin]=csm_radial_comoving_distance(par->cpar,1./(1+zmax));
#ifdef _DEBUG
printf("%d %lE %lE %lE %lE\n",
ibin,zmin,zmax,par->chimin_nc[ibin],par->chimax_nc[ibin]);
#endif //_DEBUG
free(x); free(y);
}
}
if(par->do_nc) {
if(par->has_dens==1) {
printf("Reading bias function %s\n",par->fname_bias);
fi=my_fopen(par->fname_bias,"r");
n=my_linecount(fi); rewind(fi);
//Read bias
x=(double *)my_malloc(n*sizeof(double));
y=(double *)my_malloc(n*sizeof(double));
for(ii=0;ii<n;ii++) {
stat=fscanf(fi,"%lE %lE",&(x[ii]),&(y[ii]));
if(stat!=2)
report_error(1,"Error reading file, line %d\n",ii+1);
}
fclose(fi);
par->bias=spline_init(n,x,y,y[0],y[n-1]);
free(x); free(y);
}
if(par->has_lensing==1) {
printf("Reading s-bias function %s\n",par->fname_sbias);
fi=my_fopen(par->fname_sbias,"r");
n=my_linecount(fi); rewind(fi);
//Read s-bias
x=(double *)my_malloc(n*sizeof(double));
y=(double *)my_malloc(n*sizeof(double));
for(ii=0;ii<n;ii++) {
stat=fscanf(fi,"%lE %lE",&(x[ii]),&(y[ii]));
if(stat!=2)
report_error(1,"Error reading file, line %d\n",ii+1);
}
fclose(fi);
par->sbias=spline_init(n,x,y,y[0],y[n-1]);
free(x); free(y);
printf("Computing lensing magnification window function\n");
par->wind_M=my_malloc(2*sizeof(SplPar *));
for(ibin=0;ibin<2;ibin++) {
double dchi_here;
double zmax=par->wind_0[ibin]->xf;
double chimax=csm_radial_comoving_distance(par->cpar,1./(1+zmax));
n=(int)(chimax/par->dchi)+1;
dchi_here=chimax/n;
x=(double *)my_malloc(n*sizeof(double));
y=(double *)my_malloc(n*sizeof(double));
#ifdef _HAVE_OMP
#pragma omp parallel default(none) shared(n,x,y,par,dchi_here,ibin)
{
#endif //_HAVE_OMP
int j;
#ifdef _HAVE_OMP
#pragma omp for
#endif //_HAVE_OMP
for(j=0;j<n;j++) {
x[j]=dchi_here*j;
y[j]=window_magnification(x[j],par,ibin);
} //end omp for
#ifdef _HAVE_OMP
} //end omp parallel
#endif //_HAVE_OMP
par->wind_M[ibin]=spline_init(n,x,y,y[0],0);
free(x); free(y);
}
}
}
if(par->do_shear) {
if(par->has_intrinsic_alignment==1) {
printf("Reading IA bias function %s\n",par->fname_abias);
fi=my_fopen(par->fname_abias,"r");
n=my_linecount(fi); rewind(fi);
//Read bias
x=(double *)my_malloc(n*sizeof(double));
y=(double *)my_malloc(n*sizeof(double));
for(ii=0;ii<n;ii++) {
stat=fscanf(fi,"%lE %lE",&(x[ii]),&(y[ii]));
if(stat!=2)
report_error(1,"Error reading file, line %d\n",ii+1);
}
fclose(fi);
par->abias=spline_init(n,x,y,y[0],y[n-1]);
free(x); free(y);
}
printf("Computing lensing window function\n");
par->wind_L=my_malloc(2*sizeof(SplPar *));
for(ibin=0;ibin<2;ibin++) {
double dchi_here;
double zmax=par->wind_0[ibin]->xf;
double chimax=csm_radial_comoving_distance(par->cpar,1./(1+zmax));
n=(int)(chimax/par->dchi)+1;
dchi_here=chimax/n;
x=(double *)my_malloc(n*sizeof(double));
y=(double *)my_malloc(n*sizeof(double));
#ifdef _HAVE_OMP
#pragma omp parallel default(none) shared(n,x,y,par,dchi_here,ibin)
{
#endif //_HAVE_OMP
int j;
#ifdef _HAVE_OMP
#pragma omp for
#endif //_HAVE_OMP
for(j=0;j<n;j++) {
x[j]=dchi_here*j;
y[j]=window_lensing(x[j],par,ibin);
}
#ifdef _HAVE_OMP
} //end omp parallel
#endif //_HAVE_OMP
par->wind_L[ibin]=spline_init(n,x,y,y[0],0);
free(x); free(y);
}
}
#ifdef _DEBUG
print_bg(par);
#endif //_DEBUG
return par;
}
