source: Sophya/trunk/Cosmo/SimLSS/cosmocalc.cc@ 3193

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

#include "pexceptions.h"
#include "cspline.h"

#include "constcosmo.h"
#include "cosmocalc.h"
#include "integfunc.h"


///////////////////////////////////////////////////////////
//*********************** CosmoCalc *********************//
///////////////////////////////////////////////////////////

//----------------------------------------------------------
// flat = 0 : no compute Otot from other
//      = 1 : change Omatter to get Otot=1
//      = 2 : change Olambda to get Otot=1
//      = 3 : change Orelat to get Otot=1
// usespline = "true" : compute integrale then use spline to extrapolate
//           = "false" : compute integrale everytime
// zmax : maximum redshift(only if usespline=true)
         
CosmoCalc::CosmoCalc(unsigned short flat,bool usespline,double zmax)
  : _flat(flat),
    _zold(-1.) , _integval(0.),
    _usespline(usespline), _computespl(true), _zmax(zmax), _spline(NULL),
    _nspl(0), _xspl(NULL), _yspl(NULL)
{
  if(_usespline && _zmax<=0.) {
    cout<<"CosmoCalc::CosmoCalc: Error bad _zmax value    zmax="<< _zmax<<endl;
    throw ParmError("CosmoCalc::UseSpline: Error bad _zmax value");
  }
  DefaultParam();
  SetInteg();
}

CosmoCalc::CosmoCalc(CosmoCalc& univ)
  : _spline(NULL), _xspl(NULL), _yspl(NULL)
{
  Clone(univ);
  if(_usespline && _zmax<=0.) {
    cout<<"CosmoCalc::CosmoCalc: Error bad _zmax value    zmax="<< _zmax<<endl;
    throw ParmError("CosmoCalc::UseSpline: Error bad _zmax value");
  }
}

CosmoCalc::~CosmoCalc(void)
{
  if(_spline != NULL) delete _spline; _spline = NULL;
  if(_xspl != NULL) delete [] _xspl; _xspl = NULL;
  if(_yspl != NULL) delete [] _yspl; _yspl = NULL;
}

void CosmoCalc::Clone(CosmoCalc& univ)
{
 _flat = univ._flat;
 _h100 = univ._h100;
 _H0 = univ._H0;
 _Olambda0 = univ._Olambda0;
 _W0 = univ._W0;
 _Omatter0 = univ._Omatter0;
 _Obaryon0 = univ._Obaryon0;
 _Orelat0 = univ._Orelat0;
 _Otot0 = univ._Otot0;
 _Ocurv0 = univ._Ocurv0;
 _Dhubble = univ._Dhubble;

 _dperc = univ._dperc;
 _dzinc = univ._dzinc;
 _dzmax = univ._dzmax;
 _glorder = univ._glorder;
 if(_xgausl.size()>0) {
   _xgausl.resize(0); _wgausl.resize(0);
   for(int i=0;i<(int)_xgausl.size();i++) {
     _xgausl.push_back(univ._xgausl[i]);
     _wgausl.push_back(univ._wgausl[i]);
   }
 }

 _zold = -1.;
 _integval = -1.;

 _usespline = univ._usespline;
 _computespl = true;
 _zmax = univ._zmax;
 _nspl = 0;
 if(_spline) delete _spline; _spline = NULL;
 if(_xspl) delete [] _xspl; _xspl = NULL;
 if(_yspl) delete [] _yspl; _yspl = NULL;
}

//----------------------------------------------------------
// On va couper l'intervalle entre [0,zmax]:
// On parcourt [0,zmax] par pas de dzinc
// et on cree un intervalle
//     - si la fonction varie de plus de "dperc"
//     - ou si l'increment en z est superieur a "dzmax"
void CosmoCalc::SetInteg(double dperc,double dzinc,double dzmax,unsigned short order)
{
  _dperc = fabs(dperc);

  _dzinc = fabs(dzinc);
  if(_dzinc>_zmax/5.) _dzinc = _zmax/5.; // Protection against big dzinc

  _dzmax = fabs(dzmax);
  if(_dzmax<_dzinc) _dzmax = _dzinc;

  _glorder = order;
  if(_glorder<=1) _glorder = 4;
  Compute_GaussLeg(_glorder,_xgausl,_wgausl,0.,1.);

  _computespl=true;
}

