d2/d8a/Func_8h_source.html

 /********************************************************************

  *  Copyright (C) 2010 by Federico Marulli                          *

  *  federico.marulli3@unibo.it                                      *

  *                                                                  *

  *  This program is free software; you can redistribute it and/or   *

  *  modify it under the terms of the GNU General Public License as  *

  *  published by the Free Software Foundation; either version 2 of  *

  *  the License, or (at your option) any later version.             *

  *                                                                  *

  *  This program is distributed in the hope that it will be useful, *

  *  but WITHOUT ANY WARRANTY; without even the implied warranty of  *

  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   *

  *  GNU General Public License for more details.                    *

  *                                                                  *

  *  You should have received a copy of the GNU General Public       *

  *  License along with this program; if not, write to the Free      *

  *  Software Foundation, Inc.,                                      *

  *  59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.       *

  ********************************************************************/


 #ifndef __FUNC__

 #define __FUNC__


 #include "RandomNumbers.h"

 #include "EigenWrapper.h"

 #include "ChainMesh.h"


 // ============================================================================================


 namespace cbl {


   double interpolated (const double _xx, const std::vector<double> xx, const std::vector<double> yy, const std::string type);


   double interpolated_2D (const double _x1, const double _x2, const std::vector<double> x1, const std::vector<double> x2, const std::vector<std::vector<double>> yy, const std::string type);


     std::vector<double> linear_interpolation_3D(const std::vector<double> min, std::vector<double> max, std::vector<int> steps, std::vector<std::vector<std::vector<double>>> func, const std::vector<std::vector<double>> pos);


   double Filter (const double r, const double rc);


   double legendre_polynomial (const double mu, const int l);


   double legendre_polynomial_integral (double mu, void *params);


   double Legendre_polynomial_mu_average (const int ll, const double mu, const double delta_mu);


   double Legendre_polynomial_mu_average (const double mu_min, const double mu_max, const int ll);


   double Legendre_polynomial_theta_average (const double theta_min, const double theta_max, const int ll);


   double Legendre_polynomial_triangles_average (const double r12_min, const double r12_max, const double r13_min, const double r13_max, const double r23_min, const double r23_max, const int ll, const double rel_err=1.e-5, const double abs_err=1.e-8, const int nevals=100);


   std::vector<std::vector<double>> Legendre_polynomial_triangles_average (const double r12, const double r13, const double deltaR, const int lMax, const double rel_err=1.e-5, const double abs_err=1.e-8, const int nevals=100);


   std::complex<double> spherical_harmonics (cbl::CoordinateType coordinate_type, const int l, const int m, const double coord1, const double coord2, const double coord3);


   std::vector<std::vector<std::complex<double>>> spherical_harmonics (const int lmax, const double xx, const double yy, const double zz);


   std::vector<std::complex<double>> spherical_harmonics_array (const int lmax, const double xx, const double yy, const double zz);


   double j0 (const double xx);


   double j2 (const double xx);


   double j4 (const double xx);


   double jl (const double xx, const int order);


   double j0_distance_average (const double kk, const double r_down, const double r_up);


   double j2_distance_average (const double kk, const double r_down, const double r_up);


   double jl_spherical_integrand (double rr, void *params);


   double jl_distance_average (const double kk, const int order, const double r_down, const double r_up);


   double trapezoid_integration (const std::vector<double> xx, const std::vector<double> yy);


   double coupling_3j (const int l, const int l_prime, const int l2);


   void gauleg (const double, const double, double *, double *, const int);


   // ============================================================================================


   void read_vector (const std::string file_vector, std::vector<double> &xx, std::vector<double> &vector, const std::vector<int> col={});


   void read_matrix (const std::string file_matrix, std::vector<double> &xx, std::vector<double> &yy, std::vector<std::vector<double>> &matrix, const std::vector<int> col={});


   double determinant_matrix (const std::vector<std::vector<double>> mat);


   void invert_matrix (const std::vector<std::vector<double>> mat, std::vector<std::vector<double>> &mat_inv, const double prec=1.e-10, const int Nres=-1);


   void invert_matrix (const std::vector<std::vector<double>> mat, std::vector<std::vector<double>> &mat_inv, const int i1, const int i2, const double prec=1.e-10, const int Nres=-1);


   void covariance_matrix (const std::vector<std::vector<double>> mat, std::vector<std::vector<double>> &cov, const bool JK=false);


   void covariance_matrix (const std::vector<std::string> file, std::vector<double> &rad, std::vector<double> &mean, std::vector<std::vector<double>> &cov, const bool JK=false);


   void covariance_matrix (const std::vector<std::string> file, const std::string covariance_matrix_file, const bool JK=0);


   void read_invert_covariance (const std::string filecov, std::vector<std::vector<double>> &cov, std::vector<std::vector<double>> &cov_inv, const size_t i1, const size_t i2, const double prec=1.e-10, const int Nres=-1);


   double number_from_distribution (const std::vector<double> xx, const std::vector<double> fx, const double xmin, const double xmax, const int seed);


   std::vector<double> vector_from_distribution (const int nRan, const std::vector<double> xx, const std::vector<double> fx, const double xmin, const double xmax, const int seed);


   std::vector<size_t> minimum_maximum_indexes (const std::vector<double> xx, const double x_min, const double x_max);


   double get_mu (const double r1, const double r2, const double r3);


   double window_function (const double x, const double min=-1, const double max=1);


   double binomial_coefficient(const int n, const int m);


   double clebsh_gordan(const int j1, const int j2, const int m1, const int m2, const int j3, const int m3);


   template <typename T>

   double sgn(T val);


   double wigner3j_auxA(double l1, double l2, double l3, double m1, double m2, double m3);


   double wigner3j_auxB(double l1, double l2, double l3, double m1, double m2, double m3);


   std::vector<double> wigner3j(double l2, double l3, double m1, double m2, double m3);


   double wigner3j(double l1, double l2, double l3, double m1, double m2, double m3);


   double wigner_3j(int j1, int j2, int j3, int m1, int m2, int m3);


   double wigner_6j(const int j1, const int j2, const int j3, const int j4, const int j5, const int j6);


   double three_spherical_bessel_integral (const double r1, const double r2, const double r3, const int L1, const int L2, const int L3);


   double average_three_spherical_bessel_integral (const double r1_min, const double r1_max, const double r2_min, const double r2_max, const double r3, const int L1, const int L2, const int L3);


   std::vector<double> generate_correlated_data (const std::vector<double> mean, const std::vector<std::vector<double>> covariance, const int idum =213123);


   std::vector<std::vector<double>> generate_correlated_data (const int nExtractions, const std::vector<double> mean, const std::vector<std::vector<double>> covariance, const int idum=12312);


   template <typename T>

     void vectorReadFromBinary (std::ifstream &fin, std::vector< T > &vec, size_t NN)

     {

       for (size_t ii = 0; ii<NN; ii++) {

     T var;

     fin.read((char *)&var, sizeof(T));

     vec.push_back(var);

       }

     }


   // ============================================================================================


   double Average (const std::vector<double> vect);


   double Average (const std::vector<double> vect, const std::vector<double> weight);


   double Sigma (const std::vector<double> vect);


   double Sigma (const std::vector<double> vect, const std::vector<double> weight);


   std::vector<double> Quartile (const std::vector<double> Vect);


   void Moment (const std::vector<double> data, double &ave, double &adev, double &sdev, double &var, double &skew, double &curt);


   // ============================================================================================


   template <typename T>

     T Pol2 (T xx, std::shared_ptr<void> pp, std::vector<double> par)

     {

       (void)pp;

       return par[0]*pow(xx,2)+par[1]*xx+par[2];

     }


   template <typename T>

     T Pol3 (T xx, void *pp, std::vector<double> par)

     {

       return par[0]*pow(xx,3)+par[1]*pow(xx,2)+par[2]*xx+par[3];

     }


   inline std::vector<double> linearfit (const double xx)

   {

     std::vector<double> vect(2);

     vect[0] = 1.;

     for (int i=1; i<2; i++) vect[i] = xx*vect[i-1];

     return vect;

   }


   inline std::vector<double> quadratic (const double xx)

   {

     std::vector<double> vect(3);

     vect[0] = 1.;

     for (int i=1; i<3; i++) vect[i] = xx*vect[i-1];

     return vect;

   }


   inline std::vector<double> cubicfit (const double xx)

   {

     std::vector<double> vect(4);

     vect[0] = 1.;

     for (int i=1; i<4; i++) vect[i] = xx*vect[i-1];

     return vect;

   }


   template <typename T>

     T identity (T xx, std::shared_ptr<void> pp, std::vector<double> par)

     {

       (void)xx; (void)pp; (void)par;

       return 1.;

     }


   template <typename T>

     T rectangular (T xx, std::shared_ptr<void> pp, std::vector<double> par)

     {

       if (xx>par[0] && par[1]>xx)

     return 1./(par[1]-par[0]);

       else return 0.;

     }


   double closest_probability (double xx, std::shared_ptr<void> pp, std::vector<double> par);


   double distribution_probability (double xx, std::shared_ptr<void> pp, std::vector<double> par);


   double chainMeshInterpolate (std::vector<double> xx, std::shared_ptr<void> pars);


   double multivariateGaussian (std::vector<double> xx, std::shared_ptr<void> pars);


   template <typename T>

     T gaussian (T xx, std::shared_ptr<void> pp, std::vector<double> par)

     {

       (void)pp;

       T gauss = 1./(par[1]*sqrt(2.*par::pi))*exp(-pow(xx-par[0],2)/(2.*par[1]*par[1]));

       return (par.size()==2) ? gauss : gauss*par[2];

     }


   template <typename T>

     T poisson (T xx, std::shared_ptr<void> pp, std::vector<double> par)

     {

       (void)pp;

       T pois = exp(int(xx) * log(par[0]) - lgamma(int(xx) + 1.0) - par[0]);

       return pois;

     }


   template <typename T>

     T maxwellian_distr (const T vel, const T sigma)

     {

       return sqrt(54./par::pi)*pow(vel/sigma,2)*exp(-1.5*pow(vel/sigma,2))/sigma;

     }


   template <typename T>

     T powerlaw (const T xx, const T x0, const T gamma)

     {

       return pow(xx/x0,-gamma);

     }


   template <typename T>

     T double_powerlaw (const T xx, const T x0, const T alpha, const T beta)

     {

       return pow(2.,beta-alpha)/(pow(xx/x0,alpha)*pow(1.+xx/x0,beta-alpha));

     }


   template <typename T>

     T TopHat_WF (const T kR)

     {

       return 3.*(sin(kR)-kR*cos(kR))/pow(kR,3);

     }


   template <typename T>

     T TopHat_WF_D1 (const T kR)

     {

       return (3.*(kR*kR-3.)*sin(kR)+9.*kR*cos(kR))*pow(kR, -4);

     }


   template <typename T>

     T Radius (const T Mass, const T Rho)

     {

       return pow(3.*Mass/(4.*par::pi*Rho),1./3.);

     }


   template <typename T>

     T volume_sphere (const T RR)

     {

       return 4./3.*par::pi*pow(RR, 3);

     }


   template <typename T>

     T Mass (const T RR, const T Rho)

     {

       return 4./3.*par::pi*Rho*pow(RR,3);

     }


   template <typename T>

     T radial_velocity (const T vx, const T vy, const T vz, const T ra, const T dec)

     {

       return vx*cos(dec)*sin(ra)+vy*cos(dec)*cos(ra)+vz*sin(dec);

     }


   template <typename T>

     T P_2 (const T x)

     {

       return (3.*x*x-1.)*0.5;

     }


   template <typename T>

     T P_4 (const T x)

     {

       return (35.*x*x*x*x-30.*x*x+3.)*0.125;

     }


   template <typename T>

     T P_6 (const T x)

     {

       return (231.*x*x*x*x*x*x-315.*x*x*x*x+105.*x*x-5.)*0.0625;

     }


   // ============================================================================================


   void measure_var_function (const std::vector<double> var, const int bin, const double V_min, const double V_max, const double Volume, std::vector<double> &Var, std::vector<double> &Phi, std::vector<double> &err);


   void distribution (std::vector<double> &xx, std::vector<double> &fx, std::vector<double> &err, const std::vector<double> FF, const std::vector<double> WW, const int nbin, const bool linear=true, const std::string file_out=par::defaultString, const double fact=1., const double V1=par::defaultDouble, const double V2=par::defaultDouble, const std::string bin_type="Linear", const bool conv=false, const double sigma=0.);


   double MC_Int (double func(const double), const double x1, const double x2, const int seed=3213);


   double MC_Int (double func(const double, const double AA), const double AA, const double x1, double x2, const int seed=3213);


   double MC_Int (double func(const double, const double AA, const double BB, const double CC, const double DD, const double EE), const double AA, const double BB, const double CC, const double DD, const double EE, const double x1, const double x2, const int seed=3213);


   // ============================================================================================


   void bin_function (const std::string file_grid, double func(double, void*), void *par, const int bin, const double x_min, const double x_max, const std::string binning, std::vector<double> &xx, std::vector<double> &yy);


   void bin_function_2D (const std::string file_grid, double func(double *, size_t, void *), void * par, const int bin, const double x1_min, const double x1_max, const double x2_min, const double x2_max, const std::string binning, std::vector<double> &xx1, std::vector<double> &xx2, std::vector<std::vector<double>> &yy);


   double func_grid_lin (double, void *);

   double func_grid_loglin (double, void *);

   double func_grid_log (double, void *);

   double func_grid_lin_2D (double *, size_t, void *);

   double func_grid_loglin_2D (double *, size_t, void *);

   double func_grid_log_2D (double *, size_t, void *);


   //

   void convolution (const std::vector<double> f1, const std::vector<double> f2, std::vector<double> &res, const double deltaX);


   // ============================================================================================


   double degrees (const double angle, const CoordinateUnits inputUnits=CoordinateUnits::_radians_);


   double radians (const double angle, const CoordinateUnits inputUnits=CoordinateUnits::_degrees_);


   double arcseconds (const double angle, const CoordinateUnits inputUnits=CoordinateUnits::_radians_);


   double arcminutes (const double angle, const CoordinateUnits inputUnits=CoordinateUnits::_radians_);


   double converted_angle (const double angle, const CoordinateUnits inputUnits=CoordinateUnits::_radians_, const CoordinateUnits outputUnits=CoordinateUnits::_degrees_);


   void polar_coord (const double XX, const double YY, const double ZZ, double &ra, double &dec, double &dd);


   void cartesian_coord (const double ra, const double dec, const double dd, double &XX, double &YY, double &ZZ);


   void polar_coord (const std::vector<double> XX, const std::vector<double> YY, const std::vector<double> ZZ, std::vector<double> &ra, std::vector<double> &dec, std::vector<double> &dd);


   void cartesian_coord (const std::vector<double> ra, const std::vector<double> dec, const std::vector<double> dd, std::vector<double> &XX, std::vector<double> &YY, std::vector<double> &ZZ);


   double Euclidean_distance (const double x1, const double x2, const double y1, const double y2, const double z1, const double z2);


   double perpendicular_distance (const double ra1, const double ra2, const double dec1, const double dec2, const double d1, const double d2);


   double angular_distance (const double x1, const double x2, const double y1, const double y2, const double z1, const double z2);


   double haversine_distance (const double ra1, const double ra2, const double dec1, const double dec2);


   /* ======== Alfonso Veropalumbo ======== */


   void sdss_atbound (double &angle, const double minval, const double maxval);


   void sdss_atbound2 (double &theta, double &phi);


   void eq2sdss (const std::vector<double> ra, const std::vector<double> dec, std::vector<double> &lambda, std::vector<double> &eta);


   void sdss2eq (const std::vector<double> lambda, const std::vector<double> eta, std::vector<double> &ra, std::vector<double> &dec);


   void sdss_stripe (const std::vector<double> eta, const std::vector<double> lambda, std::vector<int> &stripe, std::vector<int> &str_u);


   // ============================================================================================


   double xi_from_Pk (const double rr, const std::vector<double> lgkk, const std::vector<double> lgPk, const double k_min=0., const double k_max=100., const double aa=0., const double prec=1.e-2);


   double xi_from_Pk (const double rr, const std::string file, const int c1=1, const int c2=2, const double k_min=0., const double k_max=100., const double aa=0., const double prec=1.e-2);


   double Pk_from_xi (const double kk, const std::vector<double> lgrr, const std::vector<double> lgxi, const double r_min=0.03, const double r_max=100.);


   double Pk_from_xi (const double kk, const std::string file, const int c1=1, const int c2=2, const double r_min=0.03, const double r_max=100.);


   namespace glob {

     double func_xi_GSL (double, void *);

     double func_SSM_GSL (double, void *);

   }


   double wp (const double rp, const std::vector<double> rr, const std::vector<double> xi, const double r_max=100.);


   double wp (const double rp, const std::string file, const double r_max=100.);


   double sigmaR (const double RR, const int corrType, const std::vector<double> rr, const std::vector<double> corr);


   double xi_projected_powerlaw (const double rp, const double r0, const double gamma);


   double xi_ratio (const double beta);


   double xi_ratio (const double f_sigma8, const double bias_sigma8);


   double xi_ratio (double xx, std::shared_ptr<void> pp, std::vector<double> par); // for the chi2 function


   double error_xi_ratio (const double beta, const double error_beta);


   double barred_xi_direct (const double RR, const std::vector<double> rr, const std::vector<double> xi, const double rAPP=0., const double r0=-1., const double gamma=1.);


   double barred_xi__direct (const double RR, const std::vector<double> rr, const std::vector<double> xi, const double rAPP=0., const double r0=-1., const double gamma=1.);


   double barred_xi_ (const double RR, const std::vector<double> rr, const std::vector<double> xi, const double rAPP=0., const double r0=-1., const double gamma=1.);


   double barred_xi__ (const double RR, const std::vector<double> rr, const std::vector<double> xi, const double rAPP=0., const double r0=-1., const double gamma=1.);


   double multipole_xi0 (const int indexR, const std::vector<double> mu, const std::vector<std::vector<double>> xi);


   double multipole_xi2 (const int indexR, const std::vector<double> mu, const std::vector<std::vector<double>> xi);


   double multipole_xi4 (const int indexR, const std::vector<double> mu, const std::vector<std::vector<double>> xi);


   double error_multipole_xi0 (const int indexR, const std::vector<double> mu, const std::vector<std::vector<double>> error);


   double error_multipole_xi2 (const int indexR, const std::vector<double> mu, const std::vector<std::vector<double>> error);


   double error_multipole_xi4 (const int indexR, const std::vector<double> mu, const std::vector<std::vector<double>> error);


   double multipole_xi0 (const double ss, const std::vector<double> rp, const std::vector<double> pi, const std::vector<std::vector<double>> xi, const double delta_s);


   double multipole_xi2 (const double ss, const std::vector<double> rp, const std::vector<double> pi, const std::vector<std::vector<double>> xi, const double delta_s);


   double multipole_xi4 (const double ss, const std::vector<double> rp, const std::vector<double> pi, const std::vector<std::vector<double>> xi, const double delta_s);


   double error_multipole_xi0 (const double ss, const std::vector<double> rp, const std::vector<double> pi, const std::vector<std::vector<double>> error, const double delta_s);


   double error_multipole_xi2 (const double ss, const std::vector<double> rp, const std::vector<double> pi, const std::vector<std::vector<double>> error, const double delta_s);


   double error_multipole_xi4 (const double ss, const std::vector<double> rp, const std::vector<double> pi, const std::vector<std::vector<double>> error, const double delta_s);


   double multipoles (double rr, std::shared_ptr<void> pp, std::vector<double> par);


   double multipole_xi0_model (const double beta, const double xi_real);


   double multipole_xi0_model (const double f_sigma8, const double bias_sigma8, const double sigma8z, const double xi_matter);


   double multipole_xi0_model (double xx, std::shared_ptr<void> pp, std::vector<double> par);


   double multipole_xi2_model (const double beta, const double xi_real, const double xi_);


   double multipole_xi4_model (const double beta, const double xi_real, const double xi_, const double xi__);


   // theoretical model for the linear xi(rp,pi)

   double xi2D_lin_model (double, double, std::shared_ptr<void> , std::vector<double>);


   double xi2D_lin_model (const double beta, const double bias, const double xi_real, const double xi_, const double xi__, const double P_2, const double P_4);


   double xi2D_lin_model (const double rp, const double pi, const double beta, const double bias, const std::vector<double> rad_real, const std::vector<double> xi_real, const std::vector<double> xi_, const std::vector<double> xi__, const int index=-1, const bool bias_nl=0, const double bA=0.);


   // dispersion model for xi(rp,pi)

   double xi2D_model (double, double, std::shared_ptr<void>, std::vector<double>);


   double xi2D_model (const double rp, const double pi, const double beta, const double bias, const double sigmav, const std::vector<double> rad_real, const std::vector<double> xi_real, const std::vector<double> xi_, const std::vector<double> xi__, const double var, const int FV, int index=-1, const bool bias_nl=0, const double bA=0., const double v_min=-3000., const double v_max=3000., const int step_v=500);


   double xi2D_lin_model (const double rp, const double pi, const double beta, const double bias,  const std::shared_ptr<void> funcXiR, const std::shared_ptr<void> funcXiR_, const std::shared_ptr<void> funcXiR__, const bool bias_nl=0, const double bA=0.);


   double xi2D_model (const double rp, const double pi, const double beta, const double bias, const double sigmav, const std::shared_ptr<void> funcXiR, const std::shared_ptr<void> funcXiR_, const std::shared_ptr<void> funcXiR__, const double var, const int FV, const bool bias_nl=0, const double bA=0., const double v_min=-3000., const double v_max=3000., const int step_v=500);


   double f_v (const double vel, const double sigmav, const int FV);


   double f_v (const double vel, const double rp, const double pi, const double var, const double sigmav0, const double cmu, const double cs1, const double cs2);


   double f_star (const double xx, const double f_g, const double k_star);


   double b_nl (const double rr, const double bA, const double bB=10., const double bC=4.);


   double relative_error_beta (const double bias, const double Volume, const double density);


   double Pkl_Kaiser_integrand(const double mu, void *parameters);


   double sigma2_integrand (const double mu, void *parameters);


   double covariance_XiMultipoles_integrand (const double kk, void *parameters);


   double XiMultipoles_integrand (const double kk, void *parameters);


   double XiMultipoles_from_Xi2D_integrand (const double mu, void *parameters);


   double Pkl_Kaiser_integral(const int order, const double bias, const double f);


   std::vector<double> Pk0_Kaiser(const std::vector<double> kk, const std::vector<double> Pk, const double bias, const double f);


   std::vector<double> Pk2_Kaiser(const std::vector<double> kk, const std::vector<double> Pk, const double bias, const double f);


   std::vector<double> Pk4_Kaiser(const std::vector<double> kk, const std::vector<double> Pk, const double bias, const double f);


   std::vector<std::vector<double>> Pkl_Kaiser(const std::vector<int> orders, const std::vector<double> kk, const std::vector<double> Pk, const double bias, const double f);


   std::vector<double> Xi0(const std::vector<double> r, const std::vector<double> kk, const std::vector<double> Pk0, const double k_cut=0.7, const double cut_pow=2, const int IntegrationMethod = 1);


   std::vector<double> Xi2 (const std::vector<double> rr, const std::vector<double> kk, const std::vector<double> Pk2, const double k_cut=0.58, const double cut_pow=4, const int IntegrationMethod = 1);


   std::vector<double> Xi4 (const std::vector<double> rr, const std::vector<double> kk, const std::vector<double> Pk4, const double k_cut=0.6, const double cut_pow=2, const int IntegrationMethod = 1);


   std::vector<std::vector<double>> Xi02_AP (const double alpha_perpendicular, const double alpha_parallel, const std::vector<double> rr, const std::vector<double> rl, const std::vector<double> Xi0, const std::vector<double> Xi2);


   std::vector<std::vector<double>> Xi024_AP (const double alpha_perpendicular, const double alpha_parallel, const std::vector<double> rr, const std::vector<double> rl, const std::vector<double> Xi0, const std::vector<double> Xi2, const std::vector<double> Xi4);


   std::vector<std::vector<double>> XiWedges_AP (const std::vector<double> mu_min, const std::vector<double> delta_mu, const double alpha_perpendicular, const double alpha_parallel, const std::vector<double> rr, const std::vector<double> rl, const std::vector<double> Xi0, const std::vector<double> Xi2, const std::vector<double> Xi4);


   std::vector< std::vector<double>> sigma2_k (const double nObjects, const double Volume, const std::vector<double> kk, const std::vector<std::vector<double>> Pk_multipoles, const std::vector<int> orders);


   void Covariance_XiMultipoles (std::vector<double> &rr, std::vector<std::vector<double>> &covariance, const int nbins, const double rMin, const double rMax, const double nObjects, const double Volume, const std::vector<double> kk, const std::vector<std::vector<double>> Pk_multipoles, const std::vector<int> orders, const cbl::BinType bin_type=cbl::BinType::_linear_);


   void Covariance_XiWedges (std::vector<double> &rr, std::vector<std::vector<double>> &covariance, const std::vector<double> mu, const std::vector<double> delta_mu, const int nbins, const double rMin, const double rMax, const double nObjects, const double Volume, const std::vector<double> kk, const std::vector<std::vector<double>> Pk_multipoles, const std::vector<int> orders, const cbl::BinType bin_type=cbl::BinType::_linear_);


 // ============================================================================================


   namespace glob {


     struct STR_grid

     {

       std::vector<double> _xx, _yy;

     };


     struct STR_grid_2D

     {

       std::vector<double> _xx1, _xx2;

       std::vector<std::vector<double>> _yy;

     };


     struct STR_xi0_model

     {

       double bias_sigma8;

       double sigma8z;

       std::vector<double> xi_matter;

     };


     struct STR_xi2D_model

     {

       std::vector<double> rp, pi, xi_real, xi_, xi__, P2, P4, vel;

       std::vector<int> lim_index_fit, type;

       int step_v, FV, dim;

       double delta_v;

       bool bias_nl;

     };


     struct STR_xi

     {

       double rr, aa;

       std::vector<double> lgkk, lgPk;

     };


     struct STR_SSM

     {

       int unit;

       double hh, mass, rho, n_spec;

       std::vector<double> lgkk, lgPk;

     };


     struct STR_jl_distance_average

     {

       int order;

       double k;

     };


     struct STR_Pl_mu_integral

     {

       int order;

     };


     struct STR_Pkl_Kaiser_integrand

     {

       int l;

       double Pk, bias, f;

     };


     struct STR_closest_probability

     {

       std::vector<double> values;

       std::vector<double> weights;

     };


     struct STR_distribution_probability

     {

       std::shared_ptr<cbl::glob::FuncGrid> func;

     };


     struct STR_chainMeshInterpolate

     {

       cbl::chainmesh::ChainMesh ChainMesh;

       int DistNum;

     };


     struct STR_multivariateGaussian

     {

       Eigen::VectorXd MeanVec;

       Eigen::MatrixXd CovMat;

     };


     struct STR_sigma2_integrand

     {

       int l1, l2;

       double density_inv,kk;

       std::vector<int> orders;

       std::vector<FuncGrid> Pk_multipoles_interp;

     };


     struct STR_XiMultipoles_integrand

     {

       double r;

       int l;

       FuncGrid *Pkl;

       double k_cut;

       double cut_pow;

     };


     struct STR_xi2D_smu_integrand

     {

       FuncGrid *func;

       int order;

     };


     struct STR_covariance_XiMultipoles_integrand

     {

       FuncGrid *s2, *jl1r1, *jl2r2;

     };

   }


   std::vector<std::vector<double>> Xi02_AP (const double alpha_perpendicular, const double alpha_parallel, const std::vector<double> rr, const std::shared_ptr<glob::FuncGrid> xi0_interp, const std::shared_ptr<glob::FuncGrid> xi2_interp);


   std::vector< std::vector<double>> Xi024_AP (const double alpha_perpendicular, const double alpha_parallel, const std::vector<double> rr, const std::shared_ptr<glob::FuncGrid> xi0_interp, const std::shared_ptr<glob::FuncGrid> xi2_interp, const std::shared_ptr<glob::FuncGrid> xi4_interp);


   std::vector<std::vector<double>> XiWedges_AP (const std::vector<double> mu_min, const std::vector<double> delta_mu, const double alpha_perpendicular, const double alpha_parallel, const std::vector<double> rr, const std::shared_ptr<glob::FuncGrid> xi0_interp, const std::shared_ptr<glob::FuncGrid> xi2_interp, const std::shared_ptr<glob::FuncGrid> xi4_interp);


 }


 #endif

