HaloProfile.h

Go to the documentation of this file.

/********************************************************************
 *  Copyright (C) 2022 by Federico Marulli and Giorgio Lesci        *
 *  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 __HALOPROFILE__
#define __HALOPROFILE__ 
 
#include "Cosmology.h"
 
 
// ============================================================================================
 
 
namespace cbl {
  
  namespace cosmology {
 
    class HaloProfile { 
 
    private :
    
      std::shared_ptr<cosmology::Cosmology> m_cosmology = NULL;
      
      std::string m_profile_author = par::defaultString;
      
      std::string m_halo_def;
      
      double m_Delta;
      
      std::function<double(const double, cbl::cosmology::Cosmology, const double)> m_Delta_func;
      
      double m_trunc_fact;
      
      bool m_miscentering;
      
      double m_sigma_off;
      
      double m_f_off;
      
      double m_sigma_off_threshold;
      
      double m_f_off_threshold;
      
      double m_min_Smis;
      
      double m_max_Smis;
      
      bool m_single_profile;
      
      std::vector<double> (HaloProfile::*m_rho_ptr) (const std::vector<double>);
      
      double (HaloProfile::*m_rho_s_ptr) ();
      
      std::vector<double> (HaloProfile::*m_Sigma_mis_ptr) (const std::vector<double>);
      
      std::vector<double> (HaloProfile::*m_Sigma_cen_ptr) (const std::vector<double>);
      
      std::vector<double> (HaloProfile::*m_Sigma_mean_cen_ptr) (const std::vector<double>);
      
      std::vector<double> (HaloProfile::*m_Sigma_ptr) (const std::vector<double>);
      
      std::vector<double> (HaloProfile::*m_DeltaSigma_mis_ptr) (const std::vector<double>);
      
      std::vector<double> (HaloProfile::*m_DeltaSigma_cen_ptr) (const std::vector<double>);
      
      std::vector<double> (HaloProfile::*m_DeltaSigma_ptr) (const std::vector<double>);
    
      bool m_isSet_cM_relation = false;
      
      double (HaloProfile::*m_return_concentration) ();
      
      double m_A = par::defaultDouble;
      
      double m_B = par::defaultDouble;
      
      double m_C = par::defaultDouble;
 
      double m_mass = par::defaultDouble;
      
      double m_concentration = par::defaultDouble;
      
      double m_redshift = par::defaultDouble;
      
      
      void m_set_profile (const cbl::cosmology::Cosmology cosmology, const double redshift, const double conc, const double Mass, const double Delta, const std::string profile_author, const std::string halo_def, const double trunc_fact=3., const bool miscentering=false, const bool single_profile=false, const double sigma_off=0.1, const double f_off=1.);
    
      double m_return_set_concentration ()
      { return m_concentration; }
      
      double m_concentration_Duffy ();
      
      double m_rho_s_NFW ();
      
      double m_rho_s_NFW_trunc ();
      
      std::vector<double> m_rho_NFW (const std::vector<double> rad);
      
      std::vector<double> m_rho_NFW_trunc (const std::vector<double> rad);
      
      std::vector<double> m_Sigma_NFW (const std::vector<double> rad);
      
      std::vector<double> m_Sigma_mean_NFW (const std::vector<double> rad);
      
      std::vector<double> m_Sigma_NFW_trunc (const std::vector<double> rad);
      
      std::vector<double> m_Sigma_mean_NFW_trunc (const std::vector<double> rad);
      
      std::vector<double> m_Sigma_mis (const std::vector<double> rad);
      
      std::vector<double> m_Sigma_including_miscentering (const std::vector<double> rad);
      
      std::vector<double> m_DeltaSigma_cen (const std::vector<double> rad);
      
      std::vector<double> m_DeltaSigma_mis (const std::vector<double> rad);
      
      std::vector<double> m_DeltaSigma_including_miscentering (const std::vector<double> rad);
      
      void m_set_cM_relation (const std::string cM_author="Duffy");
 
      
      
    public:
    
 
      HaloProfile () = default;
 
      HaloProfile (const cbl::cosmology::Cosmology cosmology, const double redshift, const double conc, const double Mass, const double Delta, const std::string profile_author, const std::string halo_def, const double trunc_fact=3., const bool miscentering=false, const bool single_profile=false, const double sigma_off=0.1, const double f_off=1.);
      
      HaloProfile (const cbl::cosmology::Cosmology cosmology, const double redshift, const std::string cM_author, const double Mass, const double Delta, const std::string profile_author, const std::string halo_def, const double trunc_fact=3., const bool miscentering=false, const bool single_profile=false, const double sigma_off=0.1, const double f_off=1.);
      
      ~HaloProfile () = default;
 
  
  
      
      double concentration ()
      { return (this->*m_return_concentration)(); }
    
      double concentration2 (const double Vmax, const double Rmax) const;
      
      double Delta ()
      { return m_Delta_func(m_Delta,*m_cosmology,m_redshift); }
      
      std::vector<double> density_profile_3D (const std::vector<double> rad);
      
      double rho_s ();
      
      std::vector<double> Sigma (const std::vector<double> rad);
      
      std::vector<double> Sigma_mis (const std::vector<double> rad);
      
      std::vector<double> Sigma_cen (const std::vector<double> rad);     
      
      std::vector<double> Sigma_2h (const std::vector<double> rad, const std::string bias_author, const std::string method_Pk="EisensteinHu", const std::string interp_type="Linear", const bool NL=false);     
      
      std::vector<double> Sigma_2h (const std::vector<double> rad, const double bias, const std::string method_Pk="EisensteinHu", const std::string interp_type="Linear", const bool NL=false);
      
      std::vector<double> DeltaSigma (const std::vector<double> rad);
      
      std::vector<double> DeltaSigma_mis (const std::vector<double> rad);
      
      std::vector<double> DeltaSigma_cen (const std::vector<double> rad);
      
      std::vector<double> DeltaSigma_2h (const std::vector<double> rad, const std::string bias_author, const std::string method_Pk="EisensteinHu", const std::string interp_type="Linear", const bool NL=false);     
      
      std::vector<double> DeltaSigma_2h (const std::vector<double> rad, const double bias, const std::string method_Pk="EisensteinHu", const std::string interp_type="Linear", const bool NL=false);
      
      
      double density_profile_FourierSpace (const double kk);
      
      double Mass_Delta (const double Mass, const double Delta_in, const double Delta_out, const double conc, const bool is_input_conc, const double rRmin_guess=1.e-3, const double rRmax_guess=10.) const;      
 
  
  
      
      void set_cosmology (const cbl::cosmology::Cosmology cosmology);
      
      void set_mass (const double mass=par::defaultDouble)
      { m_mass = mass; }
      
      void set_concentration (const double conc=par::defaultDouble)
      { m_concentration = conc; }
      
      void set_f_off (const double f_off=par::defaultDouble)
      { m_f_off = f_off; }
      
      void set_sigma_off (const double sigma_off=par::defaultDouble)
      { m_sigma_off = sigma_off; }
      
      void set_trunc_fact (const double trunc_fact=par::defaultDouble)
      { m_trunc_fact = trunc_fact; }
      
    
    };
  }
}
 
#endif