Fast Methods for Cosmological Simulations
FastSim serves as a tool for quick N-body simulations in modified gravity.
Classes | Functions
cosmo.c File Reference
#include "common.h"
Include dependency graph for cosmo.c:

Go to the source code of this file.

Classes

struct  Fpar
 
struct  IntLensPar
 

Functions

static double speval_bis (double x, void *params)
 
static double fzero (double a, void *params)
 
static double dfzero (double a, void *params)
 
static void fdfzero (double a, void *params, double *f, double *df)
 
static double a_of_chi (double chi, Csm_params *cpar, double *a_old, gsl_root_fdfsolver *s)
 
static double integrand_wm (double chip, void *params)
 
static double window_magnification (double chi, RunParams *par, int i_window)
 
static double integrand_wl (double chip, void *params)
 
static double window_lensing (double chi, RunParams *par, int i_window)
 
RunParams * init_params (char *fname_ini)
 

Function Documentation

static double a_of_chi ( double  chi,
Csm_params *  cpar,
double *  a_old,
gsl_root_fdfsolver *  s 
)
static

Definition at line 34 of file cosmo.c.

References Fpar::chi, Fpar::cpar, dfzero(), fdfzero(), fzero(), and p.

Referenced by init_params().

35 {
36  if(chi==0)
37  return 1.;
38  else {
39  Fpar p;
40  gsl_function_fdf FDF;
41  double a_previous,a_current=*a_old;
42 
43  p.cpar=cpar;
44  p.chi=chi;
45  FDF.f=&fzero;
46  FDF.df=&dfzero;
47  FDF.fdf=&fdfzero;
48  FDF.params=&p;
49  gsl_root_fdfsolver_set(s,&FDF,a_current);
50 
51  int iter=0,status;
52  do {
53  iter++;
54  status=gsl_root_fdfsolver_iterate(s);
55  a_previous=a_current;
56  a_current=gsl_root_fdfsolver_root(s);
57  status=gsl_root_test_delta(a_current,a_previous,1E-6,0);
58  } while(status==GSL_CONTINUE);
59 
60  *a_old=a_current;
61  return a_current;
62  }
63 }
Fpar::chi
double chi
Definition: ccl_background.c:258
Fpar::cpar
Csm_params * cpar
Definition: cosmo.c:9
fdfzero
static void fdfzero(double a, void *params, double *f, double *df)
Definition: cosmo.c:28
pz_params::status
int * status
Definition: ccl_redshifts.c:41
fzero
static double fzero(double a, void *params)
Definition: cosmo.c:13
dfzero
static double dfzero(double a, void *params)
Definition: cosmo.c:21
p
static int p
Definition: ccl_emu17.c:25
static double dfzero ( double  a,
void *  params 
)
static

Definition at line 21 of file cosmo.c.

References ccl_test_distances::h.

Referenced by a_of_chi(), and fdfzero().

22 {
23  double h=csm_hubble(((Fpar *)params)->cpar,a);
24 
25  return 1./(a*a*h);
26 }
halomod_bm.params
dictionary params
Definition: halomod_bm.py:27
ccl_test_distances.h
float h
Definition: ccl_test_distances.py:22
static void fdfzero ( double  a,
void *  params,
double *  f,
double *  df 
)
static

Definition at line 28 of file cosmo.c.

References dfzero(), and fzero().

Referenced by a_of_chi().

29 {
30  *f=fzero(a,params);
31  *df=dfzero(a,params);
32 }
fzero
static double fzero(double a, void *params)
Definition: cosmo.c:13
halomod_bm.params
dictionary params
Definition: halomod_bm.py:27
dfzero
static double dfzero(double a, void *params)
Definition: cosmo.c:21
static double fzero ( double  a,
void *  params 
)
static

Definition at line 13 of file cosmo.c.

Referenced by a_of_chi(), and fdfzero().

