source: Sophya/trunk/Cosmo/SimLSS/pkspectrum.cc@ 4086

#include "machdefs.h"
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <unistd.h>

#include "pexceptions.h"

#include "constcosmo.h"
#include "geneutils.h"
#include "pkspectrum.h"

namespace SOPHYA {

///////////////////////////////////////////////////////////
//******************** InitialPowerLaw ******************//
///////////////////////////////////////////////////////////

InitialPowerLaw::InitialPowerLaw(double n,double a)
  : n_(n), A_(a)
{
}

InitialPowerLaw::InitialPowerLaw(InitialPowerLaw& pkinf)
  : n_(pkinf.n_), A_(pkinf.A_)
{
}

InitialPowerLaw::~InitialPowerLaw(void)
{
}


///////////////////////////////////////////////////////////
//****************** TransfertEisenstein ****************//
///////////////////////////////////////////////////////////

// From Eisenstein & Hu ApJ 496:605-614 1998 April 1 (ou astro-ph/9709112)
TransfertEisenstein::TransfertEisenstein(double h100,double OmegaCDM0,double OmegaBaryon0,double tcmb,bool nobaryon,int lp)
  : lp_(lp)
  , Oc_(OmegaCDM0) , Ob_(OmegaBaryon0) , h100_(h100) , tcmb_(tcmb)
  , nobaryon_(nobaryon) , nooscenv_(0), retpart_(ALL)
{
 zero_();
 Init_();
}

TransfertEisenstein::TransfertEisenstein(TransfertEisenstein& tf)
  : lp_(tf.lp_)
  ,Oc_(tf.Oc_) , Ob_(tf.Ob_) , h100_(tf.h100_) , tcmb_(tf.tcmb_)
  , nobaryon_(tf.nobaryon_) , nooscenv_(tf.nooscenv_), retpart_(tf.retpart_)
{
 zero_();
 Init_();
}

TransfertEisenstein::~TransfertEisenstein(void)
{
}

void TransfertEisenstein::zero_(void)
{
 th2p7_=zeq_=keq_=zd_=Req_=Rd_=s_=ksilk_=alphac_=betac_=bnode_
       =alphab_=betab_=alphag_=sfit_=kpeak_=1.e99;
}

void TransfertEisenstein::Init_(void)
{

  O0_ = Oc_ + Ob_;
  if(nobaryon_) {O0_ = Oc_; Ob_ = 0.;}
  double H0 = 100. * h100_, h2 = h100_*h100_;
  if(lp_) cout<<"h100="<<h100_<<" H0="<<H0<<") Omatter="<<O0_<<" Ocdm="<<Oc_<<" Ob="<<Ob_<<endl;


  if(tcmb_<0.) tcmb_ = T_CMB_Par;
  th2p7_ = tcmb_/2.7;
  double th2p7P4 = th2p7_*th2p7_*th2p7_*th2p7_;
  if(lp_) cout<<"tcmb = "<<tcmb_<<" K = "<<th2p7_<<" *2.7K "<<endl;

  // Formule 2 p 606
  zeq_ = 2.50e4 * O0_ * h2 / th2p7P4;
  if(lp_) cout<<"zeq = "<<zeq_<<" (redshift of matter-radiation equality)"<<endl;

  // Formule 3 p 607
  // (attention ici C=1 : H0 -> H0/C si on utilise la premiere formule)
  //  keq_ = sqrt(2.*O0_*H0*H0*zeq_) / SpeedOfLight_Cst;
  keq_ = 7.46e-2 * O0_ * h2 / (th2p7_*th2p7_);
  if(lp_) cout<<"keq = "<<keq_<<" Mpc^-1 (scale of equality)"<<endl;

  // On s'arrete ici si pas de baryons
  if(nobaryon_) return;

  // Formule 4 p 607
  double b1_eq4 = 0.313*pow(O0_*h2,-0.419)*(1. + 0.607*pow(O0_*h2,0.674));
  double b2_eq4 = 0.238*pow(O0_*h2,0.223);
  zd_ = 1291. * pow(O0_*h2,0.251) / (1.+0.659* pow(O0_*h2,0.828))
              * (1. + b1_eq4*pow(Ob_*h2,b2_eq4));
  if(lp_) cout<<"zd = "<<zd_<<" (Redshift of drag epoch)"<<endl;

  // Formule 5 page 607    (R = 3*rho_baryon/4*rho_gamma)
  Req_ = 31.5*Ob_*h2 / th2p7P4 * (1.e3/zeq_);
  //WARNING: W.Hu code (tf_fit.c) en des-accord avec l'article: zd -> (1+zd)
  Rd_  = 31.5*Ob_*h2 / th2p7P4 * (1.e3/zd_);
  //in tf_fit.c: Rd_  = 31.5*Ob_*h2 / th2p7P4 * (1.e3/(1.+zd_));
  if(lp_) {
    cout<<"Req = "<<Req_<<" Rd = "<<Rd_
        <<" (Photon-baryon ratio at equality/drag epoch)"<<endl;
    cout<<"Sound speed at equality "<<1./sqrt(3.*(1.+Req_))
        <<", at drag "<<1./sqrt(3.*(1.+Rd_))<<" in unit of C"<<endl;
  }

  // Formule 6 p 607
  s_ = 2./(3.*keq_) * sqrt(6./Req_)
      * log( (sqrt(1.+Rd_) + sqrt(Rd_+Req_)) / (1.+sqrt(Req_)) );
  if(lp_) cout<<"s = "<<s_<<" Mpc (sound horizon at drag epoch)"<<endl;

  // Formule 7 page 607
  ksilk_ = 1.6*pow(Ob_*h2,0.52)*pow(O0_*h2,0.73) * (1. + pow(10.4*O0_*h2,-0.95));
  if(lp_) cout<<"ksilk = "<<ksilk_<<" Mpc^-1 (silk damping scale)"<<endl;

  // Formules 10 page 608
  double a1 = pow(46.9*O0_*h2,0.670) * (1. + pow(32.1*O0_*h2,-0.532));
  double a2 = pow(12.0*O0_*h2,0.424) * (1. + pow(45.0*O0_*h2,-0.582));
  alphac_ = pow(a1,-Ob_/O0_) * pow(a2,-pow(Ob_/O0_,3.));
  double b1 = 0.944 / (1. + pow(458.*O0_*h2,-0.708));
  double b2 = pow(0.395*O0_*h2,-0.0266);
  betac_ = 1 / ( 1. + b1*(pow(Oc_/O0_,b2) - 1.) );
  if(lp_) cout<<"alphac = "<<alphac_<<" betac = "<<betac_
               <<" (CDM suppression/log shift)"<<endl;

  // Formule 23 page 610
  bnode_ = 8.41 * pow(O0_*h2,0.435);
  if(lp_) cout<<"bnode = "<<bnode_<<" (sound horizon shift)"<<endl;

  // Formule 14 page 608
  //WARNING: W.Hu code (tf_fit.c) en des-accord avec l'article: (1+zeq) -> zeq
  double y = (1.+zeq_)/(1.+zd_);
  //in tf_fit.c: double y = zeq_/(1.+zd_);
  double s1py = sqrt(1.+y);
  double Gy = y*( -6.*s1py + (2.+3.*y)*log((s1py+1.)/(s1py-1.)) );
  alphab_ = 2.07*keq_*s_*pow(1.+Rd_,-3./4.)*Gy;

  // Formule 24 page 610
  betab_ = 0.5 + Ob_/O0_
         + (3.-2.*Ob_/O0_) * sqrt(pow(17.2*O0_*h2,2.) + 1.);
  if(lp_) cout<<"alphab = "<<alphab_<<" betab = "<<betab_
               <<" (Baryon suppression/envelope shift)"<<endl;

  // Formule 31 page 612
  alphag_ = 1.
          - 0.328*log(431.*O0_*h2)*Ob_/O0_
          + 0.38*log(22.3*O0_*h2)*pow(Ob_/O0_,2.);
  if(lp_) cout<<"alphag = "<<alphag_<<" (gamma suppression in approximate TF)"<<endl;

 // The approximate value of the sound horizon, formule 26 page 611
 sfit_ = 44.5*log(9.83/(O0_*h2)) / sqrt(1.+10.*pow(Ob_*h2,3./4.));  // Mpc
 if(lp_) cout<<"sfit="<<sfit_<<" Mpc (fit to sound horizon)"<<endl;

 // La positoin du premier pic acoustique, formule 25 page 611
 kpeak_ = 5*M_PI/(2.*sfit_) * (1.+0.217*O0_*h2);  // 1/Mpc
 if(lp_) cout<<"kpeak="<<kpeak_<<" Mpc^-1 (fit to wavenumber of first peak)"<<endl;

  return;
}

bool TransfertEisenstein::SetParTo(double h100,double OmegaCDM0,double OmegaBaryon0)
// Changement des valeurs des parametres (suivi de re-init eventuel)
// Si h100,Omega...<=0. alors pas de changement, on garde l'ancienne valeur
{
 bool haschanged = false;

 if(h100>0.) {h100_ = h100; haschanged = true;}
 if(OmegaCDM0>0.) {Oc_ = OmegaCDM0; haschanged = true;}
 if(OmegaBaryon0>0.) {Ob_ = OmegaBaryon0; haschanged = true;}

 // et on recalcule les initialisations
 if(haschanged) Init_();

 return haschanged;
}

void TransfertEisenstein::SetNoOscEnv(unsigned short nooscenv)
// To obtain an approximate form of the non-oscillatory part of the transfert function
// nooscenv = 0 : use the baryon oscillatory part of transfert function (full tf)
// nooscenv = 1 : use approx. paragraph 3.3 p610 (middle of right column)
//                Replace  j0(k*stilde)  ->  [1+(k*stilde)^4]^(-1/4)
// nooscenv = 2 : use formulae 29+30+31 page 612
//                The value of an approximate transfer function that captures
//                the non-oscillatory part of a partial baryon transfer function.
//                In other words, the baryon oscillations are left out,
//                but the suppression of power below the sound horizon is included.
{
 if(nooscenv!=1 && nooscenv!=2) nooscenv = 0;
 nooscenv_ = nooscenv;
}

void TransfertEisenstein::SetReturnPart(ReturnPart retpart)
// To return only baryon or CDM part part of transfert function
// retpart = ALL: return full transfert function
//         = CDM : return only CDM part of transfert function
//         = BARYON : return only Baryon part of transfert function
// WARNING: only relevant for nobaryon_=false AND nooscenv!=2
{
 retpart_ = retpart;
}

void TransfertEisenstein::SetPrintLevel(int lp)
{
 lp_ = lp;
}


double TransfertEisenstein::T0tild(double k,double alphac,double betac)
{
  // Formule 10 p 608
  //double q = k*th2p7_*th2p7_/(O0_*h100_*h100_);
  double q = k/(13.41*keq_);
  // Formule 20 p 610
  double C = (14.2/alphac) + 386./(1.+69.9*pow(q,1.08));
  // Formule 19 p 610
  double x = log(M_E+1.8*betac*q);
  return x / (x + C*q*q);
}

double TransfertEisenstein::operator() (double k)
{

  // --- Pour zero baryon
  //  OU Pour function lissee sans oscillation baryon
  if(nobaryon_  || nooscenv_ == 2) {
    double gamma = O0_*h100_;
    // Calcul de Gamma_eff, formule 30 page 612 (pour fct lissee)
    if( nobaryon_==false && nooscenv_ == 2 )
      gamma = O0_*h100_*(alphag_ + (1.-alphag_)/(1.+pow(0.43*k*sfit_,4.))); // Gamma_eff
    // Formule 28 page 612 : qui est est equivalent a:
    //    q = k / h100_ * th2p7_*th2p7_ / gamma;
    // qui est est equivalent a:
    //    q = k / (13.41 * keq)                   pour Ob=0
    //    q = k / (13.41 * keq) * (O0*h/Gamma)    pour le spectre lisse
    // Les resultats sont legerement differents a cause des valeurs approx.
    // des constantes numeriques: on prend comme W.Hu (tf_fit.c)
    //double q = k / h100_ * th2p7_*th2p7_ / gamma;  // Mpc^-1
    double q = k/(13.41*keq_) * (O0_*h100_/gamma);  // Mpc^-1
    // Formules 29 page 612
    double l0 = log(2.*M_E + 1.8*q);
    double c0 = 14.2 + 731./(1.+62.5*q);
    return l0 / (l0 + c0*q*q);
  }

  // --- Pour CDM + Baryons
  // --- CDM
  double f = 1. / (1. + pow(k*s_/5.4,4.));
  double Tc = f*T0tild(k,1.,betac_) + (1.-f)*T0tild(k,alphac_,betac_);
  if(retpart_ == CDM) return Tc; 

  // --- Baryons
  // Formule 22 page 610
  double stilde, ksbnode = k*s_/bnode_;
  if(ksbnode<0.001) stilde =s_ * ksbnode;
     else   stilde = s_ / pow(1. + pow(1./ksbnode,3.), 1./3.);
  // Formule 21 page 610
  double j0kst = 0.;
  if(nooscenv_ == 1) {
    j0kst = pow(1.+pow(k*stilde,4.) , -1./4.); //lissee sans oscillation baryon
  } else {
    double x = k*stilde;
    if(x<0.01) j0kst = 1. - x*x/6.*(1.-x*x/20.);
      else j0kst = sin(x)/x;
    //cout<<"DEBUG: k="<<k<<" stilde="<<stilde<<" x="<<x<<" j0kst="<<j0kst<<endl;
  }
  double Tb = T0tild(k,1.,1.) / (1. + pow(k*s_/5.2,2.));
  Tb += alphab_/(1.+pow(betab_/(k*s_),3.)) * exp(-pow(k/ksilk_,1.4));
  Tb *= j0kst;
  if(retpart_ == BARYON) return Tb;

  // --- Total
  double T = (Ob_/O0_)*Tb + (Oc_/O0_)*Tc;

  return T;
}

double TransfertEisenstein::KPeak(void)
// Position du premier pic acoustic
{
 if(nobaryon_) return -1.;
 return kpeak_;
}


///////////////////////////////////////////////////////////
//******************* TransfertTabulate *****************//
///////////////////////////////////////////////////////////

TransfertTabulate::TransfertTabulate(void)
: kmin_(1.) , kmax_(-1.) , interptyp_(0)
{
  k_.resize(0);
  tf_.resize(0);
}

TransfertTabulate::TransfertTabulate(TransfertTabulate& tf)
: kmin_(tf.kmin_) , kmax_(tf.kmax_) , interptyp_(tf.interptyp_) , k_(tf.k_) , tf_(tf.tf_)
{
}

TransfertTabulate::~TransfertTabulate(void)
{
}

void TransfertTabulate::SetInterpTyp(int typ)
// see comment in InterpTab
{
 if(typ<0) typ=0; else if(typ>2) typ=2;
 interptyp_ = typ;
}

double TransfertTabulate::operator() (double k)
{
 return InterpTab(k,k_,tf_,interptyp_);
}

int TransfertTabulate::ReadCMBFast(string filename,double h100,double OmegaCDM0,double OmegaBaryon0)
{
 FILE *file = fopen(filename.c_str(),"r");
 if(file==NULL) return -1;
 cout<<"TransfertTabulate::ReadCMBFast: fn="<<filename<<" h100="<<h100
     <<" OmegaCDM0="<<OmegaCDM0<<" OmegaBaryon0="<<OmegaBaryon0<<endl;

 const int lenline = 512;
 char *line = new char[lenline];

 k_.resize(0); tf_.resize(0);
 double tmax = -1.;
 while ( fgets(line,lenline,file) != NULL ) {
   double k,tc,tb,tf;
   sscanf(line,"%lf %lf %lf",&k,&tc,&tb);
   k *= h100;     // convert h Mpc^-1  ->  Mpc^-1
   tf = (OmegaCDM0*tc+OmegaBaryon0*tb)/(OmegaCDM0+OmegaBaryon0);
   if(tf>tmax) tmax = tf;
   k_.push_back(k);
   tf_.push_back(tf);
 }

 cout<<"TransfertTabulate::ReadCMBFast: nread="<<tf_.size()<<" tf_max="<<tmax<<endl;
 delete [] line;
 if(tf_.size()==0) return (int)tf_.size();

 for(unsigned int i=0;i<tf_.size();i++) tf_[i] /= tmax;

 return (int)tf_.size();
}

int TransfertTabulate::ReadCAMB(string filename, double h100)
{
 FILE *file = fopen(filename.c_str(),"r");
 if(file==NULL) return -1;
 cout<<"TransfertTabulate::ReadCAMB: fn="<<filename<<" h100="<<h100<<endl;

 const int lenline = 512;
 char *line = new char[lenline];

 k_.resize(0); tf_.resize(0);
 double tmax = -1.;
 while ( fgets(line,lenline,file) != NULL ) {
   double k,tcdm,tbar,tph,trel,tnu,ttot, tf;
   sscanf(line,"%lf %lf %lf %lf %lf %lf %lf",&k,&tcdm,&tbar,&tph,&trel,&tnu,&ttot);
   k *= h100;     // convert h Mpc^-1  ->  Mpc^-1
   tf = ttot;
   if(tf>tmax) tmax = tf;
   k_.push_back(k);
   tf_.push_back(tf);
 }

 cout<<"TransfertTabulate::ReadCAMB nread="<<tf_.size()<<" tf_max="<<tmax<<endl;
 delete [] line;
 if(tf_.size()==0) return (int)tf_.size();

 for(unsigned int i=0;i<tf_.size();i++) tf_[i] /= tmax;

 return (int)tf_.size();
}


///////////////////////////////////////////////////////////
//********************* GrowthFactor ********************//
///////////////////////////////////////////////////////////
double GrowthFactor::DsDz(double z, double)
{
  cout<<"GrowthFactor::DsDz_Error not implemented"<<endl;
  throw AllocationError(" GrowthFactor::DsDz_Error not implemented");
}

///////////////////////////////////////////////////////////
//********************* GrowthEisenstein ********************//
///////////////////////////////////////////////////////////

// From Eisenstein & Hu ApJ 496:605-614 1998 April 1
// Pour avoir D(z) = 1/(1+z) faire: OmegaMatter0=1 OmegaLambda0=0
GrowthEisenstein::GrowthEisenstein(double OmegaMatter0,double OmegaLambda0)
  : O0_(OmegaMatter0) , Ol_(OmegaLambda0)
{
  if(OmegaMatter0==0.) {
    cout<<"GrowthEisenstein::GrowthEisenstein_Error: bad OmegaMatter0  value : "<<OmegaMatter0<<endl;
    throw ParmError("GrowthEisenstein::GrowthEisenstein_Error:  bad OmegaMatter0  value");
  }
}

GrowthEisenstein::GrowthEisenstein(GrowthEisenstein& d1)
  : O0_(d1.O0_) , Ol_(d1.Ol_)
{
}

GrowthEisenstein::~GrowthEisenstein(void)
{
}

double GrowthEisenstein::operator() (double z)
// see Formulae A4 + A5 + A6 page 614
{
 z += 1.;
 double z2 = z*z, z3 = z2*z;

 // Calcul de la normalisation (pour z=0 -> growth=1.)
 double D1z0 = pow(O0_,4./7.) - Ol_ + (1.+O0_/2.)*(1.+Ol_/70.);
 D1z0 = 2.5*O0_ / D1z0;

 // Calcul du growthfactor pour z
 double Ok = 1. - O0_ - Ol_;
 double den = Ol_ + Ok*z2 + O0_*z3;
 double o0z = O0_ *z3 / den;
 double olz = Ol_ / den;

 double D1z = pow(o0z,4./7.) - olz + (1.+o0z/2.)*(1.+olz/70.);
 D1z = 2.5*o0z / z / D1z;

 return D1z / D1z0;
}

double GrowthEisenstein::DsDz(double z,double dzinc)
// y-y0 = a*(x-x0)^2 + b*(x-x0)
// dy = a*dx^2 + b*dx   avec  dx = x-x0
// dy'(dx) = 2*a*dx + b -> pour x=x0 on a dy'(0) = b
{
 if(z<0. || dzinc<=0.) {
   cout<<"GrowthEisenstein::DsDz_Error: z<0 or dzinc<=0. !"<<endl;
   throw ParmError("GrowthEisenstein::DsDz_Error: z<0 or dzinc<=0. !");
 }

 double z1, z2;
 if(z>dzinc/2.) {
   // cas ou z est suffisamment loin de zero
   // resolution avec 2 points encadrant x0=z
   z1 = z - dzinc; if(z1<0.) z1 = 0.;
   z2 = z + dzinc;
 } else {
   // cas ou z est proche de zero
   // resolution avec 2 points au dessus, x0=z1
   z1 = z + dzinc;
   z2 = z + 2.*dzinc;
 }

 double gz  = (*this)(z);
 double dgz1 = (*this)(z1) - gz;
 double dgz2 = (*this)(z2) - gz;

 z1 -= z;
 z2 -= z;
 return (dgz2*z1*z1 - dgz1*z2*z2)/(z1*z2*(z1-z2));
}

void GrowthEisenstein::SetParTo(double OmegaMatter0,double OmegaLambda0)
{
 if(OmegaMatter0>0.) O0_ = OmegaMatter0;
 Ol_ = OmegaLambda0;
}

bool GrowthEisenstein::SetParTo(double OmegaMatter0)
// idem precedent sans changer OmegaLambda0
{
 if(OmegaMatter0<=0.) return false;
 O0_ = OmegaMatter0;
 return true;
}


///////////////////////////////////////////////////////////
//********************** PkSpectrum *********************//
///////////////////////////////////////////////////////////

PkSpectrum::PkSpectrum(void)
  : zref_(0.) , scale_(1.) , typspec_(PK)
{
}

PkSpectrum::PkSpectrum(PkSpectrum& pk)
  : zref_(pk.zref_) , scale_(pk.scale_) , typspec_(pk.typspec_)
{
}


///////////////////////////////////////////////////////////
//********************** PkSpecCalc *********************//
///////////////////////////////////////////////////////////

PkSpecCalc::PkSpecCalc(InitialSpectrum& pkinf,TransfertFunction& tf,GrowthFactor& d1,double zref)
  : pkinf_(pkinf) , tf_(tf) , d1_(d1)
{
  zref_ = zref;
}

PkSpecCalc::PkSpecCalc(PkSpecCalc& pkz)
  : pkinf_(pkz.pkinf_) , tf_(pkz.tf_) , d1_(pkz.d1_)
{
}

PkSpecCalc::~PkSpecCalc(void) 
{
}

double PkSpecCalc::operator() (double k)
{
  return (*this)(k,zref_);
}

double PkSpecCalc::operator() (double k,double z)
{
  double tf = tf_(k);
  double pkinf = pkinf_(k);
  double d1 = d1_(z);

  double v = pkinf * (tf*tf) * (d1*d1);
  if(typspec_ == DELTA) v *= k*k*k/(2.*M_PI*M_PI);

  return scale_ * v;
}

///////////////////////////////////////////////////////////
//********************** PkTabulate *********************//
///////////////////////////////////////////////////////////

PkTabulate::PkTabulate(void)
  : kmin_(1.) , kmax_(-1.) , interptyp_(0), d1_(NULL)
{
  k_.resize(0);
  pk_.resize(0);
}

PkTabulate::PkTabulate(PkTabulate& pkz)
 : kmin_(pkz.kmin_) , kmax_(pkz.kmax_) , interptyp_(pkz.interptyp_)
 , k_(pkz.k_) , pk_(pkz.pk_)
 , d1_(pkz.d1_)
{
}

PkTabulate::~PkTabulate(void) 
{
}

void PkTabulate ::SetInterpTyp(int typ)
// see comment in InterpTab
{
 if(typ<0) typ=0; else if(typ>2) typ=2;
 interptyp_ = typ;
}

double PkTabulate::operator() (double k)
{
  double v = InterpTab(k,k_,pk_,interptyp_);
  if(typspec_ == DELTA) v *= k*k*k/(2.*M_PI*M_PI);
  return scale_ * v;
}

double PkTabulate::operator() (double k,double z)
{
  cout<<"PkTabulate::operator(double k,double z)_Error: not implemented"<<endl;
  throw AllocationError("PkTabulate::operator(double k,double z)_Error: not implemented");
}

void PkTabulate::SetZ(double z)
{
  if(d1_ == NULL) {
    cout<<"PkTabulate::SetZ_Error: d1==NULL, no possible redshift change for tabulated Pk"<<endl;
    throw ParmError("PkTabulate::SetZ_Error: d1==NULL, no possible redshift change for tabulated Pk");
  }
  if(pk_.size() == 0) {
    cout<<"PkTabulate::SetZ_Error: pk_.size()==0, no possible redshift change for tabulated Pk"<<endl;
    throw ParmError("PkTabulate::SetZ_Error: pk_.size()==0, no possible redshift change for tabulated Pk");
  }

  double zold = zref_;
  if(fabs(z-zold)<1.e-4) return;

  zref_ = z;
  double d0 = (*d1_)(zold);
  double d1 = (*d1_)(zref_);
  double conv = d1*d1 / (d0*d0);
  cout<<"PkTabulate::SetZ: change redshift from "<<zold<<" (d="<<d0
      <<") to "<<zref_<<" (d="<<d1<<") conv="<<conv<<endl;
  for(unsigned int i=0;i<pk_.size();i++) pk_[i] *= conv;
}

int PkTabulate::ReadCAMB(string filename, double h100tab, double zreftab)
{
 FILE *file = fopen(filename.c_str(),"r");
 if(file==NULL) return -1;
 cout<<"PkTabulate::ReadCAMB: fn="<<filename<<" h100="<<h100tab<<" zreftab = "<<zreftab<<endl;

 const int lenline = 512;
 char *line = new char[lenline];
 double h = h100tab, h3 = pow(h100tab,3.);

 k_.resize(0); pk_.resize(0);
 double kmax = 0., pkmax = 0.;
 while ( fgets(line,lenline,file) != NULL ) {
   double k, pk;
   sscanf(line,"%lf %lf",&k,&pk);
   k *= h;      // convert h    Mpc^-1  ->  Mpc^-1
   pk /= h3;    // convert h^-3 Mpc^3   ->  Mpc^3
   if(pk>pkmax) {pkmax = pk; kmax = k;}
   k_.push_back(k);
   pk_.push_back(pk);
 }

 zref_ = zreftab;
 cout<<"  nread="<<pk_.size()<<" zref="<<GetZ()<<" , k,pk: max="<<kmax<<","<<pkmax;
 if(pk_.size()>0) cout<<" [0]="<<k_[0]<<","<<pk_[0]
                      <<" [n]="<<k_[pk_.size()-1]<<","<<pk_[pk_.size()-1];
 cout<<endl;

 delete [] line;

 return (int)pk_.size();
}

///////////////////////////////////////////////////////////
//********************* PkEisenstein ********************//
///////////////////////////////////////////////////////////

PkEisenstein::PkEisenstein(InitialPowerLaw& pkinf,TransfertEisenstein& tf,GrowthEisenstein& d1,double zref)
  : pkinf_(pkinf) , tf_(tf) , d1_(d1)
{
  zref_ = zref;
}

PkEisenstein::PkEisenstein(PkEisenstein& pkz)
  : pkinf_(pkz.pkinf_) , tf_(pkz.tf_) , d1_(pkz.d1_)
{
}

PkEisenstein::~PkEisenstein(void) 
{
}

double PkEisenstein::operator() (double k)
{
  return (*this)(k,zref_);
}

double PkEisenstein::operator() (double k,double z)
{
  double tf = tf_(k);
  double pkinf = pkinf_(k);
  double d1 = d1_(z);

  double v = pkinf * (tf*tf) * (d1*d1);
  if(typspec_ == DELTA) v *= k*k*k/(2.*M_PI*M_PI);

  return scale_ * v;
}


///////////////////////////////////////////////////////////
//******************* VarianceSpectrum ******************//
///////////////////////////////////////////////////////////

VarianceSpectrum::VarianceSpectrum(GenericFunc& pk,double R,TypeFilter typfilter)
  : pk_(pk)
{
  SetRadius(R);
  SetFilter(typfilter);
}

VarianceSpectrum::VarianceSpectrum(VarianceSpectrum& vpk)
  : pk_(vpk.pk_) , R_(vpk.R_)
{
  SetFilter(vpk.typfilter_);
}

VarianceSpectrum::~VarianceSpectrum(void)
{
}

void VarianceSpectrum::SetRadius(double R)
// R = taille du filter top-hat ou gaussien
{
 if(R<=0.) {
    cout<<"VarianceSpectrum::SetRadius_Error: R<=0"<<endl;
    throw ParmError("VarianceSpectrum::SetRadius_Error: R<=0");
  }
  R_ = R;
}

//------------------------------------
void VarianceSpectrum::SetFilter(TypeFilter typfilter)
// typfilter = TOPHAT : spherical 3D top-hat
//           = GAUSSIAN : spherical 3D gaussian
//           = NOFILTER : no filter juste integrate spectrum)
// Remarque:
//   la meilleure approximation du filtre top-hat (R) est un filtre gaussien avec (Rg=R/sqrt(5))
{
  typfilter_ = typfilter;
}

void VarianceSpectrum::SetInteg(double dperc,double dlogkinc,double dlogkmax,unsigned short glorder)
// ATTENTION: on n'integre pas f(k)*dk mais k*f(k)*d(log10(k))
// see argument details in function IntegrateFuncLog (geneutils.cc)
{
  dperc_ = dperc;  if(dperc_<=0.) dperc_ = 0.1;
  dlogkinc_ = dlogkinc;
  dlogkmax_ = dlogkmax;
  glorder_ = glorder;
}


//------------------------------------
double VarianceSpectrum::Filter2(double x)
// ATTENTION: c'est le filtre au carre qui est renvoye
{
  // Just integrate the spectrum without filtering
  if(typfilter_ == NOFILTER) return 1.;

  double x2 = x*x;
  // Filtre gaussien G(x) = exp(-x^2/2)
  //        remarque G(x)^2 = exp(-x^2)
  // on prend le DL de G(x)^2 pour x->0 a l'ordre O(x^6)
  //             DL(x) = 1-x^2*(1-x^2/2)
  //             pour x<0.01  |DL(x)-G(X)^2|<2.0e-13
  if(typfilter_ == GAUSSIAN)
    {if(x<0.01) return 1.-x2*(1.-x2/2.); else return exp(-x2);}

  // Filtre top-hat T(x) = 3*(sin(x)-x*cos(x))/x^3
  // --- Gestion de la pseudo-divergence pour x->0
  // on prend le DL de T(x)^2 pour x->0 a l'ordre O(x^7)
  //             DL(x) = 1-x^2/5*(1-3*x^2/35*(1-4*x^2/81))
  //             pour x<0.1  |DL(x)-T(X)^2|<2.5e-13
  double f2=0.;
  if(x<0.1) {
    f2 = 1.-x2/5.*(1.-3.*x2/35.*(1.-4.*x2/81.));
  } else {
    f2 = 3.*(sin(x)-x*cos(x))/(x2*x);
    f2 *= f2;
  }
  return f2;
  
}

double VarianceSpectrum::Variance(double kmin,double kmax)
// Compute variance of spectrum pk_ by integration
// Input:
//     kmin,kmax = bornes en k de l'integrale pour calculer la variance
// Return:
//     valeur de la variance (sigma^2)
// Remarque:
//   la variance renvoyee est la variance de la masse
{
  if(kmin<=0 || kmax<=0. || kmin>=kmax) {
    cout<<"VarianceSpectrum::Variance_Error: kmin<=0 or kmax<=0 or kmin>=kmax"<<endl;
    throw ParmError("VarianceSpectrum::Variance_Error: kmin<=0 or kmax<=0 or kmin>=kmax");
  }

  double lkmin = log10(kmin), lkmax = log10(kmax);

  double var = IntegrateFuncLog(*this,lkmin,lkmax,dperc_,dlogkinc_,dlogkmax_,glorder_);

  return var;
}

//------------------------------------
double VarianceSpectrum::FindMaximum(double kmin,double kmax,double eps)
// Retourne le maximum de la fonction a integrer
// La recherche a lieu entre [kmin,kmax] par pas logarithmiques
// Input:
//     kmin,kmax : intervalle de recherche
//     eps : precision requise sur les valeurs
// Return:
//     position (en k) du maximum
{
  if(kmin<=0 || kmax<=0. || kmin>=kmax) {
    cout<<"VarianceSpectrum::FindMaximum_Error: kmin<=0 or kmax<=0 or kmin>=kmax || eps<=0"<<endl;
    throw ParmError("VarianceSpectrum::FindMaximum_Error: kmin<=0 or kmax<=0 or kmin>=kmax || eps<=0");
  }

  int n = 10; // toujours >2
  double lkmin = log10(kmin), lkmax = log10(kmax), dlk = (lkmax-lkmin)/n;

  double lkfind=lkmin, pkfind=-1.;
  while(1) {
    for(int i=0; i<=n; i++) {
      double lk = lkmin  + i*dlk;
      double v = (*this)(pow(10.,lk));
      if(v<pkfind) continue;
      pkfind = v; lkfind = lk;
    }
    //cout<<"VarianceSpectrum::FindMaximum: lkfind="<<lkfind<<" pkfind="<<pkfind
    //    <<" lkmin,max="<<lkmin<<","<<lkmax<<" dlk="<<dlk<<endl;
    // --- Convergence si l'encadrement de "kfind" est tel que "dk/kfind<eps"
    // On a dk = 10^(lkfind+dlk) - 10^(lkfind-dlk) = kfind * (10^(dlk) - 10^(-dlk))
    if( pow(10.,dlk)-pow(10.,-dlk) < eps ) break;
    if(lkfind-dlk>lkmin) lkmin = lkfind-dlk;
    if(lkfind+dlk<lkmax) lkmax = lkfind+dlk;
    dlk = (lkmax-lkmin)/n;
  }

  return pow(10.,lkfind);
}

int VarianceSpectrum::FindLimits(double high,double &kmin,double &kmax,double eps)
// Retourne "[kmin,kmax]" tel que la fonction a integrer soit "f(k) <= high"
//   La recherche a lieu entre [kmin,kmax] par pas logarithmiques
// Input:
//     kmin,kmax : intervalle de recherche
//     eps : precision requise sur les valeurs kmin et kmax
// Output:
//     kmin,kmax telles que "f(k) <= high"
// Return:
//     rc  = 0 si OK
//     rc |= 1 "f(kmin) >= high"   (bit0 =1)
//     rc |= 2 "f(kmax) >= high"   (bit1 =1)
//     rc |= 4 "f(k) < high pour tout k"   (bit2 =1)
{
  if(kmin<=0 || kmax<=0. || kmin>=kmax  || eps<=0.) {
    cout<<"VarianceSpectrum::FindLimits_Error: kmin<=0 or kmax<=0 or kmin>=kmax or eps<=0"<<endl;
    throw ParmError("VarianceSpectrum::FindLimits_Error: kmin<=0 or kmax<=0 or kmin>=kmax || eps<=0");
  }

  int n = 10; // toujours >2

  int rc = 0;
  double lkmin,lkmax,dlk,lkfind;

  // --- Find kmin
  lkmin=log10(kmin); lkmax=log10(kmax); dlk=(lkmax-lkmin)/n;
  while(1) {
    lkfind = lkmin;
    for(int i=0;i<=n;i++) {
      if( (*this)(pow(10,lkfind)) >= high ) break;
      lkfind = lkmin + i*dlk;
    }
    //cout<<"VarianceSpectrum::FindLimits[kmin]: lkfind="<<lkfind
    //    <<" lkmin,max="<<lkmin<<","<<lkmax<<" dlk="<<dlk<<endl;
    if(fabs(lkfind-lkmax)<dlk/2.) {rc |= 4; return rc;} // protect against f(k)<high for all k
    if( pow(10.,dlk)-pow(10.,-dlk) < eps ) break;
    if(lkfind-dlk>lkmin) lkmin = lkfind-dlk;
    if(lkfind+dlk<lkmax) lkmax = lkfind+dlk;
    dlk = (lkmax-lkmin)/n;
  }
  if(lkfind-lkmin<dlk/2.) rc |= 1;  // f(kmin) >= high
  else kmin = pow(10.,lkmin);
  //cout<<"rc="<<rc<<" lkmin="<<lkmin<<"  pk="<<(*this)(pow(10.,lkmin))<<endl;

  // --- Find kmax
  lkmin=log10(kmin); lkmax=log10(kmax); dlk=(lkmax-lkmin)/n;
  while(1) {
    lkfind=lkmax;
    for(int i=0;i<=n;i++) {
      if( (*this)(pow(10,lkfind)) >= high ) break;
      lkfind -= dlk;
      lkfind = lkmax - i*dlk;
    }
    //cout<<"VarianceSpectrum::FindLimits[kmax]: lkfind="<<lkfind
    //    <<" lkmin,max="<<lkmin<<","<<lkmax<<" dlk="<<dlk<<endl;
    if( pow(10.,dlk)-pow(10.,-dlk) < eps ) break;
    if(lkfind-dlk>lkmin) lkmin = lkfind-dlk;
    if(lkfind+dlk<lkmax) lkmax = lkfind+dlk;
    dlk = (lkmax-lkmin)/n;
  }
  if(lkmax-lkfind<dlk/2.) rc |= 2;  // f(kmax) >= high
  else kmax = pow(10.,lkmax);
  //cout<<"rc="<<rc<<" lkmax="<<lkmax<<"  pk="<<(*this)(pow(10.,lkmax))<<endl;

  return rc;
}

}  // Fin namespace SOPHYA