ChainMesh.h
Implementation of the chain-mesh data structure.

EigenWrapper.h
functions that wrap Eigen routines

RandomNumbers.h
Class functions used to generate random numbers.

cbl::chainmesh::ChainMesh
The class ChainMesh.
Definition: ChainMesh.h:60

cbl::par::defaultString
static const std::string defaultString
default std::string value
Definition: Constants.h:336

cbl::par::defaultDouble
static const double defaultDouble
default double value
Definition: Constants.h:348

cbl::par::pi
static const double pi
: the ratio of a circle's circumference to its diameter
Definition: Constants.h:199

cbl::par::alpha
static const double alpha
: the fine-structure constant
Definition: Constants.h:233

cbl::catalogue::Var
Var
the catalogue variables
Definition: Catalogue.h:70

cbl::modelling::twopt::bias
double bias(const double Mmin, const double sigmalgM, const double M0, const double M1, const double alpha, const std::shared_ptr< void > inputs)
the mean galaxy bias
Definition: ModelFunction_TwoPointCorrelation1D_monopole.cpp:1026

cbl
The global namespace of the  CosmoBolognaLib
Definition: CAMB.h:38

cbl::distribution
void distribution(std::vector< double > &xx, std::vector< double > &fx, std::vector< double > &err, const std::vector< double > FF, const std::vector< double > WW, const int nbin, const bool linear=true, const std::string file_out=par::defaultString, const double fact=1., const double V1=par::defaultDouble, const double V2=par::defaultDouble, const std::string bin_type="Linear", const bool conv=false, const double sigma=0.)
derive and store the number distribution of a given std::vector
Definition: Func.cpp:1654