14 {
15  double chi=((Fpar *)params)->chi;
16  double chia=csm_radial_comoving_distance(((Fpar *)params)->cpar,a);
17 
18  return chi-chia;
19 }
halomod_bm.params
dictionary params
Definition: halomod_bm.py:27
RunParams* init_params ( char *  fname_ini)

Definition at line 186 of file cosmo.c.

References a_of_chi(), RunParams::aofchi, RunParams::bias, RunParams::chi_horizon, RunParams::chi_LSS, RunParams::cl_cc, RunParams::cl_ci, RunParams::cl_d1l2, RunParams::cl_d2l1, RunParams::cl_dc, RunParams::cl_dd, RunParams::cl_di, RunParams::cl_ii, RunParams::cl_lc, RunParams::cl_li, RunParams::cl_ll, RunParams::cpar, D_LKMAX, D_LKMIN, D_TCMB, D_Z_REC, dam_fopen(), dam_linecount(), dam_malloc(), dam_report_error(), RunParams::dchi, RunParams::do_cmblens, RunParams::do_isw, RunParams::do_nc, RunParams::do_shear, RunParams::do_w_theta, RunParams::fgofchi, RunParams::fname_bias, RunParams::fname_pk, RunParams::fname_sbias, RunParams::fname_window, RunParams::gfofchi, RunParams::h0, RunParams::has_bg, RunParams::has_dens, RunParams::has_lensing, RunParams::hofchi, RunParams::lmax, RunParams::n_th, RunParams::ns, RunParams::ob, RunParams::ol, RunParams::om, param_new(), RunParams::prefac_lensing, read_parameter_file(), RunParams::s8, RunParams::sbias, speval_bis(), spline_free(), spline_init(), growth_allz::T, w, RunParams::w0, RunParams::wa, RunParams::wind_0, RunParams::wind_L, RunParams::wind_M, window_lensing(), window_magnification(), RunParams::wt_cc, RunParams::wt_ci, RunParams::wt_d1l2, RunParams::wt_d2l1, RunParams::wt_dc, RunParams::wt_dd, RunParams::wt_di, RunParams::wt_ii, RunParams::wt_lc, RunParams::wt_li, RunParams::wt_ll_mm, RunParams::wt_ll_pp, x, SplPar::xf, and RunParams::zofchi.

Referenced by main().

