common.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <gsl/gsl_spline.h>
#include <gsl/gsl_roots.h>
#include "params.h"
#include "cosmo_mad.h"

Include dependency graph for common.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	SplPar
struct	RunParams

Macros
#define	DTOR   0.01745329251

Functions
void	dam_report_error (int level, char *fmt,...)
void *	dam_malloc (size_t size)
void *	dam_calloc (size_t nmemb, size_t size)
FILE *	dam_fopen (const char *path, const char *mode)
int	dam_linecount (FILE *f)
SplPar *	spline_init (int n, double *x, double *y, double y0, double yf)
double	spline_eval (double x, SplPar *spl)
void	spline_free (SplPar *spl)
RunParams *	param_new (void)
void	param_free (RunParams *par)
RunParams *	init_params (char *fname_ini)
double	transfer_wrap (int l, double k, RunParams *par, char *trtype, int ibin)
void	compute_spectra (RunParams *par)
void	compute_w_theta (RunParams *par)
int	read_parameter_file (char *fname, RunParams *par)
void	write_output (RunParams *par)

Macro Definition Documentation

#define DTOR   0.01745329251

Definition at line 14 of file common.h.

Referenced by compute_wt_single().

Function Documentation

void compute_spectra

(

RunParams *

par

)

Definition at line 40 of file spectra.c.

References 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::do_cmblens, RunParams::do_isw, RunParams::do_nc, RunParams::do_shear, cl_cmbl_bm::l, RunParams::lmax, and spectra().

Referenced by main().

{
  printf("Computing power spectra\n");
#ifdef _HAS_OMP
#pragma omp parallel default(none) shared(par)
  {
#endif //_HAS_OMP
    int l;
#ifdef _HAS_OMP
#pragma omp for
#endif //_HAS_OMP
    for(l=0;l<=par->lmax;l++) {
#ifdef _DEBUG
      printf("%d \n",l);
#endif //_DEBUG
      if(par->do_nc) {
    par->cl_dd[l]=spectra("nc","nc",l,par);
    if(par->do_shear) {
      par->cl_d1l2[l]=spectra("nc","shear",l,par);
      par->cl_d2l1[l]=spectra("shear","nc",l,par);
    }
    if(par->do_cmblens)
      par->cl_dc[l]=spectra("nc","cmblens",l,par);
    if(par->do_isw)
      par->cl_di[l]=spectra("nc","isw",l,par);
      }
      if(par->do_shear) {
    par->cl_ll[l]=spectra("shear","shear",l,par);
    if(par->do_cmblens)
      par->cl_lc[l]=spectra("shear","cmblens",l,par);
    if(par->do_isw)
      par->cl_li[l]=spectra("shear","isw",l,par);
      }
      if(par->do_cmblens) {
    par->cl_cc[l]=spectra("cmblens","cmblens",l,par);
    if(par->do_isw)
      par->cl_ci[l]=spectra("cmblens","isw",l,par);
      }
      if(par->do_isw)
    par->cl_ii[l]=spectra("isw","isw",l,par);
    } //end omp for
#ifdef _HAS_OMP
  } //end omp parallel
#endif //_HAS_OMP
}

void compute_w_theta

(

RunParams *

par

)

Definition at line 149 of file spectra.c.

References 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, compute_wt_single(), dam_malloc(), RunParams::do_cmblens, RunParams::do_isw, RunParams::do_nc, RunParams::do_shear, RunParams::do_w_theta, cl_cmbl_bm::l, RunParams::lmax, 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, and RunParams::wt_ll_pp.

Referenced by main().