cbl::sdss_atbound
void sdss_atbound(double &angle, const double minval, const double maxval)
check if ra coordinate is inside the boundaries
Definition: Func.cpp:1347

cbl::MC_Int
double MC_Int(double func(const double), const double x1, const double x2, const int seed=3213)
simple Monte Carlo integration of f(x)
Definition: Func.cpp:295

cbl::sigmaR
double sigmaR(const double RR, const int corrType, const std::vector< double > rr, const std::vector< double > corr)
the rms mass fluctuation within a given radius
Definition: FuncXi.cpp:227

cbl::vectorReadFromBinary
void vectorReadFromBinary(std::ifstream &fin, std::vector< T > &vec, size_t NN)
reads a vector from a binary file
Definition: Func.h:867

cbl::maxwellian_distr
T maxwellian_distr(const T vel, const T sigma)
the Maxwellian distribution
Definition: Func.h:1157

cbl::sigma2_integrand
double sigma2_integrand(const double mu, void *parameters)
integrand of the 2d power spectrum to obtain sigma^2(k)
Definition: FuncMultipoles.cpp:446

cbl::Pk0_Kaiser
std::vector< double > Pk0_Kaiser(const std::vector< double > kk, const std::vector< double > Pk, const double bias, const double f)
function to obtain the linear RSD power spectrum monopole
Definition: FuncMultipoles.cpp:501