187 {
188  FILE *fi;
189  int n,ii,stat,ibin;
190  double *x,*a,*y,dchi;
191  RunParams *par=param_new();
192  par->cpar=csm_params_new();
193  read_parameter_file(fname_ini,par);
194 
195  csm_unset_gsl_eh(par->cpar);
196  if(par->has_bg) {
197  double hub;
198  csm_background_set(par->cpar,par->om,par->ol,par->ob,par->w0,par->wa,par->h0,D_TCMB);
199  par->chi_horizon=csm_radial_comoving_distance(par->cpar,0.);
200  par->chi_LSS=csm_radial_comoving_distance(par->cpar,1./(1+D_Z_REC));
201  hub=csm_hubble(par->cpar,1.);
202  par->prefac_lensing=1.5*hub*hub*par->om;
203 
204  n=(int)(par->chi_horizon/par->dchi)+1;
205  dchi=par->chi_horizon/n;
206  par->dchi=dchi;
207 
208  x=(double *)dam_malloc(n*sizeof(double));
209  a=(double *)dam_malloc(n*sizeof(double));
210  y=(double *)dam_malloc(n*sizeof(double));
211 
212  for(ii=0;ii<n;ii++)
213  x[ii]=dchi*ii;
214 
215  printf("Setting up background splines\n");
216  //Set chi <-> a correspondence
217  const gsl_root_fdfsolver_type *T=gsl_root_fdfsolver_newton;
218  gsl_root_fdfsolver *s=gsl_root_fdfsolver_alloc(T);
219  double a_old=1.0;
220  for(ii=0;ii<n;ii++)
221  a[ii]=a_of_chi(x[ii],par->cpar,&a_old,s);
222  gsl_root_fdfsolver_free(s);
223  par->aofchi=spline_init(n,x,a,1.0,0.0);
224 
225  //Compute redshift
226  for(ii=0;ii<n;ii++)
227  y[ii]=1./a[ii]-1;
228  par->zofchi=spline_init(n,x,y,y[0],y[n-1]);
229 
230  //Compute hubble scale
231  for(ii=0;ii<n;ii++)
232  y[ii]=csm_hubble(par->cpar,a[ii]);
233  par->hofchi=spline_init(n,x,y,y[0],y[n-1]);
234 
235  //Compute growth factor
236  double g0=csm_growth_factor(par->cpar,1.0);
237  for(ii=0;ii<n;ii++)
238  y[ii]=csm_growth_factor(par->cpar,a[ii])/g0;
239  par->gfofchi=spline_init(n,x,y,1.,0.);
240 
241  //Compute growth rate
242  for(ii=0;ii<n;ii++)
243  y[ii]=csm_f_growth(par->cpar,a[ii]);
244  par->fgofchi=spline_init(n,x,y,y[0],1.);
245  free(x); free(a); free(y);
246  }
247 
248  //Allocate power spectra
249  if(par->do_nc) {
250  par->cl_dd=(double *)dam_malloc((par->lmax+1)*sizeof(double));
251  if(par->do_shear) {
252  par->cl_d1l2=(double *)dam_malloc((par->lmax+1)*sizeof(double));
253  par->cl_d2l1=(double *)dam_malloc((par->lmax+1)*sizeof(double));
254  }
255  if(par->do_cmblens)
256  par->cl_dc=(double *)dam_malloc((par->lmax+1)*sizeof(double));
257  if(par->do_isw)
258  par->cl_di=(double *)dam_malloc((par->lmax+1)*sizeof(double));
259  }
260  if(par->do_shear) {
261  par->cl_ll=(double *)dam_malloc((par->lmax+1)*sizeof(double));
262  if(par->do_cmblens)
263  par->cl_lc=(double *)dam_malloc((par->lmax+1)*sizeof(double));
264  if(par->do_isw)
265  par->cl_li=(double *)dam_malloc((par->lmax+1)*sizeof(double));
266  }
267  if(par->do_cmblens) {
268  par->cl_cc=(double *)dam_malloc((par->lmax+1)*sizeof(double));
269  if(par->do_isw)
270  par->cl_ci=(double *)dam_malloc((par->lmax+1)*sizeof(double));
271  }
272  if(par->do_isw)
273  par->cl_ii=(double *)dam_malloc((par->lmax+1)*sizeof(double));
274 
275  if(par->do_w_theta) {
276  if(par->do_nc) {
277  par->wt_dd=(double *)dam_malloc(par->n_th*sizeof(double));
278  if(par->do_shear) {
279  par->wt_d1l2=(double *)dam_malloc(par->n_th*sizeof(double));
280  par->wt_d2l1=(double *)dam_malloc(par->n_th*sizeof(double));
281  }
282  if(par->do_cmblens)
283  par->wt_dc=(double *)dam_malloc(par->n_th*sizeof(double));
284  if(par->do_isw)
285  par->wt_di=(double *)dam_malloc(par->n_th*sizeof(double));
286  }
287  if(par->do_shear) {
288  par->wt_ll_pp=(double *)dam_malloc(par->n_th*sizeof(double));
289  par->wt_ll_mm=(double *)dam_malloc(par->n_th*sizeof(double));
290  if(par->do_cmblens)
291  par->wt_lc=(double *)dam_malloc(par->n_th*sizeof(double));
292  if(par->do_isw)
293  par->wt_li=(double *)dam_malloc(par->n_th*sizeof(double));
294  }
295  if(par->do_cmblens) {
296  par->wt_cc=(double *)dam_malloc(par->n_th*sizeof(double));
297  if(par->do_isw)
298  par->wt_ci=(double *)dam_malloc(par->n_th*sizeof(double));
299  }
300  if(par->do_isw)
301  par->wt_ii=(double *)dam_malloc(par->n_th*sizeof(double));
302  }
303 
304  if(par->do_nc || par->do_shear || par->do_cmblens || par->do_isw)
305  csm_set_linear_pk(par->cpar,par->fname_pk,D_LKMIN,D_LKMAX,0.01,par->ns,par->s8);
306 
307  if(par->do_nc || par->do_shear) {
308  par->wind_0=dam_malloc(2*sizeof(SplPar *));
309  for(ibin=0;ibin<2;ibin++) {
310  printf("Reading window function %s\n",par->fname_window[ibin]);
311  fi=dam_fopen(par->fname_window[ibin],"r");
312  n=dam_linecount(fi); rewind(fi);
313  //Read unnormalized window
314  x=(double *)dam_malloc(n*sizeof(double));
315  y=(double *)dam_malloc(n*sizeof(double));
316  for(ii=0;ii<n;ii++) {
317  stat=fscanf(fi,"%lE %lE",&(x[ii]),&(y[ii]));
318  if(stat!=2)
319  dam_report_error(1,"Error reading file, line %d\n",ii+1);
320  }
321  fclose(fi);
322  par->wind_0[ibin]=spline_init(n,x,y,0.,0.);
323  //Normalize window
324  double norm,enorm;
325  gsl_function F;
326  gsl_integration_workspace *w=gsl_integration_workspace_alloc(1000);
327  F.function=&speval_bis;
328  F.params=par->wind_0[ibin];
329  gsl_integration_qag(&F,x[0],x[n-1],0,1E-4,1000,GSL_INTEG_GAUSS41,w,&norm,&enorm);
330  gsl_integration_workspace_free(w);
331  for(ii=0;ii<n;ii++)
332  y[ii]/=norm;
333  spline_free(par->wind_0[ibin]);
334  par->wind_0[ibin]=spline_init(n,x,y,0.,0.);
335  free(x); free(y);
336  }
337  }
338 
339  if(par->do_nc) {
340  if(par->has_dens==1) {
341  printf("Reading bias function %s\n",par->fname_bias);
342  fi=dam_fopen(par->fname_bias,"r");
343  n=dam_linecount(fi); rewind(fi);
344  //Read bias
345  x=(double *)dam_malloc(n*sizeof(double));
346  y=(double *)dam_malloc(n*sizeof(double));
347  for(ii=0;ii<n;ii++) {
348  stat=fscanf(fi,"%lE %lE",&(x[ii]),&(y[ii]));
349  if(stat!=2)
350  dam_report_error(1,"Error reading file, line %d\n",ii+1);
351  }
352  fclose(fi);
353  par->bias=spline_init(n,x,y,y[0],y[n-1]);
354  free(x); free(y);
355  }
356 
357  if(par->has_lensing==1) {
358  printf("Reading s-bias function %s\n",par->fname_sbias);
359  fi=dam_fopen(par->fname_sbias,"r");
360  n=dam_linecount(fi); rewind(fi);
361  //Read s-bias
362  x=(double *)dam_malloc(n*sizeof(double));
363  y=(double *)dam_malloc(n*sizeof(double));
364  for(ii=0;ii<n;ii++) {
365  stat=fscanf(fi,"%lE %lE",&(x[ii]),&(y[ii]));
366  if(stat!=2)
367  dam_report_error(1,"Error reading file, line %d\n",ii+1);
368  }
369  fclose(fi);
370  par->sbias=spline_init(n,x,y,y[0],y[n-1]);
371  free(x); free(y);
372 
373  printf("Computing lensing magnification window function\n");
374  par->wind_M=dam_malloc(2*sizeof(SplPar *));
375  for(ibin=0;ibin<2;ibin++) {
376  double dchi_here;
377  double zmax=par->wind_0[ibin]->xf;
378  double chimax=csm_radial_comoving_distance(par->cpar,1./(1+zmax));
379  n=(int)(chimax/par->dchi)+1;
380  dchi_here=chimax/n;
381 
382  x=(double *)dam_malloc(n*sizeof(double));
383  y=(double *)dam_malloc(n*sizeof(double));
384 
385 #ifdef _HAVE_OMP
386 #pragma omp parallel default(none) shared(n,x,y,par,dchi_here,ibin)
387  {
388 #endif //_HAVE_OMP
389  int j;
390 
391 #ifdef _HAVE_OMP
392 #pragma omp for
393 #endif //_HAVE_OMP
394  for(j=0;j<n;j++) {
395  x[j]=dchi_here*j;
396  y[j]=window_magnification(x[j],par,ibin);
397  } //end omp for
398 #ifdef _HAVE_OMP
399  } //end omp parallel
400 #endif //_HAVE_OMP
401  par->wind_M[ibin]=spline_init(n,x,y,y[0],0);
402  free(x); free(y);
403  }
404  }
405  }
406 
407  if(par->do_shear) {
408  printf("Computing lensing window function\n");
409  par->wind_L=dam_malloc(2*sizeof(SplPar *));
410  for(ibin=0;ibin<2;ibin++) {
411  double dchi_here;
412  double zmax=par->wind_0[ibin]->xf;
413  double chimax=csm_radial_comoving_distance(par->cpar,1./(1+zmax));
414  n=(int)(chimax/par->dchi)+1;
415  dchi_here=chimax/n;
416 
417  x=(double *)dam_malloc(n*sizeof(double));
418  y=(double *)dam_malloc(n*sizeof(double));
419 
420 #ifdef _HAVE_OMP
421 #pragma omp parallel default(none) shared(n,x,y,par,dchi_here,ibin)
422  {
423 #endif //_HAVE_OMP
424  int j;
425 
426 #ifdef _HAVE_OMP
427 #pragma omp for
428 #endif //_HAVE_OMP
429  for(j=0;j<n;j++) {
430  x[j]=dchi_here*j;
431  y[j]=window_lensing(x[j],par,ibin);
432  }
433 #ifdef _HAVE_OMP
434  } //end omp parallel
435 #endif //_HAVE_OMP
436  par->wind_L[ibin]=spline_init(n,x,y,y[0],0);
437  free(x); free(y);
438  }
439  }
440 
441 #ifdef _DEBUG
442  print_bg(par);
443 #endif //_DEBUG
444  return par;
445 }
RunParams::cl_ci
double * cl_ci
Definition: common.h:65
RunParams::wt_d1l2
double * wt_d1l2
Definition: common.h:74
RunParams::sbias
SplPar * sbias
Definition: common.h:55
RunParams::chi_horizon
double chi_horizon
Definition: common.h:34
D_Z_REC
#define D_Z_REC
Definition: params.h:5
double
double double
Definition: precision.hpp:19
RunParams::wt_di
double * wt_di
Definition: common.h:77
RunParams::wt_li
double * wt_li
Definition: common.h:81
RunParams::prefac_lensing
double prefac_lensing
Definition: common.h:36
read_parameter_file
int read_parameter_file(char *fname, RunParams *par)
Definition: io.c:112
dam_report_error
void dam_report_error(int level, char *fmt,...)
Definition: common.c:39
RunParams::cl_d1l2
double * cl_d1l2
Definition: common.h:57
RunParams::do_isw
int do_isw
Definition: common.h:41
RunParams::ns
double ns
Definition: common.h:26
D_TCMB
#define D_TCMB
Definition: params.h:4
RunParams::chi_LSS
double chi_LSS
Definition: common.h:35
RunParams::wt_dc
double * wt_dc
Definition: common.h:76
RunParams::hofchi
SplPar * hofchi
Definition: common.h:48
RunParams::cpar
Csm_params * cpar
Definition: common.h:33
a_of_chi
static double a_of_chi(double chi, Csm_params *cpar, double *a_old, gsl_root_fdfsolver *s)
Definition: cosmo.c:34
RunParams::zofchi
SplPar * zofchi
Definition: common.h:47
RunParams::lmax
int lmax
Definition: common.h:32
RunParams::wt_lc
double * wt_lc
Definition: common.h:80
growth_allz.T
T
Definition: growth_allz.py:26
window_lensing
static double window_lensing(double chi, RunParams *par, int i_window)
Definition: cosmo.c:117
RunParams::w0
double w0
Definition: common.h:25
RunParams::wt_ll_pp
double * wt_ll_pp
Definition: common.h:78
spline_init
SplPar * spline_init(int n, double *x, double *y, double y0, double yf)
Definition: common.c:57
RunParams::do_cmblens
int do_cmblens
Definition: common.h:40
dam_fopen
FILE * dam_fopen(const char *path, const char *mode)
Definition: common.c:20
RunParams::gfofchi
SplPar * gfofchi
Definition: common.h:49
speval_bis
static double speval_bis(double x, void *params)
Definition: cosmo.c:3
RunParams::om
double om
Definition: common.h:24
D_LKMIN
#define D_LKMIN
Definition: params.h:7
RunParams::fname_bias
char fname_bias[256]
Definition: common.h:28
RunParams::cl_cc
double * cl_cc
Definition: common.h:64
RunParams::wind_0
SplPar ** wind_0
Definition: common.h:51
param_new
RunParams * param_new(void)
Definition: common.c:88
RunParams::n_th
int n_th
Definition: common.h:71
RunParams::cl_di
double * cl_di
Definition: common.h:60
RunParams::fname_pk
char fname_pk[256]
Definition: common.h:30
x
static CCL_BEGIN_DECLS double x[111][8]
Definition: ccl_emu17_params.h:14
window_magnification
static double window_magnification(double chi, RunParams *par, int i_window)
Definition: cosmo.c:86
RunParams::ob
double ob
Definition: common.h:24
RunParams::aofchi
SplPar * aofchi
Definition: common.h:46
RunParams::cl_d2l1
double * cl_d2l1
Definition: common.h:58
RunParams::dchi
double dchi
Definition: common.h:37
RunParams::cl_ll
double * cl_ll
Definition: common.h:61
RunParams::fname_sbias
char fname_sbias[256]
Definition: common.h:29
dam_malloc
void * dam_malloc(size_t size)
Definition: common.c:3
RunParams::h0
double h0
Definition: common.h:25
RunParams::bias
SplPar * bias
Definition: common.h:54
RunParams::do_shear
int do_shear
Definition: common.h:39
RunParams::do_nc
int do_nc
Definition: common.h:38
RunParams::cl_dd
double * cl_dd
Definition: common.h:56
spline_free
void spline_free(SplPar *spl)
Definition: common.c:81
RunParams::wt_cc
double * wt_cc
Definition: common.h:82
RunParams::wind_M
SplPar ** wind_M
Definition: common.h:52
RunParams::has_dens
int has_dens
Definition: common.h:43
RunParams::cl_li
double * cl_li
Definition: common.h:63
RunParams::wa
double wa
Definition: common.h:25
RunParams::wt_d2l1
double * wt_d2l1
Definition: common.h:75
RunParams::has_bg
int has_bg
Definition: common.h:42
RunParams::fname_window
char ** fname_window
Definition: common.h:27
RunParams::wind_L
SplPar ** wind_L
Definition: common.h:53
RunParams::fgofchi
SplPar * fgofchi
Definition: common.h:50
RunParams::cl_ii
double * cl_ii
Definition: common.h:66
RunParams::wt_ii
double * wt_ii
Definition: common.h:84
RunParams::has_lensing
int has_lensing
Definition: common.h:45
RunParams::wt_ll_mm
double * wt_ll_mm
Definition: common.h:79
RunParams::cl_dc
double * cl_dc
Definition: common.h:59
RunParams::wt_dd
double * wt_dd
Definition: common.h:73
RunParams::s8
double s8
Definition: common.h:26
D_LKMAX
#define D_LKMAX
Definition: params.h:8
w
static double w[2][28][111]
Definition: ccl_emu17.c:33
RunParams::ol
double ol
Definition: common.h:24
RunParams::do_w_theta
int do_w_theta
Definition: common.h:67
SplPar::xf
double xf
Definition: ccl_utils.h:52
RunParams::wt_ci
double * wt_ci
Definition: common.h:83
RunParams::cl_lc
double * cl_lc
Definition: common.h:62
dam_linecount
int dam_linecount(FILE *f)
Definition: common.c:29
static double integrand_wl ( double  chip,
void *  params 
)
static