{
  if(par->do_w_theta) {
    int l;
    double *llist;

    printf("Computing correlation functions\n");

    llist=dam_malloc((par->lmax+1)*sizeof(double));
    for(l=0;l<=par->lmax;l++)
      llist[l]=(float)l;

    if(par->do_nc) {
      compute_wt_single(par,par->cl_dd,par->wt_dd,llist,0);
      if(par->do_shear) {
    compute_wt_single(par,par->cl_d1l2,par->wt_d1l2,llist,0);
    compute_wt_single(par,par->cl_d2l1,par->wt_d2l1,llist,0);
      }
      if(par->do_cmblens)
    compute_wt_single(par,par->cl_dc,par->wt_dc,llist,0);
      if(par->do_isw)
    compute_wt_single(par,par->cl_di,par->wt_di,llist,0);
    }
    if(par->do_shear) {
      compute_wt_single(par,par->cl_ll,par->wt_ll_pp,llist,0);
      compute_wt_single(par,par->cl_ll,par->wt_ll_mm,llist,4);
      if(par->do_cmblens)
    compute_wt_single(par,par->cl_lc,par->wt_lc,llist,0);
      if(par->do_isw)
    compute_wt_single(par,par->cl_li,par->wt_li,llist,0);
    }
    if(par->do_cmblens) {
      compute_wt_single(par,par->cl_cc,par->wt_cc,llist,0);
      if(par->do_isw)
    compute_wt_single(par,par->cl_ci,par->wt_ci,llist,0);
    }
    if(par->do_isw)
      compute_wt_single(par,par->cl_ii,par->wt_ii,llist,0);
    free(llist);
  }
  else {
    printf("Skipping correlation functions\n");
  }
}

void* dam_calloc	(	size_t	nmemb,
		size_t	size
	)

Definition at line 11 of file common.c.

References dam_report_error().

{
  void *outptr=calloc(nmemb,size);
  if(outptr==NULL) 
    dam_report_error(1,"Out of memory\n");

  return outptr;
}

FILE* dam_fopen	(	const char *	path,
		const char *	mode
	)

Definition at line 20 of file common.c.

References dam_report_error().

Referenced by init_params(), read_parameter_file(), window_lensing(), write_cl_single(), and write_wt_single().

{
  FILE *fout=fopen(path,mode);
  if(fout==NULL) 
    dam_report_error(1,"Couldn't open file %s\n",path);

  return fout;
}

int dam_linecount

(

FILE *

f

)

Definition at line 29 of file common.c.

Referenced by init_params(), and read_parameter_file().

{
  int i0=0;
  char ch[1024];
  while((fgets(ch,sizeof(ch),f))!=NULL) {
    i0++;
  }
  return i0;
}

void* dam_malloc

(

size_t

size

)

Definition at line 3 of file common.c.

References dam_report_error().

Referenced by compute_w_theta(), init_params(), param_new(), and spline_init().

{
  void *outptr=malloc(size);
  if(outptr==NULL) dam_report_error(1,"Out of memory\n");

  return outptr;
}

void dam_report_error	(	int	level,
		char *	fmt,
			...
	)

Definition at line 39 of file common.c.

References run_tests::args.

Referenced by dam_calloc(), dam_fopen(), dam_malloc(), init_params(), read_parameter_file(), and transfer_wrap().

{
  va_list args;
  char msg[256];

  va_start(args,fmt);
  vsprintf(msg,fmt,args);
  va_end(args);
  
  if(level) {
    fprintf(stderr,"Fatal: %s",msg);
    exit(level);
  }
  else {
    fprintf(stderr,"Warning: %s",msg);
  }
}

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().