void CosmoCalc::SetObaryon0(double v)
{
  _Obaryon0 = v;
  if(_Obaryon0<0.) {
    cout<<"CosmoCalc::SetObaryon0: Error bad _Obaryon0 value: "<<_Obaryon0<<endl;
    throw ParmError("CosmoCalc::SetObaryon0: Error bad _Obaryon0 value");
  }
}

void CosmoCalc::SetDynParam(double h100,double om0,double or0,double ol0,double w0)
{
  _computespl=true;

  _h100 = h100;
  _H0 = 100. * _h100 ;
  _Dhubble = SpeedOfLight_Cst / _H0;

  _Omatter0 = om0;
  _Orelat0 = or0;
  _Olambda0 = ol0;
  _W0 = w0;
  _Otot0 = _Olambda0 + _Omatter0 + _Orelat0;
  _Ocurv0 = 1. - _Otot0;
  if( _h100<0. || _Omatter0<0. || _Orelat0<0. || _Olambda0<0. ) {
    cout<<"CosmoCalc::SetDynParam: Error bad parameter value"<<endl;
    throw ParmError("CosmoCalc::SetDynParam: Error bad parameter value");
  }
  if(_flat==0) return;

  _Otot0 = 1.; _Ocurv0 = 0.;
  if(_flat==1) {
    _Omatter0 = _Otot0 - _Olambda0 - _Orelat0;
    if( _Omatter0<0. ) {
      cout<<"CosmoCalc::SetDynParam: Error bad _Omatter0 value: "<<_Omatter0<<endl;
      throw ParmError("CosmoCalc::SetDynParam: Error bad _Omatter0 value");
    }
    return;
  }

  //--
  if(_flat==2) {
    _Olambda0 = _Otot0 - _Omatter0 - _Orelat0;
    if( _Olambda0<0. ) {
      cout<<"CosmoCalc::SetDynParam: Error bad _Olambda0 value: "<<_Olambda0<<endl;
      throw ParmError("CosmoCalc::SetDynParam: Error bad _Olambda0 value");
    }
    return;
  }

  //--
  if(_flat==3) {
    _Orelat0 = _Otot0 - _Omatter0 - _Olambda0;
    if( _Orelat0<0. ) {
      cout<<"CosmoCalc::SetDynParam: Error bad _Orelat0 value: "<<_Orelat0<<endl;
      throw ParmError("CosmoCalc::SetDynParam: Error bad _Orelat0 value");
    }
    return;
  }

  cout<<"CosmoCalc::SetDynParam: Error bad _flat value: "<<_flat<<endl;
  throw ParmError("CosmoCalc::SetDynParam: Error bad _flat value");

}

void CosmoCalc::DefaultParam(void)
{
  _computespl=true;

  double h100 = 0.71;
  double ol0 = 0.73, w0 = -1.;
  double om0 = 0.135/(h100*h100);
  // Relat = photons (2.725 K) + neutrinos (1.9 K)
  double or0 = 2.47e-5 * (1. + 21./8.*pow(T_NU_Par/T_CMB_Par,4.)) / (h100*h100);
  SetDynParam(h100,om0,or0,ol0,w0);
  _Obaryon0 = 0.0224/(h100*h100);

  return;
}

//----------------------------------------------------------
void CosmoCalc::Print(double z)
{
  if(z<0.) z = 0.;

  printf("CosmoCalc::Print(spl=%d,zmax=%g,flat=%u)  for z=%g\n",int(_usespline),ZMax(),Flat(),z);
  printf("h100=%g H0=%g Dhub=%g  H(z)=%g  Rhoc=%g g/cm^3 =%g Msol/Mpc^3\n"
        ,h100(),H0(),Dhubble(),H(z),Rhoc(z),Rhoc(z)*GCm3toMsolMpc3_Cst);
  printf("Olambda=%g  W0=%g\n",Olambda(z),_W0);
  printf("Omatter=%g  Obaryon=%g\n",Omatter(z),Obaryon(z));
  printf("Orelat=%g\n",Orelat(z));
  printf("Otot=%g  Ocurv=%g\n",Otot(z),Ocurv(z));
  if(z <= 0.) return;
  printf("Distance comoving: los=%g Mpc, transv=%g Mpc\n",Dloscom(z),Dtrcom(z));
  printf("Distance: angular=%g Mpc, lum=%g Mpc\n",Dang(z),Dlum(z));
  printf("Volume comoving element: %g Mpc^3/sr/dz=1\n",dVol(z));
  printf("Volume comoving in [0,z] for 4Pi sr: %g Mpc^3\n",Vol4Pi(z));

}
//----------------------------------------------------------
double CosmoCalc::Olambda(double z)
{
  double v = _Olambda0;
  if(_W0 != -1.) v *= pow((1.+z),3.*(1+_W0));
  return v / E2(z);
}