Definition at line 103 of file cosmo.c.

References IntLensPar::chi, ccl_test_distances::h, RunParams::hofchi, IntLensPar::i_window, p, IntLensPar::par, spline_eval(), RunParams::wind_0, z, and RunParams::zofchi.

Referenced by window_lensing().

104 {
105  IntLensPar *p=(IntLensPar *)params;
106  double chi=p->chi;
107  double z=spline_eval(chip,p->par->zofchi);
108  double pz=spline_eval(z,p->par->wind_0[p->i_window]);
109  double h=spline_eval(chip,p->par->hofchi);
110 
111  if(chi==0)
112  return h*pz;
113  else
114  return h*pz*(chip-chi)/chip;
115 }
RunParams::hofchi
SplPar * hofchi
Definition: common.h:48
RunParams::zofchi
SplPar * zofchi
Definition: common.h:47
RunParams::wind_0
SplPar ** wind_0
Definition: common.h:51
IntLensPar::chi
double chi
Definition: ccl_cls.c:131
spline_eval
double spline_eval(double x, SplPar *spl)
Definition: common.c:71
halomod_bm.params
dictionary params
Definition: halomod_bm.py:27
z
static double z[8]
Definition: ccl_emu17_params.h:104517
p
static int p
Definition: ccl_emu17.c:25
IntLensPar::par
RunParams * par
Definition: cosmo.c:66
IntLensPar::i_window
int i_window
Definition: cosmo.c:68
ccl_test_distances.h
float h
Definition: ccl_test_distances.py:22
static double integrand_wm ( double  chip,
void *  params 
)
static