{
  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(par->cpar);
  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_LSS=csm_radial_comoving_distance(par->cpar,1./(1+D_Z_REC));
    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 *)dam_malloc(n*sizeof(double));
    a=(double *)dam_malloc(n*sizeof(double));
    y=(double *)dam_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 *)dam_malloc((par->lmax+1)*sizeof(double));
    if(par->do_shear) {
      par->cl_d1l2=(double *)dam_malloc((par->lmax+1)*sizeof(double));
      par->cl_d2l1=(double *)dam_malloc((par->lmax+1)*sizeof(double));
    }
    if(par->do_cmblens)
      par->cl_dc=(double *)dam_malloc((par->lmax+1)*sizeof(double));
    if(par->do_isw)
      par->cl_di=(double *)dam_malloc((par->lmax+1)*sizeof(double));
  }
  if(par->do_shear) {
    par->cl_ll=(double *)dam_malloc((par->lmax+1)*sizeof(double));
    if(par->do_cmblens)
      par->cl_lc=(double *)dam_malloc((par->lmax+1)*sizeof(double));
    if(par->do_isw)
      par->cl_li=(double *)dam_malloc((par->lmax+1)*sizeof(double));
  }
  if(par->do_cmblens) {
    par->cl_cc=(double *)dam_malloc((par->lmax+1)*sizeof(double));
    if(par->do_isw)
      par->cl_ci=(double *)dam_malloc((par->lmax+1)*sizeof(double));
  }
  if(par->do_isw)
    par->cl_ii=(double *)dam_malloc((par->lmax+1)*sizeof(double));

  if(par->do_w_theta) {
    if(par->do_nc) {
      par->wt_dd=(double *)dam_malloc(par->n_th*sizeof(double));
      if(par->do_shear) {
    par->wt_d1l2=(double *)dam_malloc(par->n_th*sizeof(double));
    par->wt_d2l1=(double *)dam_malloc(par->n_th*sizeof(double));
      }
      if(par->do_cmblens)
    par->wt_dc=(double *)dam_malloc(par->n_th*sizeof(double));
      if(par->do_isw)
    par->wt_di=(double *)dam_malloc(par->n_th*sizeof(double));
    }
    if(par->do_shear) {
      par->wt_ll_pp=(double *)dam_malloc(par->n_th*sizeof(double));
      par->wt_ll_mm=(double *)dam_malloc(par->n_th*sizeof(double));
      if(par->do_cmblens)
    par->wt_lc=(double *)dam_malloc(par->n_th*sizeof(double));
      if(par->do_isw)
    par->wt_li=(double *)dam_malloc(par->n_th*sizeof(double));
    }
    if(par->do_cmblens) {
      par->wt_cc=(double *)dam_malloc(par->n_th*sizeof(double));
      if(par->do_isw)
    par->wt_ci=(double *)dam_malloc(par->n_th*sizeof(double));
    }
    if(par->do_isw)
      par->wt_ii=(double *)dam_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=dam_malloc(2*sizeof(SplPar *));
    for(ibin=0;ibin<2;ibin++) {
      printf("Reading window function %s\n",par->fname_window[ibin]);
      fi=dam_fopen(par->fname_window[ibin],"r");
      n=dam_linecount(fi); rewind(fi);
      //Read unnormalized window
      x=(double *)dam_malloc(n*sizeof(double));
      y=(double *)dam_malloc(n*sizeof(double));
      for(ii=0;ii<n;ii++) {
    stat=fscanf(fi,"%lE %lE",&(x[ii]),&(y[ii]));
    if(stat!=2)
      dam_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.);
      free(x); free(y);
    }
  }

  if(par->do_nc) {
    if(par->has_dens==1) {
      printf("Reading bias function %s\n",par->fname_bias);
      fi=dam_fopen(par->fname_bias,"r");
      n=dam_linecount(fi); rewind(fi);
      //Read bias
      x=(double *)dam_malloc(n*sizeof(double));
      y=(double *)dam_malloc(n*sizeof(double));
      for(ii=0;ii<n;ii++) {
    stat=fscanf(fi,"%lE %lE",&(x[ii]),&(y[ii]));
    if(stat!=2)
      dam_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=dam_fopen(par->fname_sbias,"r");
      n=dam_linecount(fi); rewind(fi);
      //Read s-bias
      x=(double *)dam_malloc(n*sizeof(double));
      y=(double *)dam_malloc(n*sizeof(double));
      for(ii=0;ii<n;ii++) {
    stat=fscanf(fi,"%lE %lE",&(x[ii]),&(y[ii]));
    if(stat!=2)
      dam_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=dam_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 *)dam_malloc(n*sizeof(double));
    y=(double *)dam_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) {
    printf("Computing lensing window function\n");
    par->wind_L=dam_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 *)dam_malloc(n*sizeof(double));
      y=(double *)dam_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;
}

void param_free

(

RunParams *

par

)

Definition at line 162 of file common.c.

References RunParams::aofchi, RunParams::bias, 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, RunParams::do_cmblens, RunParams::do_isw, RunParams::do_nc, RunParams::do_shear, RunParams::do_w_theta, RunParams::fgofchi, RunParams::gfofchi, RunParams::has_bg, RunParams::has_dens, RunParams::has_lensing, RunParams::hofchi, RunParams::sbias, spline_free(), RunParams::wind_0, RunParams::wind_L, RunParams::wind_M, RunParams::wt_ci, RunParams::wt_d1l2, RunParams::wt_d2l1, RunParams::wt_dc, RunParams::wt_dd, RunParams::wt_di, RunParams::wt_lc, RunParams::wt_li, RunParams::wt_ll_mm, RunParams::wt_ll_pp, and RunParams::zofchi.

Referenced by main().

{
  csm_params_free(par->cpar);
  if(par->has_bg) {
    spline_free(par->aofchi);
    spline_free(par->zofchi);
    spline_free(par->hofchi);
    spline_free(par->gfofchi);
    spline_free(par->fgofchi);
  }
  if(par->do_nc || par->do_shear) {
    spline_free(par->wind_0[0]);
    spline_free(par->wind_0[1]);
    free(par->wind_0);
  }
  if(par->do_nc) {
    free(par->cl_dd);
    if(par->do_w_theta)
      free(par->wt_dd);
    if(par->do_shear) {
      free(par->cl_d1l2);
      free(par->cl_d2l1);
      if(par->do_w_theta) {
    free(par->wt_d1l2);
    free(par->wt_d2l1);
      }
    }
    if(par->do_cmblens) {
      free(par->cl_dc);
      if(par->do_w_theta)
    free(par->wt_dc);
    }
    if(par->do_isw) {
      free(par->cl_di);
      if(par->do_w_theta)
    free(par->wt_di);
    }
    if(par->has_dens)
      spline_free(par->bias);
    if(par->has_lensing) {
      spline_free(par->sbias);
      spline_free(par->wind_M[0]);
      spline_free(par->wind_M[1]);
      free(par->wind_M);
    }
  }
  if(par->do_shear) {
    spline_free(par->wind_L[0]);
    spline_free(par->wind_L[1]);
    free(par->wind_L);
    free(par->cl_ll);
    if(par->do_w_theta) {
      free(par->wt_ll_pp);
      free(par->wt_ll_mm);
    }
    if(par->do_cmblens) {
      free(par->cl_lc);
      if(par->do_w_theta)
    free(par->wt_lc);
    }
    if(par->do_isw) {
      free(par->cl_li);
      if(par->do_w_theta)
    free(par->wt_li);
    }
  }
  if(par->do_cmblens) {
    free(par->cl_cc);
    if(par->do_isw) {
      free(par->cl_ci);
      if(par->do_w_theta)
    free(par->wt_ci);
    }
  }
  if(par->do_isw)
    free(par->cl_ii);

  free(par);
}

RunParams* param_new

(

void

)

Definition at line 88 of file common.c.

References 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, dam_malloc(), 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::has_bg, RunParams::has_dens, RunParams::has_lensing, RunParams::has_rsd, RunParams::hofchi, RunParams::lmax, RunParams::n_th, RunParams::n_th_logint, RunParams::ns, RunParams::ob, RunParams::ol, RunParams::om, RunParams::prefac_lensing, RunParams::prefix_out, RunParams::s8, RunParams::sbias, RunParams::th_max, RunParams::th_min, RunParams::w0, RunParams::wa, RunParams::wind_0, RunParams::wind_L, RunParams::wind_M, 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, and RunParams::zofchi.

Referenced by init_params().

{
  RunParams *par=(RunParams *)dam_malloc(sizeof(RunParams));
  par->om=0.3;
  par->ol=0.7;
  par->ob=0.05;
  par->w0=-1.;
  par->wa=0.;
  par->ns=0.96;
  par->s8=0.8;
  par->fname_window=dam_malloc(2*sizeof(char *));
  par->fname_window[0]=dam_malloc(256*sizeof(char));
  par->fname_window[1]=dam_malloc(256*sizeof(char));
  sprintf(par->fname_window[0],"default");
  sprintf(par->fname_window[1],"default");
  sprintf(par->fname_bias,"default");
  sprintf(par->fname_sbias,"default");
  sprintf(par->fname_pk,"default");
  sprintf(par->prefix_out,"default");
  par->lmax=100;
  par->cpar=NULL;
  par->chi_horizon=-1.;
  par->chi_LSS=-1.;
  par->prefac_lensing=-1.;
  par->dchi=-1.;
  par->aofchi=NULL;
  par->zofchi=NULL;
  par->hofchi=NULL;
  par->gfofchi=NULL;
  par->fgofchi=NULL;
  par->wind_0=NULL;
  par->wind_M=NULL;
  par->wind_L=NULL;
  par->bias=NULL;
  par->sbias=NULL;
  par->do_nc=0;
  par->do_shear=0;
  par->do_cmblens=0;
  par->do_isw=0;
  par->has_bg=0;
  par->has_dens=0;
  par->has_rsd=0;
  par->has_lensing=0;
  par->cl_dd=NULL;
  par->cl_d1l2=NULL;
  par->cl_d2l1=NULL;
  par->cl_dc=NULL;
  par->cl_di=NULL;
  par->cl_ll=NULL;
  par->cl_lc=NULL;
  par->cl_li=NULL;
  par->cl_cc=NULL;
  par->cl_ci=NULL;
  par->cl_ii=NULL;
  par->do_w_theta=0;
  par->th_min=0;
  par->th_max=10.;
  par->n_th=15;
  par->n_th_logint=5;
  par->wt_dd=NULL;
  par->wt_d1l2=NULL;
  par->wt_d2l1=NULL;
  par->wt_dc=NULL;
  par->wt_di=NULL;
  par->wt_ll_pp=NULL;
  par->wt_ll_mm=NULL;
  par->wt_lc=NULL;
  par->wt_li=NULL;
  par->wt_cc=NULL;
  par->wt_ci=NULL;
  par->wt_ii=NULL;
  return par;
}

int read_parameter_file	(	char *	fname,
		RunParams *	par
	)

Definition at line 112 of file io.c.

References dam_fopen(), dam_linecount(), dam_report_error(), RunParams::dchi, RunParams::do_cmblens, RunParams::do_isw, RunParams::do_nc, RunParams::do_shear, RunParams::do_w_theta, RunParams::do_w_theta_logbin, RunParams::fname_bias, RunParams::fname_pk, RunParams::fname_sbias, RunParams::fname_window, RunParams::h0, RunParams::has_bg, RunParams::has_dens, RunParams::has_lensing, RunParams::has_rsd, RunParams::lmax, RunParams::n_th, RunParams::n_th_logint, RunParams::ns, RunParams::ob, RunParams::ol, RunParams::om, RunParams::prefix_out, RunParams::s8, RunParams::th_max, RunParams::th_min, RunParams::w0, and RunParams::wa.

Referenced by init_params().

{
  FILE *fi;
  int n_lin,ii;

  //Read parameters from file
  fi=dam_fopen(fname,"r");
  n_lin=dam_linecount(fi); rewind(fi);
  for(ii=0;ii<n_lin;ii++) {
    char s0[512],s1[64],s2[256];
    if(fgets(s0,sizeof(s0),fi)==NULL)
      dam_report_error(1,"Error reading line %d, file %s\n",ii+1,fname);
    if((s0[0]=='#')||(s0[0]=='\n')||(s0[0]==' ')) continue;
    int sr=sscanf(s0,"%s %s",s1,s2);
    if(sr!=2)
      dam_report_error(1,"Error reading line %d, file %s\n",ii+1,fname);

    if(!strcmp(s1,"omega_m="))
      par->om=atof(s2);
    else if(!strcmp(s1,"omega_l="))
      par->ol=atof(s2);
    else if(!strcmp(s1,"omega_b="))
      par->ob=atof(s2);
    else if(!strcmp(s1,"w0="))
      par->w0=atof(s2);
    else if(!strcmp(s1,"wa="))
      par->wa=atof(s2);
    else if(!strcmp(s1,"h="))
      par->h0=atof(s2);
    else if(!strcmp(s1,"ns="))
      par->ns=atof(s2);
    else if(!strcmp(s1,"s8="))
      par->s8=atof(s2);
    else if(!strcmp(s1,"d_chi="))
      par->dchi=atof(s2);
    else if(!strcmp(s1,"l_max="))
      par->lmax=atoi(s2);
    else if(!strcmp(s1,"do_nc="))
      par->do_nc=atoi(s2);
    else if(!strcmp(s1,"has_nc_dens="))
      par->has_dens=atoi(s2);
    else if(!strcmp(s1,"has_nc_rsd="))
      par->has_rsd=atoi(s2);
    else if(!strcmp(s1,"has_nc_lensing="))
      par->has_lensing=atoi(s2);
    else if(!strcmp(s1,"do_shear="))
      par->do_shear=atoi(s2);
    else if(!strcmp(s1,"do_cmblens="))
      par->do_cmblens=atoi(s2);
    else if(!strcmp(s1,"do_isw="))
      par->do_isw=atoi(s2);
    else if(!strcmp(s1,"do_w_theta="))
      par->do_w_theta=atoi(s2);
    else if(!strcmp(s1,"use_logbin="))
      par->do_w_theta_logbin=atoi(s2);
    else if(!strcmp(s1,"theta_min="))
      par->th_min=atof(s2);
    else if(!strcmp(s1,"theta_max="))
      par->th_max=atof(s2);
    else if(!strcmp(s1,"n_bins_theta="))
      par->n_th=atof(s2);
    else if(!strcmp(s1,"n_bins_decade="))
      par->n_th_logint=atof(s2);
    else if(!strcmp(s1,"window_1_fname="))
      sprintf(par->fname_window[0],"%s",s2);
    else if(!strcmp(s1,"window_2_fname="))
      sprintf(par->fname_window[1],"%s",s2);
    else if(!strcmp(s1,"bias_fname="))
      sprintf(par->fname_bias,"%s",s2);
    else if(!strcmp(s1,"sbias_fname="))
      sprintf(par->fname_sbias,"%s",s2);
    else if(!strcmp(s1,"pk_fname="))
      sprintf(par->fname_pk,"%s",s2);
    else if(!strcmp(s1,"prefix_out="))
      sprintf(par->prefix_out,"%s",s2);
    else
      dam_report_error(0,"Unknown parameter %s\n",s1);
  }
  fclose(fi);

  if(par->do_w_theta==0)
    par->do_w_theta_logbin=0;
  
  par->has_bg=1;

  return 0;
}

double spline_eval	(	double	x,
		SplPar *	spl
	)

Definition at line 71 of file common.c.

References SplPar::intacc, SplPar::spline, SplPar::xf, SplPar::y0, and SplPar::yf.

Referenced by integrand_wl(), integrand_wm(), speval_bis(), transfer_cmblens(), transfer_dens(), transfer_isw(), transfer_lensing(), transfer_magnification(), transfer_rsd(), and window_lensing().

{
  if(x<=spl->x0)
    return spl->y0;
  else if(x>=spl->xf) 
    return spl->yf;
  else
    return gsl_spline_eval(spl->spline,x,spl->intacc);
}

void spline_free

(

SplPar *

spl

)

Definition at line 81 of file common.c.

References SplPar::intacc, and SplPar::spline.

Referenced by compute_wt_single(), init_params(), and param_free().

{
  gsl_spline_free(spl->spline);
  gsl_interp_accel_free(spl->intacc);
  free(spl);
}

SplPar* spline_init	(	int	n,
		double *	x,
		double *	y,
		double	y0,
		double	yf
	)

Definition at line 57 of file common.c.

References dam_malloc(), SplPar::intacc, SplPar::spline, SplPar::x0, SplPar::xf, SplPar::y0, and SplPar::yf.

Referenced by compute_wt_single(), and init_params().

{
  SplPar *spl=(SplPar *)dam_malloc(sizeof(SplPar));
  spl->intacc=gsl_interp_accel_alloc();
  spl->spline=gsl_spline_alloc(gsl_interp_cspline,n);
  gsl_spline_init(spl->spline,x,y,n);
  spl->x0=x[0];
  spl->xf=x[n-1];
  spl->y0=y0;
  spl->yf=yf;

  return spl;
}

double transfer_wrap	(	int	l,
		double	k,
		RunParams *	par,
		char *	trtype,
		int	ibin
	)

Definition at line 107 of file transfers.c.

References dam_report_error(), RunParams::do_cmblens, RunParams::do_isw, RunParams::do_nc, RunParams::do_shear, RunParams::has_dens, RunParams::has_lensing, RunParams::has_rsd, transfer_cmblens(), transfer_dens(), transfer_isw(), transfer_lensing(), transfer_magnification(), and transfer_rsd().

{
  if(!strcmp(trtype,"nc")) {
    if(par->do_nc!=1)
      dam_report_error(1,"Asked to calculate NC transfer function, but can't!\n");
    else {
      double tr=0;
      if(par->has_dens)
    tr+=transfer_dens(l,k,par,ibin);
      if(par->has_rsd)
    tr+=transfer_rsd(l,k,par,ibin);
      if(par->has_lensing)
    tr+=transfer_magnification(l,k,par,ibin);
      return tr;
    }
  }
  if(!strcmp(trtype,"isw")) {
    if(par->do_isw!=1)
      dam_report_error(1,"Asked to calculate ISW transfer function, but can't!\n");
    else
      return transfer_isw(l,k,par);
  }
  if(!strcmp(trtype,"shear")) {
    if(par->do_shear!=1)
      dam_report_error(1,"Asked to calculate shear transfer function, but can't!\n");
    else
      return transfer_lensing(l,k,par,ibin);
  }
  if(!strcmp(trtype,"cmblens")) {
    if(par->do_cmblens!=1)
      dam_report_error(1,"Asked to calculate shear transfer function, but can't!\n");
    else
#ifdef _NOLIM_CMBL
      return transfer_cmblens_nolim(l,k,par);
#else //_NOLIM_CMBL
      return transfer_cmblens(l,k,par);
#endif //_NOLIM_CMBL
  }
  else
    dam_report_error(1,"Unknown transfer type %s\n",trtype);
  return -1.;
}

void write_output

(

RunParams *

par

)

Definition at line 36 of file io.c.

References 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::do_cmblens, RunParams::do_isw, RunParams::do_nc, RunParams::do_shear, RunParams::do_w_theta, RunParams::do_w_theta_logbin, RunParams::lmax, RunParams::n_th, RunParams::n_th_logint, RunParams::prefix_out, RunParams::th_max, RunParams::th_min, write_cl_single(), write_wt_single(), 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, and RunParams::wt_ll_pp.

Referenced by main().

{
  if(par->do_nc) {
    write_cl_single(par->lmax,par->cl_dd,par->prefix_out,"dd");
    if(par->do_shear) {
      write_cl_single(par->lmax,par->cl_d1l2,par->prefix_out,"d1l2");
      write_cl_single(par->lmax,par->cl_d2l1,par->prefix_out,"d2l1");
    }
    if(par->do_cmblens)
      write_cl_single(par->lmax,par->cl_dc,par->prefix_out,"dc");
    if(par->do_isw)
      write_cl_single(par->lmax,par->cl_di,par->prefix_out,"di");
  }
  if(par->do_shear) {
    write_cl_single(par->lmax,par->cl_ll,par->prefix_out,"ll");
    if(par->do_cmblens)
      write_cl_single(par->lmax,par->cl_lc,par->prefix_out,"lc");
    if(par->do_isw)
      write_cl_single(par->lmax,par->cl_li,par->prefix_out,"li");
  }
  if(par->do_cmblens) {
    write_cl_single(par->lmax,par->cl_cc,par->prefix_out,"cc");
    if(par->do_isw)
      write_cl_single(par->lmax,par->cl_ci,par->prefix_out,"ci");
  }
  if(par->do_isw)
    write_cl_single(par->lmax,par->cl_ii,par->prefix_out,"ii");

  if(par->do_w_theta) {
    if(par->do_nc) {
      write_wt_single(par->n_th,par->n_th_logint,par->th_min,par->th_max,
              par->do_w_theta_logbin,par->wt_dd,par->prefix_out,"dd");
      if(par->do_shear) {
    write_wt_single(par->n_th,par->n_th_logint,par->th_min,par->th_max,
            par->do_w_theta_logbin,par->wt_d1l2,par->prefix_out,"d1l2");
    write_wt_single(par->n_th,par->n_th_logint,par->th_min,par->th_max,
            par->do_w_theta_logbin,par->wt_d2l1,par->prefix_out,"d2l1");
      }
      if(par->do_cmblens) {
    write_wt_single(par->n_th,par->n_th_logint,par->th_min,par->th_max,
            par->do_w_theta_logbin,par->wt_dc,par->prefix_out,"dc");
      }
      if(par->do_isw) {
    write_wt_single(par->n_th,par->n_th_logint,par->th_min,par->th_max,
            par->do_w_theta_logbin,par->wt_di,par->prefix_out,"di");
      }
    }
    if(par->do_shear) {
      write_wt_single(par->n_th,par->n_th_logint,par->th_min,par->th_max,
              par->do_w_theta_logbin,par->wt_ll_pp,par->prefix_out,"ll_pp");
      write_wt_single(par->n_th,par->n_th_logint,par->th_min,par->th_max,
              par->do_w_theta_logbin,par->wt_ll_mm,par->prefix_out,"ll_mm");
      if(par->do_cmblens) {
    write_wt_single(par->n_th,par->n_th_logint,par->th_min,par->th_max,
            par->do_w_theta_logbin,par->wt_lc,par->prefix_out,"lc");
      }
      if(par->do_isw) {
    write_wt_single(par->n_th,par->n_th_logint,par->th_min,par->th_max,
            par->do_w_theta_logbin,par->wt_li,par->prefix_out,"li");
      }
    }
    if(par->do_cmblens) {
      write_wt_single(par->n_th,par->n_th_logint,par->th_min,par->th_max,
              par->do_w_theta_logbin,par->wt_cc,par->prefix_out,"cc");
      if(par->do_isw) {
    write_wt_single(par->n_th,par->n_th_logint,par->th_min,par->th_max,
            par->do_w_theta_logbin,par->wt_ci,par->prefix_out,"ci");
      }
    }
    if(par->do_isw) {
      write_wt_single(par->n_th,par->n_th_logint,par->th_min,par->th_max,
              par->do_w_theta_logbin,par->wt_ii,par->prefix_out,"ii");
    }
  }
}