cbl::conv
std::string conv(const T val, const char *fact)
convert a number to a std::string
Definition: Kernel.h:903

cbl::legendre_polynomial_integral
double legendre_polynomial_integral(double mu, void *params)
the order l Legendre polynomial integrand
Definition: Func.cpp:1795

cbl::Euclidean_distance
double Euclidean_distance(const double x1, const double x2, const double y1, const double y2, const double z1, const double z2)
the Euclidean distance in 3D relative to the origin (0,0,0), i.e. the Euclidean norm
Definition: Func.cpp:250

cbl::barred_xi_direct
double barred_xi_direct(const double RR, const std::vector< double > rr, const std::vector< double > xi, const double rAPP=0., const double r0=-1., const double gamma=1.)
the barred correlation function
Definition: FuncXi.cpp:331

cbl::read_matrix
void read_matrix(const std::string file_matrix, std::vector< double > &xx, std::vector< double > &yy, std::vector< std::vector< double >> &matrix, const std::vector< int > col={})
read a matrix from file
Definition: Func.cpp:612

cbl::error_multipole_xi2
double error_multipole_xi2(const int indexR, const std::vector< double > mu, const std::vector< std::vector< double >> error)
error on xi2(s) from ξ(r,μ)
Definition: FuncMultipoles.cpp:105