double CosmoCalc::Omatter(double z)
{
  return _Omatter0 * (1.+z)*(1.+z)*(1.+z) /E2(z);
}

double CosmoCalc::Obaryon(double z)
{
  return _Obaryon0 * (1.+z)*(1.+z)*(1.+z) /E2(z);
}

double CosmoCalc::Orelat(double z)
{
  double z2 = (1.+z)*(1.+z);
  return _Orelat0 * z2*z2 /E2(z);
}

double CosmoCalc::Ocurv(double z)
{
  return _Ocurv0 * (1.+z)*(1.+z) /E2(z);
}

double CosmoCalc::Otot(double z)
{
  return Olambda(z)+Omatter(z)+Orelat(z);
}

double CosmoCalc::Rhoc(double z)
// Densite critique au redshift "z"  en "g/cm^3"
{
  double h2 = H(z) / MpctoMeters_Cst;  h2 *= h2;
  return 3.* h2 / (8.*M_PI*G_Newton_Cst) * 1000.;
}

//----------------------------------------------------------
double CosmoCalc::Dloscom(double z)     /* Mpc */
{
  return _Dhubble * NInteg(z);
}

double CosmoCalc::Dtrcom(double z)     /* Mpc */
{
  double v = NInteg(z);  // Zero curvature

  if(_flat) return _Dhubble * v;

  if(_Ocurv0>0.) {  // hyperbolique
    double s = sqrt(_Ocurv0);
    v = sinh(s*v)/s;
  } else if(_Ocurv0<0.) {  // spherique
    double s = sqrt(-_Ocurv0);
    v = sin(s*v)/s;
  }

  return _Dhubble * v;

}

double CosmoCalc::Dang(double z)     /* Mpc */
{
  return Dtrcom(z) / (1.+z);
}

double CosmoCalc::Dlum(double z)     /* Mpc */
{
  return (1.+z) * Dtrcom(z);
}

double CosmoCalc::dVol(double z)     /* Mpc^3/ sr / unite z */
{
  double d = Dtrcom(z);
  return _Dhubble * d*d / E(z);
}

//----------------------------------------------------------
double CosmoCalc::Vol4Pi(double z)  /* Mpc^3 pour 4Pi sr entre [0,z] */
  // --- on pose x = dm/dh = (1+z)*da/dh, s = sqrt(|Ok|)
  // Ok=0 : V(z)/dh^3 = (4*Pi/3) * x^3
  // Ok>0 : V(z)/dh^3 = (4*Pi/(2*Ok)) * (x*sqrt(1+Ok*x^2) - 1/s * asinh(s*x))
  // Ok<0 : V(z)/dh^3 = (4*Pi/(2*Ok)) * (x*sqrt(1+Ok*x^2) - 1/s * asin(s*x) )
  // --- on pose y = s*x  (y>0)
  // Ok>0 : V(z)/dh^3 = (4*Pi/(2*Ok*s)) * (y*sqrt(1+y^2) - asinh(y))
  // Ok<0 : V(z)/dh^3 = (4*Pi/(2*Ok*s)) * (y*sqrt(1-y^2) - asin(y) )
  // --- a petit "z" on a pour "y -> 0+" en faisant le DL
  // Ok>0 : V(z)/dh^3 =  4*Pi*y^3 / (3*Ok*s) * (1 - 3*y^2/10) + O(y^7)
  // Ok<0 : V(z)/dh^3 = -4*Pi*y^3 / (3*Ok*s) * (1 + 3*y^2/10) + O(y^7)
  //                          (remarque: Ok^(3/2) = s*Ok)
{
  double v,x = Dtrcom(z)/_Dhubble;

  if(_flat) {
    v = 4.*M_PI/3. * x*x*x;
  } else if(_Ocurv0>0.) {
    double s = sqrt(_Ocurv0), y = s*x, y2 = y*y;
    if(y<1e-6) {
      v = 1. - 3.*y2/10.;
      v *= 4.*M_PI*y*y2 / (3.*_Ocurv0*s);
    } else {
      v = y*sqrt(1.+y2) - asinh(y);
      v *= 4.*M_PI/(2.*_Ocurv0*s);
    }
  } else if (_Ocurv0<0.) {
    double s = sqrt(-_Ocurv0), y = s*x, y2 = y*y;
    if(y<1e-6) {
      v = 1. + 3.*y2/10.;
      v *= -4.*M_PI*y*y2 / (3.*_Ocurv0*s);
    } else {
      v = y*sqrt(1.-y2) - asin(y);
      v *= 4.*M_PI/(2.*_Ocurv0*s);
    }
  } else {
    v = 4.*M_PI/3. * x*x*x;
  }

  return v * _Dhubble*_Dhubble*_Dhubble;
}