Definition at line 71 of file cosmo.c.

References IntLensPar::chi, ccl_test_distances::h, RunParams::hofchi, IntLensPar::i_window, p, IntLensPar::par, RunParams::sbias, spline_eval(), mk_bins::sz, RunParams::wind_0, z, and RunParams::zofchi.

Referenced by window_magnification().

72 {
73  IntLensPar *p=(IntLensPar *)params;
74  double chi=p->chi;
75  double z=spline_eval(chip,p->par->zofchi);
76  double pz=spline_eval(z,p->par->wind_0[p->i_window]);
77  double sz=spline_eval(z,p->par->sbias);
78  double h=spline_eval(chip,p->par->hofchi);
79 
80  if(chi==0)
81  return h*pz*0.5*(2-5*sz);
82  else
83  return h*pz*0.5*(2-5*sz)*(chip-chi)/chip;
84 }
RunParams::sbias
SplPar * sbias
Definition: common.h:55
RunParams::hofchi
SplPar * hofchi
Definition: common.h:48
RunParams::zofchi
SplPar * zofchi
Definition: common.h:47
RunParams::wind_0
SplPar ** wind_0
Definition: common.h:51
IntLensPar::chi
double chi
Definition: ccl_cls.c:131
spline_eval
double spline_eval(double x, SplPar *spl)
Definition: common.c:71
halomod_bm.params
dictionary params
Definition: halomod_bm.py:27
mk_bins.sz
float sz
Definition: mk_bins.py:8
z
static double z[8]
Definition: ccl_emu17_params.h:104517
p
static int p
Definition: ccl_emu17.c:25
IntLensPar::par
RunParams * par
Definition: cosmo.c:66
IntLensPar::i_window
int i_window
Definition: cosmo.c:68
ccl_test_distances.h
float h
Definition: ccl_test_distances.py:22
static double speval_bis ( double  x,
void *  params 
)
static