cbl::Legendre_polynomial_mu_average
double Legendre_polynomial_mu_average(const int ll, const double mu, const double delta_mu)
the average of the Legendre polynomial of the l-th order over the mu range
Definition: Func.cpp:1806

cbl::multivariateGaussian
double multivariateGaussian(std::vector< double > xx, std::shared_ptr< void > pars)
the multivariate Gaussian function
Definition: Func.cpp:79

cbl::XiWedges_AP
std::vector< std::vector< double > > XiWedges_AP(const std::vector< double > mu_min, const std::vector< double > delta_mu, const double alpha_perpendicular, const double alpha_parallel, const std::vector< double > rr, const std::vector< double > rl, const std::vector< double > Xi0, const std::vector< double > Xi2, const std::vector< double > Xi4)
function to obtain the 2pcf wedges
Definition: FuncMultipoles.cpp:923

cbl::Average
double Average(const std::vector< double > vect)
the average of a std::vector
Definition: Func.cpp:870

cbl::CoordinateType
CoordinateType
the coordinate type
Definition: Kernel.h:624

cbl::error_multipole_xi4
double error_multipole_xi4(const int indexR, const std::vector< double > mu, const std::vector< std::vector< double >> error)
error on xi4(s) from ξ(r,μ)
Definition: FuncMultipoles.cpp:120

cbl::Pkl_Kaiser_integral
double Pkl_Kaiser_integral(const int order, const double bias, const double f)
function to obtain the Kaiser factor
Definition: FuncMultipoles.cpp:480

cbl::Mass
T Mass(const T RR, const T Rho)
the mass of a sphere of a given radius and density
Definition: Func.h:1243

cbl::volume_sphere
T volume_sphere(const T RR)
the volume of a sphere of a given radius
Definition: Func.h:1231

cbl::j2
double j2(const double xx)
the l=2 spherical Bessel function
Definition: Func.cpp:2048

cbl::Xi02_AP
std::vector< std::vector< double > > Xi02_AP(const double alpha_perpendicular, const double alpha_parallel, const std::vector< double > rr, const std::vector< double > rl, const std::vector< double > Xi0, const std::vector< double > Xi2)
function to obtain the monopole and quadrupole of the two point correlation function
Definition: FuncMultipoles.cpp:811

cbl::j2_distance_average
double j2_distance_average(const double kk, const double r_down, const double r_up)
the distance average l=2 spherical Bessel function this function is used to obtain the analytic twop ...
Definition: Func.cpp:2087

cbl::multipole_xi0
double multipole_xi0(const int indexR, const std::vector< double > mu, const std::vector< std::vector< double >> xi)
xi0(s) from ξ(r,μ)
Definition: FuncMultipoles.cpp:45

cbl::chainMeshInterpolate
double chainMeshInterpolate(std::vector< double > xx, std::shared_ptr< void > pars)
a multidimension interpolator
Definition: Func.cpp:68

cbl::Xi2
std::vector< double > Xi2(const std::vector< double > rr, const std::vector< double > kk, const std::vector< double > Pk2, const double k_cut=0.58, const double cut_pow=4, const int IntegrationMethod=1)
function to obtain the two point correlation function quadrupole
Definition: FuncMultipoles.cpp:624

cbl::Radius
T Radius(const T Mass, const T Rho)
the radius of a sphere of a given mass and density
Definition: Func.h:1220

cbl::spherical_harmonics_array
std::vector< std::complex< double > > spherical_harmonics_array(const int lmax, const double xx, const double yy, const double zz)
the spherical harmonics up to
Definition: Func.cpp:2009

cbl::barred_xi__
double barred_xi__(const double RR, const std::vector< double > rr, const std::vector< double > xi, const double rAPP=0., const double r0=-1., const double gamma=1.)
the double barred correlation function
Definition: FuncXi.cpp:412

cbl::barred_xi_
double barred_xi_(const double RR, const std::vector< double > rr, const std::vector< double > xi, const double rAPP=0., const double r0=-1., const double gamma=1.)
the barred correlation function
Definition: FuncXi.cpp:392

cbl::haversine_distance
double haversine_distance(const double ra1, const double ra2, const double dec1, const double dec2)
the haversine angular separation
Definition: Func.cpp:286

cbl::converted_angle
double converted_angle(const double angle, const CoordinateUnits inputUnits=CoordinateUnits::_radians_, const CoordinateUnits outputUnits=CoordinateUnits::_degrees_)
conversion to angle units
Definition: Func.cpp:192

cbl::multipole_xi0_model
double multipole_xi0_model(const double beta, const double xi_real)
the model multipole ξ0 of the two-point correlation function
Definition: FuncMultipoles.cpp:353

cbl::rectangular
T rectangular(T xx, std::shared_ptr< void > pp, std::vector< double > par)
the rectangular distribution
Definition: Func.h:1071

