A class for calculating the deflection, kappa and gamma caused by an NFW halos.
More...
|
|
| LensHaloNFW () |
| | Shell constructor. Sets the halo to zero mass.
|
| |
| | LensHaloNFW (float my_mass, float my_Rsize, PosType my_zlens, float my_concentration, float my_fratio, float my_pa, const COSMOLOGY &cosmo, EllipMethod my_ellip_method=EllipMethod::Pseudo) |
| |
|
| LensHaloNFW (const LensHaloNFW &h) |
| |
|
| LensHaloNFW (const LensHaloNFW &&h) |
| |
|
LensHaloNFW & | operator= (const LensHaloNFW &h) |
| |
|
LensHaloNFW & | operator= (const LensHaloNFW &&h) |
| |
| PosType | ffunction (PosType x) const |
| |
| PosType | gfunction (PosType x) const |
| |
| PosType | dgfunctiondx (PosType x) |
| |
|
PosType | g2function (PosType x) const |
| |
|
PosType | hfunction (PosType x) const |
| |
| PosType | dhfunction (PosType x) const |
| |
| PosType | ddhfunction (PosType x, bool numerical) |
| |
| PosType | dddhfunction (PosType x, bool numerical) |
| |
| PosType | bfunction (PosType x) |
| |
| PosType | dbfunction (PosType x) |
| |
| PosType | ddbfunction (PosType x) |
| |
| PosType | dmoddb (int whichmod, PosType q, PosType b) |
| | dbfunction and ddbfunction are approximation formulae for dbeta/dr and d^2beta/dr^2 whereas dbnum and ddbnum calculate those derivates numerically using the 5-point rule, i.e. 4th order accuracy.
|
| |
| PosType | ddmoddb (int whichmod, PosType q, PosType b) |
| |
| PosType | dmoddq (int whichmod, PosType q, PosType b) |
| |
| PosType | ddmoddq (int whichmod, PosType q, PosType b) |
| |
| void | alphaNFW (PosType *alpha, PosType *x, PosType Rtrunc, PosType mass, PosType r_scale, PosType *center, PosType Sigma_crit) |
| | deflection caused by NFW halo
|
| |
|
KappaType | kappaNFW (PosType *x, PosType Rtrunc, PosType mass, PosType r_scale, PosType *center, PosType Sigma_crit) |
| | Convergence for an NFW halo.
|
| |
|
void | gammaNFW (KappaType *gamma, PosType *x, PosType Rtrunc, PosType mass, PosType r_scale, PosType *center, PosType Sigma_crit) |
| | Shear for and NFW halo. this might have a flaw in it.
|
| |
| void | initFromFile (float my_mass, long *seed, float vmax, float r_halfmass) |
| | Sets the profile to match the mass, Vmax and R_halfmass.
|
| |
| void | initFromMassFunc (float my_mass, float my_Rsize, float my_rscale, PosType my_slope, long *seed) |
| | initialize from a mass function
|
| |
|
void | set_RsizeXmax (float my_Rsize) |
| | set Rsize, xmax and gmax
|
| |
| void | set_rscaleXmax (float my_rscale) |
| |
|
| LensHalo () |
| | Shell constructor.
|
| |
|
| LensHalo (PosType z, const COSMOLOGY &cosmo) |
| |
| | LensHalo (const LensHalo &h) |
| |
|
| LensHalo (LensHalo &&h) |
| |
| LensHalo & | operator= (const LensHalo &h) |
| |
| LensHalo & | operator= (LensHalo &&h) |
| |
| float | get_Rmax () const |
| | this can be used to tag types of LensHalos
|
| |
|
float | getRsize () const |
| | get the Rsize which is the size of the halo in Mpc
|
| |
|
float | get_mass () const |
| | get the mass solar units
|
| |
|
float | get_rscale () const |
| | get the scale radius in Mpc
|
| |
|
PosType | getZlens () const |
| | get the redshift
|
| |
|
void | getX (PosType *MyPosHalo) const |
| | get the position of the Halo in physical Mpc on the lens plane
|
| |
|
PosType | operator[] (int i) const |
| | returns position of the Halo in physical Mpc on the lens plane
|
| |
|
void | setTheta (PosType PosX, PosType PosY) |
| | set the position of the Halo in radians
|
| |
|
void | setTheta (PosType *PosXY) |
| | set the position of the Halo in radians
|
| |
|
void | setTheta (const Point_2d &p) |
| | set the position of the Halo in radians
|
| |
|
void | getTheta (PosType *MyPosHalo) const |
| | get the position of the Halo in radians
|
| |
|
void | setDist (COSMOLOGY &co) |
| | Set the angular size distance to the halo. This should be the distance to the lens plane.
|
| |
| PosType | getDist () const |
| |
| void | displayPos () |
| |
|
virtual void | set_RsizeRmax (float my_Rsize) |
| | set Rsize (in Mpc) and reset Rmax
|
| |
|
void | set_mass (float my_mass) |
| | set mass (in solar masses)
|
| |
|
virtual void | set_rscale (float my_rscale) |
| | set scale radius (in Mpc)
|
| |
|
void | setZlens (PosType my_zlens, const COSMOLOGY &cosmo) |
| | set redshift
|
| |
|
void | setRsize (PosType R) |
| |
|
void | setZlensDist (PosType my_zlens, const COSMOLOGY &cos) |
| |
|
void | setMass (PosType m) |
| |
| virtual void | set_slope (PosType my_slope) |
| | set slope
|
| |
| virtual PosType | get_slope () |
| | get slope
|
| |
|
bool | get_flag_elliptical () |
| | flag=True if halo elliptical
|
| |
|
void | set_flag_elliptical (bool ell) |
| |
|
bool | get_switch_flag () |
| |
|
void | set_switch_flag (bool swt) |
| | flag permits case distinction in force_halo_asym for elliptical NFWs only (get_switch_flag==true), in latter case the mass_norm_factor^2 is used instead of mass_norm_factor.
|
| |
| virtual void | setCosmology (const COSMOLOGY &cosmo) |
| | used for elliptical NFWs only, in that case get_switch_flag==true
|
| |
| virtual void | force_halo (PosType *alpha, KappaType *kappa, KappaType *gamma, KappaType *phi, PosType const *xcm, bool subtract_point=false, PosType screening=1.0) |
| |
| bool | compareZ (PosType z) |
| | force tree calculation for stars
|
| |
| EllipMethod | getEllipMethod () const |
| | stars
|
| |
|
std::vector< double > | get_mod () |
| | get vector of Fourier modes, which are calculated in the constructors of the LensHaloes when main_ellip_method is set to 'Fourier'
|
| |
|
virtual std::size_t | Nparams () const |
| | get the number of halo parameters
|
| |
|
virtual PosType | getParam (std::size_t p) const |
| | get the value of a scaled halo parameter by index
|
| |
|
virtual PosType | setParam (std::size_t p, PosType value) |
| | set the value of a scaled halo parameter by index
|
| |
|
virtual void | printCSV (std::ostream &, bool header=false) const |
| | print the halo parameters in CSV format
|
| |
| PosType | MassBy2DIntegation (PosType R) |
| | Prints star parameters; if show_stars is true, prints data for single stars.
|
| |
|
PosType | MassBy1DIntegation (PosType R) |
| | calculates the mass within radius R by integating alpha on a ring and using Gauss' law, used only for testing
|
| |
|
PosType | test_average_gt (PosType R) |
| | calculates the average gamma_t for LensHalo::test()
|
| |
|
PosType | test_average_kappa (PosType R) |
| |
|
void | set_norm_factor () |
| |
|
void | set_rsize (float my_rsize) |
| | set radius rsize beyond which interpolation values between alpha_ellip and alpha_iso are computed
|
| |
|
float | get_rsize () |
| |
| bool | test () |
| | perform some basic consistancy checks for halo
|
| |
|
size_t | getID () const |
| |
|
void | setID (size_t id) |
| |
|
PosType | renormalization (PosType r_max) |
| |
| PixelMap< double > | map_variables (LensingVariable lensvar, size_t Nx, size_t Ny, double res) |
| | Map a PixelMap of the surface, density, potential and potential gradient centred on (0,0) in LensHalo coordinates.
|
| |
|
|
void | make_tables () |
| | make the specific tables
|
| |
|
PosType | InterpolateFromTable (PosType *table, PosType y) const |
| | interpolates from the specific tables
|
| |
| PosType | InterpolateModes (int whichmod, PosType q, PosType b) |
| |
|
void | assignParams (InputParams ¶ms) |
| | read in parameters from a parameterfile in InputParams params
|
| |
| PosType | alpha_h (PosType x) const |
| | r |alpha(r = x*rscale)| PI Sigma_crit / Mass
|
| |
| KappaType | kappa_h (PosType x) const |
| |
| KappaType | gamma_h (PosType x) const |
| |
| KappaType | phi_h (PosType x) const |
| |
| KappaType | phi_int (PosType x) const |
| |
|
PosType | alpha_int (PosType x) const |
| | Calculates potential (phi_int) from alpha_h. If flag is_alphah_a_table is True it takes and integrates directly the gfunction instead of alpha_h. The gfunction is used for the InterpolationTable used in alpha_h. Setting the flag to False speeds up the calculation of phi_h.
|
| |
|
PosType | norm_int (PosType r_max) |
| |
| void | force_halo_sym (PosType *alpha, KappaType *kappa, KappaType *gamma, KappaType *phi, PosType const *xcm, bool subtract_point=false, PosType screening=1.0) |
| | returns the lensing quantities of a ray in center of mass coordinates for a symmetric halo
|
| |
| void | force_halo_asym (PosType *alpha, KappaType *kappa, KappaType *gamma, KappaType *phi, PosType const *xcm, bool subtract_point=false, PosType screening=1.0) |
| |
|
bool | force_point (PosType *alpha, KappaType *kappa, KappaType *gamma, KappaType *phi, PosType const *xcm, PosType rcm2, bool subtract_point, PosType screening) |
| |
|
void | assignParams (InputParams ¶ms, bool needRsize) |
| | read in parameters from a parameterfile in InputParams params
|
| |
| void | error_message1 (std::string name, std::string filename) |
| | read in star parameters. This is valid for all halos and not overloaded.
|
| |
|
virtual PosType | bnumfunction (PosType x) |
| |
| void | faxial (PosType x, PosType theta, PosType f[]) |
| | If set to true the correct normalization is applied for asymmetric NFW profiles, the mass_norm_factor is different for the other halos.
|
| |
|
void | faxial0 (PosType theta, PosType f0[]) |
| |
|
void | faxial1 (PosType theta, PosType f1[]) |
| |
|
void | faxial2 (PosType theta, PosType f2[]) |
| |
|
void | gradial (PosType r, PosType g[]) |
| | Derivatives of the potential damping factor with respect to r ... TODO: come up with a better damping faction.
|
| |
|
void | gradial2 (PosType r, PosType mu, PosType sigma, PosType g[]) |
| |
| void | felliptical (PosType x, PosType q, PosType theta, PosType f[], PosType g[]) |
| | Calculate the derivatives of the G function = r*sqrt(cos(theta)^2 + q(r)^2 sin(theta))
|
| |
|
virtual void | gamma_asym (PosType x, PosType theta, PosType gamma[]) |
| |
| virtual PosType | kappa_asym (PosType x, PosType theta) |
| |
| virtual void | alphakappagamma_asym (PosType x, PosType theta, PosType alpha[], PosType *kappa, PosType gamma[], PosType *phi) |
| | Pseudo-elliptical profiles by Phi(G)-Ansatz.
|
| |
| virtual void | alphakappagamma1asym (PosType x, PosType theta, PosType alpha[2], PosType *kappa, PosType gamma[], PosType *phi) |
| | Elliptical profiles by Fourier-Ansatz.
|
| |
|
virtual void | alphakappagamma2asym (PosType x, PosType theta, PosType alpha[2], PosType *kappa, PosType gamma[], PosType *phi) |
| |
|
virtual void | alphakappagamma3asym (PosType x, PosType theta, PosType alpha[2], PosType *kappa, PosType gamma[], PosType *phi) |
| |
|
virtual PosType | alpha_ell (PosType x, PosType theta) |
| |
|
double | fourier_coeff (double n, double q, double beta) |
| | Calculates fourier-coefficients for power law halo.
|
| |
|
double | IDAXDM (double lambda, double a2, double b2, double x[], double rmax, double mo) |
| |
|
double | IDAYDM (double lambda, double a2, double b2, double x[], double rmax, double mo) |
| |
|
double | SCHRAMMKN (double n, double x[], double rmax) |
| |
|
double | SCHRAMMJN (double n, double x[], double rmax) |
| |
|
double | SCHRAMMI (double x[], double rmax) |
| |
|
void | calcModes (double q, double beta, double rottheta, PosType newmod[]) |
| | Calculates the modes for fourier expansion of power law halo. All the modes are relative to the zero mode to conserve mass throughout the calculation of kappa etc.
|
| |
|
void | calcModesB (PosType x, double q, double beta, double rottheta, PosType newmod[]) |
| |
|
void | calcModesC (PosType beta_r, double q, double rottheta, PosType newmod[]) |
| |
| void | analModes (int modnumber, PosType my_beta, PosType q, PosType amod[3]) |
| |
A class for calculating the deflection, kappa and gamma caused by an NFW halos.
This class uses the true expressions for the NFW profile. This is time consuming and not usually necessary. See TreeQuadPseudoNFW for a faster alternative.
The default value of theta = 0.1 generally gives better than 1% accuracy on alpha. The shear and kappa is always more accurate than the deflection.
Public Member Functions inherited from LensHalo
1.12.0