Example #1
0
double intersection_point()
{
    gsl_root_fdfsolver* s;
    odesolver_t funcsolver;
    
    gsl_function_fdf fdf = 
        {.f = &func,
         .df = &dfunc,
         .fdf = &func_fdf,
         .params = &funcsolver};
    double x0, x=0.;
    
    ode_alloc(&funcsolver);
    
    s = gsl_root_fdfsolver_alloc(gsl_root_fdfsolver_steffenson);
    gsl_root_fdfsolver_set(s, &fdf, x);
    
    int status;
    do {
        gsl_root_fdfsolver_iterate(s);
        x0 = x;
        x = gsl_root_fdfsolver_root(s);
        status = gsl_root_test_delta(x, x0, 0, 1e-12);
    } while(status == GSL_CONTINUE);
    
    double root = gsl_root_fdfsolver_root(s);
    gsl_root_fdfsolver_free(s);
    
    ode_free(&funcsolver);
    
    if(status == GSL_SUCCESS)
        return root;
    else
        return -1.;
}
Example #2
0
void
test_fdf_e (const gsl_root_fdfsolver_type * T, 
            const char * description, gsl_function_fdf *fdf,
            double root, double correct_root)
{
  int status;
  size_t iterations = 0;
  double prev = 0 ;

  gsl_root_fdfsolver * s = gsl_root_fdfsolver_alloc(T);
  status = gsl_root_fdfsolver_set (s, fdf, root) ;

  gsl_test (status, "%s (set), %s", T->name, description);

  do 
    {
      iterations++ ;
      prev = gsl_root_fdfsolver_root(s);
      gsl_root_fdfsolver_iterate (s);
      status = gsl_root_test_delta(gsl_root_fdfsolver_root(s), prev, 
                                   EPSABS, EPSREL);
    }
  while (status == GSL_CONTINUE && iterations < MAX_ITERATIONS);

  gsl_test (!status, "%s, %s", gsl_root_fdfsolver_name(s), 
            description, gsl_root_fdfsolver_root(s) - correct_root);
  gsl_root_fdfsolver_free(s);
}
Example #3
0
void satellite_free()
{
  if(!solver) {
    gsl_root_fdfsolver_free(solver);
    solver= 0;
  }
}
double tsolve_findroot_E(struct Tsolve * theTsolve){
    int status;
    int iter = 0, max_iter = 100;
    const gsl_root_fdfsolver_type *T;
    gsl_root_fdfsolver *s;
    gsl_function_fdf FDF;
    T = gsl_root_fdfsolver_newton;
    s = gsl_root_fdfsolver_alloc (T);

    FDF.f = &tsolve_E_eq;
    FDF.df = &tsolve_E_eq_deriv;
    FDF.fdf = &tsolve_E_eq_fdf;
    FDF.params = theTsolve;

    double Temp0; //store previous iteration value
    double Temp = theTsolve->guess; // set initial guess here
    gsl_root_fdfsolver_set (s, &FDF, Temp);

    do
    {
        iter++;
        status = gsl_root_fdfsolver_iterate (s);
        Temp0 = Temp;
        Temp = gsl_root_fdfsolver_root (s);
        status = gsl_root_test_delta (Temp, Temp0, 0, 1e-12);
    }
    while (status == GSL_CONTINUE && iter < max_iter);
    gsl_root_fdfsolver_free (s);

    return(Temp);
}
Example #5
0
CAMLprim value ml_gsl_root_fdfsolver_free(value s)
{
    struct callback_params *p=Fparams_val(s);
    remove_global_root(&(p->closure));
    stat_free(p);
    gsl_root_fdfsolver_free(FDFsolver_val(s));
    return Val_unit;
}
Example #6
0
double
  fun_root (void *params)
{
   int status;
   int iter = 0, max_iter = 100;
   int i;
   const gsl_root_fdfsolver_type *T;
   gsl_root_fdfsolver *s;
   double x0, x, y;

   gsl_function_fdf FDF_ri;
   struct fun_root_params *p 
     = (struct fun_root_params *) params;

   FDF_ri.f = &fun_ri;
   FDF_ri.df = &fun_ri_deriv;
   FDF_ri.fdf = &fun_ri_fdf;
   FDF_ri.params = p;

   x = p->rf; 

   T = gsl_root_fdfsolver_secant;
   s = gsl_root_fdfsolver_alloc (T);
   gsl_root_fdfsolver_set (s, &FDF_ri, x);

   do
     {
    iter++;
    status = gsl_root_fdfsolver_iterate (s);
    x0 = x;
    x = gsl_root_fdfsolver_root (s);
    status = gsl_root_test_delta (x, x0, 0, 0.0000001);

//        printf ("%5d %10.7f %10.7f\n",
//                iter, x, x - x0);
     }
   while (status == GSL_CONTINUE && iter < max_iter);

//   printf ("%5d %10.7f %10.7f %10.7f\n",
//      iter, p->rf, x, x - x0);

   y = x;
   gsl_root_fdfsolver_free (s);

   return y;
}
Example #7
0
void
test_fdf (const gsl_root_fdfsolver_type * T, const char * description, 
        gsl_function_fdf *fdf, double root, double correct_root)
{
  int status;
  size_t iterations = 0;
  double prev = 0 ;

  gsl_root_fdfsolver * s = gsl_root_fdfsolver_alloc(T);
  gsl_root_fdfsolver_set (s, fdf, root) ;

  do 
    {
      iterations++ ;
      prev = gsl_root_fdfsolver_root(s);
      gsl_root_fdfsolver_iterate (s);
      status = gsl_root_test_delta(gsl_root_fdfsolver_root(s), prev, 
                                   EPSABS, EPSREL);
    }
  while (status == GSL_CONTINUE && iterations < MAX_ITERATIONS);

  gsl_test (status, "%s, %s (%g obs vs %g expected) ", 
            gsl_root_fdfsolver_name(s), description, 
            gsl_root_fdfsolver_root(s), correct_root);

  if (iterations == MAX_ITERATIONS)
    {
      gsl_test (GSL_FAILURE, "exceeded maximum number of iterations");
    }

  /* check the validity of the returned result */

  if (!WITHIN_TOL (gsl_root_fdfsolver_root(s), correct_root, 
                   EPSREL, EPSABS))
    {
      gsl_test (GSL_FAILURE, "incorrect precision (%g obs vs %g expected)", 
                gsl_root_fdfsolver_root(s), correct_root);

    }
  gsl_root_fdfsolver_free(s);
}
Example #8
0
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;
}