cbl::xi_projected_powerlaw
double xi_projected_powerlaw(const double rp, const double r0, const double gamma)
the projected correlation function, wp(rp), computed by modelling the two-point correlation function,...
Definition: FuncXi.cpp:278

cbl::f_v
double f_v(const double vel, const double sigmav, const int FV)
pairwise velocity distribution
Definition: FuncXi.cpp:616

cbl::Legendre_polynomial_triangles_average
double Legendre_polynomial_triangles_average(const double r12_min, const double r12_max, const double r13_min, const double r13_max, const double r23_min, const double r23_max, const int ll, const double rel_err=1.e-5, const double abs_err=1.e-8, const int nevals=100)
the average of the Legendre polynomial of the l-th order over the
Definition: Func.cpp:1836

cbl::jl_spherical_integrand
double jl_spherical_integrand(double rr, void *params)
the generic integrand to obtain the distance average spherical Bessel function of order l
Definition: Func.cpp:2099

cbl::angular_distance
double angular_distance(const double x1, const double x2, const double y1, const double y2, const double z1, const double z2)
the angular separation in 3D
Definition: Func.cpp:277

cbl::XiMultipoles_integrand
double XiMultipoles_integrand(const double kk, void *parameters)
integrand to obtain covariance for the 2PCF multipoles
Definition: FuncMultipoles.cpp:420

cbl::interpolated_2D
double interpolated_2D(const double _x1, const double _x2, const std::vector< double > x1, const std::vector< double > x2, const std::vector< std::vector< double >> yy, const std::string type)
2D interpolation
Definition: Func.cpp:502

cbl::Legendre_polynomial_theta_average
double Legendre_polynomial_theta_average(const double theta_min, const double theta_max, const int ll)
the average of the Legendre polynomial of the l-th order over the  range
Definition: Func.cpp:1827

cbl::identity
T identity(T xx, std::shared_ptr< void > pp, std::vector< double > par)
the Identity function
Definition: Func.h:1053

cbl::relative_error_beta
double relative_error_beta(const double bias, const double Volume, const double density)
estimated relative error on
Definition: Func.cpp:1072

cbl::TopHat_WF
T TopHat_WF(const T kR)
the top-hat window function
Definition: Func.h:1195

cbl::cartesian_coord
void cartesian_coord(const double ra, const double dec, const double dd, double &XX, double &YY, double &ZZ)
conversion from polar coordinates to Cartesian coordinates
Definition: Func.cpp:221

cbl::multipole_xi2
double multipole_xi2(const int indexR, const std::vector< double > mu, const std::vector< std::vector< double >> xi)
xi2(s) from ξ(r,μ)
Definition: FuncMultipoles.cpp:60

cbl::multipole_xi4
double multipole_xi4(const int indexR, const std::vector< double > mu, const std::vector< std::vector< double >> xi)
xi4(s) from ξ(r,μ)
Definition: FuncMultipoles.cpp:75

cbl::multipole_xi4_model
double multipole_xi4_model(const double beta, const double xi_real, const double xi_, const double xi__)
the model multipole ξ4 of the two-point correlation function
Definition: FuncMultipoles.cpp:397

cbl::Pkl_Kaiser
std::vector< std::vector< double > > Pkl_Kaiser(const std::vector< int > orders, const std::vector< double > kk, const std::vector< double > Pk, const double bias, const double f)
function to obtain Pk multipoles from linear RSD (Kaiser)
Definition: FuncMultipoles.cpp:546

cbl::P_4
T P_4(const T x)
the Legendre polynomial P4
Definition: Func.h:1280

cbl::invert_matrix
void invert_matrix(const std::vector< std::vector< double >> mat, std::vector< std::vector< double >> &mat_inv, const double prec=1.e-10, const int Nres=-1)
function to invert a matrix
Definition: Func.cpp:673

cbl::poisson
T poisson(T xx, std::shared_ptr< void > pp, std::vector< double > par)
the poisson distribution
Definition: Func.h:1143

cbl::three_spherical_bessel_integral
double three_spherical_bessel_integral(const double r1, const double r2, const double r3, const int L1, const int L2, const int L3)
compute the integral of three spherical bessel function, from Mehrem (2011)
Definition: Func.cpp:2554