double CosmoCalc::Vol4Pi(double z1,double z2)  /* Mpc^3 pour 4Pi sr entre [z1,z2] */
{
  return Vol4Pi(z2) - Vol4Pi(z1);
}

double CosmoCalc::E2(double z) const
{
  z += 1.;
  double oldum = _Olambda0;

  if(oldum>0. && _W0!=-1.) oldum *= pow(z,3.*(1.+_W0));

  return oldum + z*z*(_Ocurv0 + z*(_Omatter0+z*_Orelat0));
}

//----------------------------------------------------------
double CosmoCalc::NInteg(double z)
{
  if(z<0.) {
    cout<<"CosmoCalc::NInteg: Error bad z value  z="<<z<<endl;
    throw ParmError("CosmoCalc::NInteg: Error bad z value");
  }

  // On utilise le spline
  if(_usespline) {
    if( (!_computespl) && (z==_zold) ) return _integval;
    if(z>_zmax) {_zmax = z; _computespl = true;}
    if(_computespl) Init_Spline();
    _integval = _spline->CSplineInt(z);
    _zold = z;
    return _integval;
  }

  // On calcule l'integrale
  if(z != _zold) {
    _integval = IntegrateFunc(*this,0.,z,_dperc,_dzinc,_dzmax,_glorder);
    _zold = z;
  }
  return _integval;

}

int_4 CosmoCalc::Init_Spline(void)
{
  if(_spline!=NULL)
    {delete _spline; delete [] _xspl; delete [] _yspl;}

  //-- Look for intervalles and integrate
  vector<double> x,y;
  double zbas=0., fbas = Integrand(zbas);
  x.push_back(zbas); y.push_back(0.);
  for(double z=_dzinc;z<_zmax+_dzinc && zbas<_zmax;z+=_dzinc) {
    double f = Integrand(z);
    bool doit = false;
    //cout<<fbas<<","<<f<<"  :  "<<fabs(f-fbas)<<" >? "<<_dperc*fabs(fbas)<<endl;
    if( fabs(f-fbas)>_dperc*fabs(fbas) ) doit = true;
    if( z-zbas>_dzmax ) doit = true;
    if( z>_zmax ) {doit = true; z=_zmax;}
    if( ! doit ) continue;
    x.push_back(z);
    double sum = 0., dz = z-zbas;
    for(unsigned short i=0;i<_glorder;i++) sum += _wgausl[i]*Integrand(zbas+_xgausl[i]*dz);
    y.push_back(sum*dz);
    //cout<<"...set... "<<zbas<<","<<z<<"  ,  "<<fbas<<","<<f<<endl;
    zbas = z;
    fbas = f;
  }

  //-- Fill spline
  _nspl = x.size();
  _xspl = new double[_nspl];
  _yspl = new double[_nspl];
  for(int i=0;i<_nspl;i++) {
    _xspl[i] = x[i];
    _yspl[i] = y[i];
    if(i!=0) _yspl[i] += _yspl[i-1];
  }
  double yp1 = Integrand(_xspl[0]);
  double ypn = Integrand(_xspl[_nspl-1]);
  _spline = new CSpline(_nspl,_xspl,_yspl,yp1,ypn,CSpline::NoNatural,false);
  _spline->ComputeCSpline();
  _computespl = false;

  cout<<"CosmoCalc::Init_Spline called: (zmax="<<_zmax<<") _nspl="<<_nspl<<endl;
  for(int i=0;i<(10<_nspl?10:_nspl);i++) cout<<_xspl[i]<<" ";
  cout<<" ... "<<_xspl[_nspl-1]<<endl;

  return _nspl;
}