Definition at line 3 of file cosmo.c.

References spline_eval().

Referenced by init_params().

4 {
5  return spline_eval(x,(SplPar *)params);
6 }
x
static CCL_BEGIN_DECLS double x[111][8]
Definition: ccl_emu17_params.h:14
spline_eval
double spline_eval(double x, SplPar *spl)
Definition: common.c:71
halomod_bm.params
dictionary params
Definition: halomod_bm.py:27
static double window_lensing ( double  chi,
RunParams *  par,
int  i_window 
)
static

Definition at line 117 of file cosmo.c.

References RunParams::aofchi, IntLensPar::chi, RunParams::chi_horizon, RunParams::cpar, dam_fopen(), RunParams::do_nc, RunParams::do_shear, RunParams::fgofchi, RunParams::gfofchi, RunParams::has_lensing, RunParams::hofchi, IntLensPar::i_window, integrand_wl(), IntLensPar::par, RunParams::prefix_out, spline_eval(), w, RunParams::wind_0, RunParams::wind_L, RunParams::wind_M, SplPar::xf, z, and RunParams::zofchi.

Referenced by init_params().

118 {
119  double result,eresult;
120  IntLensPar ip;
121  gsl_function F;
122  gsl_integration_workspace *w=gsl_integration_workspace_alloc(1000);
123 
124  ip.par=par;
125  ip.chi=chi;
126  ip.i_window=i_window;
127  F.function=&integrand_wl;
128  F.params=&ip;
129  gsl_integration_qag(&F,chi,par->chi_horizon,0,1E-4,1000,GSL_INTEG_GAUSS41,w,&result,&eresult);
130  gsl_integration_workspace_free(w);
131  return result;
132 }
RunParams::chi_horizon
double chi_horizon
Definition: common.h:34
integrand_wl
static double integrand_wl(double chip, void *params)
Definition: cosmo.c:103
IntLensPar::chi
double chi
Definition: ccl_cls.c:131
IntLensPar::par
RunParams * par
Definition: cosmo.c:66
IntLensPar::i_window
int i_window
Definition: cosmo.c:68
w
static double w[2][28][111]
Definition: ccl_emu17.c:33
static double window_magnification ( double  chi,
RunParams *  par,
int  i_window 
)
static

Definition at line 86 of file cosmo.c.

References IntLensPar::chi, RunParams::chi_horizon, IntLensPar::i_window, integrand_wm(), IntLensPar::par, and w.

Referenced by init_params().

87 {
88  double result,eresult;
89  IntLensPar ip;
90  gsl_function F;
91  gsl_integration_workspace *w=gsl_integration_workspace_alloc(1000);
92 
93  ip.par=par;
94  ip.chi=chi;
95  ip.i_window=i_window;
96  F.function=&integrand_wm;
97  F.params=&ip;
98  gsl_integration_qag(&F,chi,par->chi_horizon,0,1E-4,1000,GSL_INTEG_GAUSS41,w,&result,&eresult);
99  gsl_integration_workspace_free(w);
100  return result;
101 }
RunParams::chi_horizon
double chi_horizon
Definition: common.h:34
IntLensPar::chi
double chi
Definition: ccl_cls.c:131
IntLensPar::par
RunParams * par
Definition: cosmo.c:66
integrand_wm
static double integrand_wm(double chip, void *params)
Definition: cosmo.c:71
IntLensPar::i_window
int i_window
Definition: cosmo.c:68
w
static double w[2][28][111]
Definition: ccl_emu17.c:33