cbl::sigma2_k
std::vector< std::vector< double > > sigma2_k(const double nObjects, const double Volume, const std::vector< double > kk, const std::vector< std::vector< double >> Pk_multipoles, const std::vector< int > orders)
multipole expansion of the per-mode covariance sigma2_k (see Grieb et al. 2016, eq....
Definition: FuncMultipoles.cpp:944

cbl::error_xi_ratio
double error_xi_ratio(const double beta, const double error_beta)
error on the ratio between the redshift-space and real-space correlation functions
Definition: FuncXi.cpp:322

cbl::Pk_from_xi
double Pk_from_xi(const double kk, const std::vector< double > lgrr, const std::vector< double > lgxi, const double r_min=0.03, const double r_max=100.)
the power spectrum computed from the Fourier transform of the two-point correlation function
Definition: FuncXi.cpp:141

cbl::barred_xi__direct
double barred_xi__direct(const double RR, const std::vector< double > rr, const std::vector< double > xi, const double rAPP=0., const double r0=-1., const double gamma=1.)
the double barred correlation function
Definition: FuncXi.cpp:361

cbl::Pk4_Kaiser
std::vector< double > Pk4_Kaiser(const std::vector< double > kk, const std::vector< double > Pk, const double bias, const double f)
function to obtain the linear RSD power spectrum hexadecapole
Definition: FuncMultipoles.cpp:531

cbl::double_powerlaw
T double_powerlaw(const T xx, const T x0, const T alpha, const T beta)
the double power-law function
Definition: Func.h:1184

cbl::P_6
T P_6(const T x)
the Legendre polynomial P6
Definition: Func.h:1291

cbl::j0
double j0(const double xx)
the l=0 spherical Bessel function
Definition: Func.cpp:2039

cbl::trapezoid_integration
double trapezoid_integration(const std::vector< double > xx, const std::vector< double > yy)
integral, computed with the trapezoid rule, using ordered data
Definition: Func.cpp:2203

cbl::wigner3j
std::vector< double > wigner3j(double l2, double l3, double m1, double m2, double m3)
Wigner  symbol.
Definition: Func.cpp:2267

cbl::xi2D_model
double xi2D_model(const double rp, const double pi, const double beta, const double bias, const double sigmav, const std::vector< double > rad_real, const std::vector< double > xi_real, const std::vector< double > xi_, const std::vector< double > xi__, const double var, const int FV, int index=-1, const bool bias_nl=0, const double bA=0., const double v_min=-3000., const double v_max=3000., const int step_v=500)
the non-linear dispersion model for ξ(rp,π)
Definition: FuncXi.cpp:574

cbl::linear_interpolation_3D
std::vector< double > linear_interpolation_3D(const std::vector< double > min, std::vector< double > max, std::vector< int > steps, std::vector< std::vector< std::vector< double >>> func, const std::vector< std::vector< double >> pos)
3D interpolation on a 3D regular grid
Definition: Func.cpp:546

cbl::xi_ratio
double xi_ratio(const double beta)
the ratio between the redshift-space and real-space correlation functions
Definition: FuncXi.cpp:287

cbl::radial_velocity
T radial_velocity(const T vx, const T vy, const T vz, const T ra, const T dec)
the radial velocity
Definition: Func.h:1258

cbl::linearfit
std::vector< double > linearfit(const double xx)
linear function
Definition: Func.h:1007

cbl::Xi024_AP
std::vector< std::vector< double > > Xi024_AP(const double alpha_perpendicular, const double alpha_parallel, const std::vector< double > rr, const std::vector< double > rl, const std::vector< double > Xi0, const std::vector< double > Xi2, const std::vector< double > Xi4)
function to obtain the monopole, quadrupole and hexadecapole of the two-point correlation function
Definition: FuncMultipoles.cpp:853

cbl::multipole_xi2_model
double multipole_xi2_model(const double beta, const double xi_real, const double xi_)
the model multipole ξ2 of the two-point correlation function
Definition: FuncMultipoles.cpp:388

cbl::Pol2
T Pol2(T xx, std::shared_ptr< void > pp, std::vector< double > par)
the quadratic function
Definition: Func.h:981

cbl::Pkl_Kaiser_integrand
double Pkl_Kaiser_integrand(const double mu, void *parameters)
integrand of the 2d power spectrum to obtain power spectrum multipole
Definition: FuncMultipoles.cpp:409

cbl::gaussian
T gaussian(T xx, std::shared_ptr< void > pp, std::vector< double > par)
the Gaussian function
Definition: Func.h:1127

cbl::TopHat_WF_D1
T TopHat_WF_D1(const T kR)
the derivative of the top-hat window function
Definition: Func.h:1208

cbl::Pk2_Kaiser
std::vector< double > Pk2_Kaiser(const std::vector< double > kk, const std::vector< double > Pk, const double bias, const double f)
function to obtain the linear RSD power spectrum quadrupole
Definition: FuncMultipoles.cpp:516

cbl::coupling_3j
double coupling_3j(const int l, const int l_prime, const int l2)
compute the Wigner 3-j symbol
Definition: Func.cpp:2520

cbl::f_star
double f_star(const double xx, const double f_g, const double k_star)
velocity distribution used to model BAO
Definition: FuncXi.cpp:642

cbl::spherical_harmonics
std::complex< double > spherical_harmonics(cbl::CoordinateType coordinate_type, const int l, const int m, const double coord1, const double coord2, const double coord3)
the order l, degree m spherical harmonics
Definition: Func.cpp:1939

cbl::Covariance_XiMultipoles
void Covariance_XiMultipoles(std::vector< double > &rr, std::vector< std::vector< double >> &covariance, const int nbins, const double rMin, const double rMax, const double nObjects, const double Volume, const std::vector< double > kk, const std::vector< std::vector< double >> Pk_multipoles, const std::vector< int > orders, const cbl::BinType bin_type=cbl::BinType::_linear_)
Covariance matrix for two-point correlation multipoles (see Grieb et al. 2016, Eq....
Definition: FuncMultipoles.cpp:994

cbl::Filter
double Filter(const double r, const double rc)
filter W(r/rc), used e.g. for filtering the correlation function
Definition: Func.cpp:94

cbl::xi_from_Pk
double xi_from_Pk(const double rr, const std::vector< double > lgkk, const std::vector< double > lgPk, const double k_min=0., const double k_max=100., const double aa=0., const double prec=1.e-2)
the two-point correlation function computed from the Fourier transform of the power spectrum
Definition: FuncXi.cpp:80

cbl::radians
double radians(const double angle, const CoordinateUnits inputUnits=CoordinateUnits::_degrees_)
conversion to radians
Definition: Func.cpp:126

cbl::interpolated
double interpolated(const double _xx, const std::vector< double > xx, const std::vector< double > yy, const std::string type)
1D interpolation
Definition: Func.cpp:445

cbl::clebsh_gordan
double clebsh_gordan(const int j1, const int j2, const int m1, const int m2, const int j3, const int m3)
get the Clebsh-Gordan coefficient in the notation
Definition: Func.cpp:2511

cbl::average_three_spherical_bessel_integral
double average_three_spherical_bessel_integral(const double r1_min, const double r1_max, const double r2_min, const double r2_max, const double r3, const int L1, const int L2, const int L3)
compute the integral of three spherical bessel function, from Mehrem (2011), averaged on r1-r2 shells
Definition: Func.cpp:2585

cbl::binomial_coefficient
double binomial_coefficient(const int n, const int m)
get the binomial coefficient
Definition: Func.cpp:2217

cbl::Sigma
double Sigma(const std::vector< double > vect)
the standard deviation of a std::vector
Definition: Func.cpp:925

cbl::j0_distance_average
double j0_distance_average(const double kk, const double r_down, const double r_up)
the distance average l=0 spherical Bessel function this function is used to obtain the analytic twop ...
Definition: Func.cpp:2075

cbl::Covariance_XiWedges
void Covariance_XiWedges(std::vector< double > &rr, std::vector< std::vector< double >> &covariance, const std::vector< double > mu, const std::vector< double > delta_mu, const int nbins, const double rMin, const double rMax, const double nObjects, const double Volume, const std::vector< double > kk, const std::vector< std::vector< double >> Pk_multipoles, const std::vector< int > orders, const cbl::BinType bin_type=cbl::BinType::_linear_)
Covariance matrix for two-point correlation wedges (see Grieb et al. 2016, Eq. 19 https://arxiv....
Definition: FuncMultipoles.cpp:1096

cbl::wigner_3j
double wigner_3j(int j1, int j2, int j3, int m1, int m2, int m3)
Wigner  symbol, use it for l<100.
Definition: Func.cpp:2493

cbl::Quartile
std::vector< double > Quartile(const std::vector< double > Vect)
the first, second and third quartiles of a std::vector
Definition: Func.cpp:1002

cbl::quadratic
std::vector< double > quadratic(const double xx)
quadratic function
Definition: Func.h:1020

cbl::P_2
T P_2(const T x)
the Legendre polynomial P2
Definition: Func.h:1269

cbl::Moment
void Moment(const std::vector< double > data, double &ave, double &adev, double &sdev, double &var, double &skew, double &curt)
compute the moments of a set of data
Definition: Func.cpp:1058

cbl::sdss2eq
void sdss2eq(const std::vector< double > lambda, const std::vector< double > eta, std::vector< double > &ra, std::vector< double > &dec)
convert sdss coordinates  to R.A., Dec.
Definition: Func.cpp:1397

cbl::error_multipole_xi0
double error_multipole_xi0(const int indexR, const std::vector< double > mu, const std::vector< std::vector< double >> error)
error on xi0(s) from ξ(r,μ)
Definition: FuncMultipoles.cpp:90

cbl::sgn
double sgn(T val)
sgn the sign function
Definition: Func.cpp:2227

cbl::generate_correlated_data
std::vector< double > generate_correlated_data(const std::vector< double > mean, const std::vector< std::vector< double >> covariance, const int idum=213123)
generate a covariant sample of n points using a covariance matrix
Definition: Func.cpp:2142

cbl::sdss_stripe
void sdss_stripe(const std::vector< double > eta, const std::vector< double > lambda, std::vector< int > &stripe, std::vector< int > &str_u)
compute the SDSS stripe given SDSS coordinates
Definition: Func.cpp:1420

cbl::Xi4
std::vector< double > Xi4(const std::vector< double > rr, const std::vector< double > kk, const std::vector< double > Pk4, const double k_cut=0.6, const double cut_pow=2, const int IntegrationMethod=1)
function to obtain the two point correlation function hexadecapole
Definition: FuncMultipoles.cpp:680

cbl::closest_probability
double closest_probability(double xx, std::shared_ptr< void > pp, std::vector< double > par)
probability of the closest element to x from a list with weights
Definition: Func.cpp:47

cbl::covariance_matrix
void covariance_matrix(const std::vector< std::vector< double >> mat, std::vector< std::vector< double >> &cov, const bool JK=false)
compute the covariance matrix from an input dataset
Definition: Func.cpp:761

cbl::read_invert_covariance
void read_invert_covariance(const std::string filecov, std::vector< std::vector< double >> &cov, std::vector< std::vector< double >> &cov_inv, const size_t i1, const size_t i2, const double prec=1.e-10, const int Nres=-1)
read and invert the covariance matrix
Definition: Func.cpp:1522

cbl::wigner3j_auxA
double wigner3j_auxA(double l1, double l2, double l3, double m1, double m2, double m3)
Wigner  auxiliar function A.
Definition: Func.cpp:2240

cbl::powerlaw
T powerlaw(const T xx, const T x0, const T gamma)
the power-law function
Definition: Func.h:1170

cbl::Pol3
T Pol3(T xx, void *pp, std::vector< double > par)
the cubic function
Definition: Func.h:997

cbl::degrees
double degrees(const double angle, const CoordinateUnits inputUnits=CoordinateUnits::_radians_)
conversion to degrees
Definition: Func.cpp:104

cbl::j4
double j4(const double xx)
the l=4 spherical Bessel function
Definition: Func.cpp:2057

cbl::bin_function_2D
void bin_function_2D(const std::string file_grid, double func(double *, size_t, void *), void *par, const int bin, const double x1_min, const double x1_max, const double x2_min, const double x2_max, const std::string binning, std::vector< double > &xx1, std::vector< double > &xx2, std::vector< std::vector< double >> &yy)
create a 2D grid given an input function
Definition: Func.cpp:1183

cbl::jl_distance_average
double jl_distance_average(const double kk, const int order, const double r_down, const double r_up)
the distance average for the order l-th spherical Bessel function
Definition: Func.cpp:2109

cbl::CoordinateUnits
CoordinateUnits
the coordinate units
Definition: Kernel.h:562

cbl::CoordinateUnits::_radians_
@ _radians_
angle in radians

cbl::CoordinateUnits::_degrees_
@ _degrees_
angle in degrees

cbl::vector_from_distribution
std::vector< double > vector_from_distribution(const int nRan, const std::vector< double > xx, const std::vector< double > fx, const double xmin, const double xmax, const int seed)
return a std::vector of numbers sampled from a given distribution
Definition: Func.cpp:1455

cbl::BinType
BinType
the binning type
Definition: Kernel.h:505

cbl::BinType::_linear_
@ _linear_
linear binning

cbl::sdss_atbound2
void sdss_atbound2(double &theta, double &phi)
set the angular coordinates in the SDSS boundaries
Definition: Func.cpp:1356

cbl::cubicfit
std::vector< double > cubicfit(const double xx)
cubic function
Definition: Func.h:1034

cbl::perpendicular_distance
double perpendicular_distance(const double ra1, const double ra2, const double dec1, const double dec2, const double d1, const double d2)
the perpendicular separation, rp
Definition: Func.cpp:259

cbl::get_mu
double get_mu(const double r1, const double r2, const double r3)
get the cosine of the angle between two sides of a triangle
Definition: Func.cpp:2529

cbl::determinant_matrix
double determinant_matrix(const std::vector< std::vector< double >> mat)
compute the determinant of a matrix
Definition: Func.cpp:648

cbl::covariance_XiMultipoles_integrand
double covariance_XiMultipoles_integrand(const double kk, void *parameters)
integrand to obtain the 2PCF multipoles
Definition: FuncMultipoles.cpp:466

cbl::XiMultipoles_from_Xi2D_integrand
double XiMultipoles_from_Xi2D_integrand(const double mu, void *parameters)
integrand to obtain the 2PCF multipoles from 2D 2pcf in polar coordinates
Definition: FuncMultipoles.cpp:435

cbl::legendre_polynomial
double legendre_polynomial(const double mu, const int l)
the order l Legendre polynomial
Definition: Func.cpp:1786

cbl::measure_var_function
void measure_var_function(const std::vector< double > var, const int bin, const double V_min, const double V_max, const double Volume, std::vector< double > &Var, std::vector< double > &Phi, std::vector< double > &err)
measure the var function (where "var" could be the mass, the luminosity, the radius,...
Definition: Func.cpp:1084

cbl::Xi0
std::vector< double > Xi0(const std::vector< double > r, const std::vector< double > kk, const std::vector< double > Pk0, const double k_cut=0.7, const double cut_pow=2, const int IntegrationMethod=1)
function to obtain the two point correlation funciton monopole
Definition: FuncMultipoles.cpp:569

cbl::jl
double jl(const double xx, const int order)
the order l spherical Bessel function
Definition: Func.cpp:2066

cbl::convolution
void convolution(const std::vector< double > f1, const std::vector< double > f2, std::vector< double > &res, const double deltaX)
convolution of two functions
Definition: Func.cpp:1580

cbl::eq2sdss
void eq2sdss(const std::vector< double > ra, const std::vector< double > dec, std::vector< double > &lambda, std::vector< double > &eta)
convert from equatorial coordinates R.A., Dec to sdss coordinates
Definition: Func.cpp:1373

cbl::arcseconds
double arcseconds(const double angle, const CoordinateUnits inputUnits=CoordinateUnits::_radians_)
conversion to arcseconds
Definition: Func.cpp:148

cbl::bin_function
void bin_function(const std::string file_grid, double func(double, void *), void *par, const int bin, const double x_min, const double x_max, const std::string binning, std::vector< double > &xx, std::vector< double > &yy)
create a 1D grid given an input function
Definition: Func.cpp:1118

cbl::distribution_probability
double distribution_probability(double xx, std::shared_ptr< void > pp, std::vector< double > par)
probability of an interpolated distribution
Definition: Func.cpp:58

cbl::read_vector
void read_vector(const std::string file_vector, std::vector< double > &xx, std::vector< double > &vector, const std::vector< int > col={})
read a vector from file
Definition: Func.cpp:582

cbl::window_function
double window_function(const double x, const double min=-1, const double max=1)
the unnormalized window function
Definition: Func.cpp:2538

cbl::wigner3j_auxB
double wigner3j_auxB(double l1, double l2, double l3, double m1, double m2, double m3)
Wigner  auxiliar function B.
Definition: Func.cpp:2253

cbl::number_from_distribution
double number_from_distribution(const std::vector< double > xx, const std::vector< double > fx, const double xmin, const double xmax, const int seed)
return a number sampled from a given distribution
Definition: Func.cpp:1446

cbl::xi2D_lin_model
double xi2D_lin_model(const double beta, const double bias, const double xi_real, const double xi_, const double xi__, const double P_2, const double P_4)
the linear dispersion model for ξ(rp,π)
Definition: FuncXi.cpp:473

cbl::wigner_6j
double wigner_6j(const int j1, const int j2, const int j3, const int j4, const int j5, const int j6)
Wigner  symbol.
Definition: Func.cpp:2502

cbl::wp
double wp(const double rp, const std::vector< double > rr, const std::vector< double > xi, const double r_max=100.)
the projected two-point correlation function
Definition: FuncXi.cpp:192

cbl::polar_coord
void polar_coord(const double XX, const double YY, const double ZZ, double &ra, double &dec, double &dd)
conversion from Cartesian coordinates to polar coordinates
Definition: Func.cpp:214

cbl::b_nl
double b_nl(const double rr, const double bA, const double bB=10., const double bC=4.)
a possible parameterization of the non-linear bias
Definition: FuncXi.cpp:653

cbl::arcminutes
double arcminutes(const double angle, const CoordinateUnits inputUnits=CoordinateUnits::_radians_)
conversion to arcminutes
Definition: Func.cpp:170

cbl::minimum_maximum_indexes
std::vector< size_t > minimum_maximum_indexes(const std::vector< double > xx, const double x_min, const double x_max)
return the std::vector indexes corresponding to a given interval
Definition: Func.cpp:1503