Einasto profile¶
This module implements the Einasto form of the density profile. Please see Halo Density Profiles for a general introduction to the Colossus density profile module.
Basics¶
The Einasto profile (Einasto 1965) is defined by the density function
or, alternatively, by a logarithmic slope that evolves with radius as
The third parameter, \(\alpha\), determines how quickly the profile steepens with slope. The Einasto profile class can be initialized from its fundamental parameters \(\rho_{\rm s}\), \(r_{\rm s}\), and \(\alpha\), but the more convenient initialization is via mass and concentration:
from colossus.cosmology import cosmology
from colossus.halo import profile_einasto
cosmology.setCosmology('planck15')
p_einasto = profile_einasto.EinastoProfile(M = 1E12, c = 10.0, z = 0.0, mdef = 'vir')
In this case, \(\alpha\) is determined automatically using the formula of Gao et al. 2008,
Please see the Tutorials for more code examples.
Module reference¶

class
halo.profile_einasto.
EinastoProfile
(rhos=None, rs=None, alpha=None, M=None, c=None, z=None, mdef=None, **kwargs)¶ The Einasto 1965 density profile.
The constructor accepts either the free parameters (the density at the scale radius, the scale radius, and alpha), or a spherical overdensity mass and concentration (in this case the mass definition and redshift also need to be specified). In the latter case, the user can specify alpha or let the constructor compute it from its tight correlation with peak height (Gao et al. 2008). In the latter case, a cosmology must be set before instantiating the profile object.
 Parameters
 rhos: float
The density at the scale radius in physical \(M_{\odot} h^2 / {\rm kpc}^3\).
 rs: float
The scale radius in physical kpc/h.
 alpha: float
The radial dependence of the profile slope.
 M: float
A spherical overdensity mass in \(M_{\odot}/h\) corresponding to the mass definition
mdef
at redshiftz
. c: float
The concentration, \(c = R / r_{\rm s}\), corresponding to the given halo mass and mass definition.
 z: float
Redshift
 mdef: str
The mass definition in which
M
andc
are given. See Halo Mass Definitions for details.
Methods
MDelta
(self, z, mdef)The spherical overdensity mass of a given mass definition.
RDelta
(self, z, mdef)The spherical overdensity radius of a given mass definition.
RMDelta
(self, z, mdef)The spherical overdensity radius and mass of a given mass definition.
Vmax
(self)The maximum circular velocity, and the radius where it occurs.
circularVelocity
(self, r)The circular velocity, \(v_c \equiv \sqrt{GM(<r)/r}\).
cumulativePdf
(self, r[, Rmax, z, mdef])The cumulative distribution function of the profile.
deltaSigma
(self, r[, interpolate, …])The excess surface density at radius r.
deltaSigmaInner
(self, r[, interpolate, …])The excess surface density at radius r due to the inner profile.
deltaSigmaOuter
(self, r[, interpolate, …])The excess surface density at radius r due to the outer profile.
density
(self, r)Density as a function of radius.
densityDerivativeLin
(self, r)The linear derivative of density, \(d \rho / dr\).
densityDerivativeLinInner
(self, r)The linear derivative of the inner density, \(d \rho_{\rm inner} / dr\).
densityDerivativeLinOuter
(self, r)The linear derivative of the outer density, \(d \rho_{\rm outer} / dr\).
densityDerivativeLog
(self, r)The logarithmic derivative of density, \(d \log(\rho) / d \log(r)\).
densityDerivativeLogInner
(self, r)The logarithmic derivative of the inner density, \(d \log(\rho_{\rm inner}) / d \log(r)\).
densityDerivativeLogOuter
(self, r)The logarithmic derivative of the outer density, \(d \log(\rho_{\rm outer}) / d \log(r)\).
densityInner
(self, r)Density of the inner profile as a function of radius.
densityOuter
(self, r)Density of the outer profile as a function of radius.
enclosedMass
(self, r[, accuracy])The mass enclosed within radius r.
enclosedMassInner
(self, r)The mass enclosed within radius r.
enclosedMassOuter
(self, r[, accuracy])The mass enclosed within radius r due to the outer profile term.
fit
(self, r, q, quantity[, q_err, q_cov, …])Fit the density, mass, or surface density profile to a given set of data points.
fundamentalParameters
(self, M, c, z, mdef[, …])The fundamental Einasto parameters, \(\rho_{\rm s}\), \(r_{\rm s}\), and \(\alpha\) from mass and concentration.
getParameterArray
(self[, mask])Returns an array of the profile parameters.
setParameterArray
(self, pars[, mask])Set the profile parameters from an array.
surfaceDensity
(self, r[, interpolate, …])The projected surface density at radius r.
surfaceDensityInner
(self, r[, interpolate, …])The projected surface density at radius r due to the inner profile.
surfaceDensityOuter
(self, r[, interpolate, …])The projected surface density at radius r due to the outer profile.
update
(self)Update the profile object after a change in parameters.

fundamentalParameters
(self, M, c, z, mdef, alpha=None)¶ The fundamental Einasto parameters, \(\rho_{\rm s}\), \(r_{\rm s}\), and \(\alpha\) from mass and concentration.
This routine is called in the constructor of the Einasto profile class (unless \(\rho_{\rm s}\), \(\rho_{\rm s}\) and \(\alpha\) are passed by the user), and cannot be called without instantiating an EinastoProfile object.
 Parameters
 M: float
Spherical overdensity mass in \(M_{\odot}/h\); can be a number or a numpy array.
 c: float
The concentration, \(c = R / r_{\rm s}\), corresponding to the given halo mass and mass definition; must have the same dimensions as
M
. z: float
Redshift
 mdef: str
The mass definition in which
M
andc
are given. See Halo Mass Definitions for details. alpha: float
The radial dependence of the profile slope; can be
None
in which case it is approximated.
 Returns
 rhos: float
The density at the scale radius in physical \(M_{\odot} h^2 / {\rm kpc}^3\).
 rs: float
The scale radius in physical kpc/h.
 alpha: float
The radial dependence of the profile slope.

update
(self)¶ Update the profile object after a change in parameters.
If the parameters dictionary has been changed (e.g. by the user or during fitting), this function must be called to ensure consistency within the profile object. This involves deleting any precomputed quantities (e.g., tabulated enclosed masses) and recomputing profile properties that depend on the parameters.

setParameterArray
(self, pars, mask=None)¶ Set the profile parameters from an array.
The profile parameters are internally stored in an ordered dictionary. For some applications (e.g., fitting), setting them directly from an array might be necessary. If the profile contains values that depend on the parameters, the profile class must overwrite this function and update according to the new parameters.
 Parameters
 pars: array_like
The new parameter array.
 mask: array_like
Optional; must be a numpy array (not a list) of booleans, with the same length as the parameter vector of the profile class (profile.N_par). If passed, only those parameters that correspond to
True
values are set (meaning the pars parameter must be shorter than profile.N_par).

densityInner
(self, r)¶ Density of the inner profile as a function of radius.
 Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 Returns
 density: array_like
Density in physical \(M_{\odot} h^2 / {\rm kpc}^3\); has the same dimensions as
r
.

densityDerivativeLinInner
(self, r)¶ The linear derivative of the inner density, \(d \rho_{\rm inner} / dr\).
 Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 Returns
 derivative: array_like
The linear derivative in physical \(M_{\odot} h / {\rm kpc}^2\); has the same dimensions as r.

densityDerivativeLogInner
(self, r)¶ The logarithmic derivative of the inner density, \(d \log(\rho_{\rm inner}) / d \log(r)\).
 Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 Returns
 derivative: array_like
The dimensionless logarithmic derivative; has the same dimensions as
r
.

enclosedMassInner
(self, r)¶ The mass enclosed within radius r.
 Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 accuracy: float
The minimum accuracy of the integration.
 Returns
 M: array_like
The mass enclosed within radius r, in \(M_{\odot}/h\); has the same dimensions as r.

MDelta
(self, z, mdef)¶ The spherical overdensity mass of a given mass definition.
 Parameters
 z: float
Redshift
 mdef: str
The mass definition for which the spherical overdensity mass is computed. See Halo Mass Definitions for details.
 Returns
 M: float
Spherical overdensity mass in \(M_{\odot} /h\).

RDelta
(self, z, mdef)¶ The spherical overdensity radius of a given mass definition.
 Parameters
 z: float
Redshift
 mdef: str
The mass definition for which the spherical overdensity radius is computed. See Halo Mass Definitions for details.
 Returns
 R: float
Spherical overdensity radius in physical kpc/h.

RMDelta
(self, z, mdef)¶ The spherical overdensity radius and mass of a given mass definition.
This is a wrapper for the
RDelta()
andMDelta()
functions which returns both radius and mass. Parameters
 z: float
Redshift
 mdef: str
The mass definition for which the spherical overdensity mass is computed. See Halo Mass Definitions for details.
 Returns
 R: float
Spherical overdensity radius in physical kpc/h.
 M: float
Spherical overdensity mass in \(M_{\odot} /h\).

Vmax
(self)¶ The maximum circular velocity, and the radius where it occurs.
 Returns
 vmax: float
The maximum circular velocity in km / s.
 rmax: float
The radius where fmax occurs, in physical kpc/h.
See also
circularVelocity
The circular velocity, \(v_c \equiv \sqrt{GM(<r)/r}\).

circularVelocity
(self, r)¶ The circular velocity, \(v_c \equiv \sqrt{GM(<r)/r}\).
 Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 Returns
 vc: float
The circular velocity in km / s; has the same dimensions as
r
.
See also
Vmax
The maximum circular velocity, and the radius where it occurs.

cumulativePdf
(self, r, Rmax=None, z=None, mdef=None)¶ The cumulative distribution function of the profile.
Some density profiles do not converge to a finite mass at large radius, and the distribution thus needs to be cut off. The user can specify either a radius (in physical kpc/h) where the profile is cut off, or a mass definition and redshift to compute this radius (e.g., the virial radius \(R_{vir}\) at z = 0).
 Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 Rmax: float
The radius where to cut off the profile in physical kpc/h.
 z: float
Redshift
 mdef: str
The radius definition for the cutoff radius. See Halo Mass Definitions for details.
 Returns
 pdf: array_like
The probability for mass to lie within radius
r
; has the same dimensions asr
.

deltaSigma
(self, r, interpolate=True, interpolate_surface_density=True, accuracy=0.0001, min_r_interpolate=1e06, max_r_interpolate=100000000.0, max_r_integrate=1e+20)¶ The excess surface density at radius r.
This quantity is useful in weak lensing studies, and is defined as \(\Delta\Sigma(R) = \Sigma(<R)\Sigma(R)\) where \(\Sigma(<R)\) is the averaged surface density within R weighted by area,
\[\Delta\Sigma(R) = \frac{1}{\pi R^2} \int_0^{R} 2 \pi r \Sigma(r) dr  \Sigma(R)\] Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 interpolate: bool
Use an interpolation table for the surface density during the integration. This can speed up the evaluation significantly, as the surface density can be expensive to evaluate.
 interpolate_surface_density: bool
Use an interpolation table for density during the computation of the surface density. This should make the evaluation somewhat faster, but can fail for some density terms which are negative at particular radii.
 accuracy: float
The minimum accuracy of the integration (used both to compute the surface density and average it to get DeltaSigma).
 min_r_interpolate: float
The minimum radius in physical kpc/h from which the surface density profile is averaged.
 max_r_interpolate: float
The maximum radius in physical kpc/h to which the density profile is integrated when using interpolating density.
 max_r_integrate: float
The maximum radius in physical kpc/h to which the density profile is integrated when using exact densities.
 Returns
 DeltaSigma: array_like
The excess surface density at radius
r
, in physical \(M_{\odot} h/{\rm kpc}^2\); has the same dimensions asr
.

deltaSigmaInner
(self, r, interpolate=True, interpolate_surface_density=True, accuracy=0.0001, min_r_interpolate=1e06, max_r_interpolate=100000000.0, max_r_integrate=1e+20)¶ The excess surface density at radius r due to the inner profile.
 Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 interpolate: bool
Use an interpolation table for the surface density during the integration. This can speed up the evaluation significantly, as the surface density can be expensive to evaluate.
 interpolate_surface_density: bool
Use an interpolation table for density during the computation of the surface density. This should make the evaluation somewhat faster, but can fail for some density terms which are negative at particular radii.
 accuracy: float
The minimum accuracy of the integration (used both to compute the surface density and average it to get DeltaSigma).
 min_r_interpolate: float
The minimum radius in physical kpc/h from which the surface density profile is averaged.
 max_r_interpolate: float
The maximum radius in physical kpc/h to which the density profile is integrated when using interpolating density.
 max_r_integrate: float
The maximum radius in physical kpc/h to which the density profile is integrated when using exact densities.
 Returns
 DeltaSigma: array_like
The excess surface density at radius
r
, in physical \(M_{\odot} h/{\rm kpc}^2\); has the same dimensions asr
.

deltaSigmaOuter
(self, r, interpolate=True, interpolate_surface_density=True, accuracy=0.0001, min_r_interpolate=1e06, max_r_interpolate=100000000.0, max_r_integrate=1e+20)¶ The excess surface density at radius r due to the outer profile.
 Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 interpolate: bool
Use an interpolation table for the surface density during the integration. This can speed up the evaluation significantly, as the surface density can be expensive to evaluate.
 interpolate_surface_density: bool
Use an interpolation table for density during the computation of the surface density. This should make the evaluation somewhat faster, but can fail for some density terms which are negative at particular radii.
 accuracy: float
The minimum accuracy of the integration (used both to compute the surface density and average it to get DeltaSigma).
 min_r_interpolate: float
The minimum radius in physical kpc/h from which the surface density profile is averaged.
 max_r_interpolate: float
The maximum radius in physical kpc/h to which the density profile is integrated when using interpolating density.
 max_r_integrate: float
The maximum radius in physical kpc/h to which the density profile is integrated when using exact densities.
 Returns
 DeltaSigma: array_like
The excess surface density at radius
r
, in physical \(M_{\odot} h/{\rm kpc}^2\); has the same dimensions asr
.

density
(self, r)¶ Density as a function of radius.
Abstract function which must be overwritten by child classes.
 Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 Returns
 density: array_like
Density in physical \(M_{\odot} h^2 / {\rm kpc}^3\); has the same dimensions as
r
.

densityDerivativeLin
(self, r)¶ The linear derivative of density, \(d \rho / dr\).
This function should generally not be overwritten by child classes since it handles the general case of adding up the contributions from the inner and outer terms.
 Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 Returns
 derivative: array_like
The linear derivative in physical \(M_{\odot} h / {\rm kpc}^2\); has the same dimensions as
r
.

densityDerivativeLinOuter
(self, r)¶ The linear derivative of the outer density, \(d \rho_{\rm outer} / dr\).
This function should generally not be overwritten by child classes since it handles the general case of adding up the contributions from all outer profile terms.
 Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 Returns
 derivative: array_like
The linear derivative in physical \(M_{\odot} h / {\rm kpc}^2\); has the same dimensions as
r
.

densityDerivativeLog
(self, r)¶ The logarithmic derivative of density, \(d \log(\rho) / d \log(r)\).
This function should generally not be overwritten by child classes since it handles the general case of adding up the contributions from the inner and outer profile terms.
 Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 Returns
 derivative: array_like
The dimensionless logarithmic derivative; has the same dimensions as
r
.

densityDerivativeLogOuter
(self, r)¶ The logarithmic derivative of the outer density, \(d \log(\rho_{\rm outer}) / d \log(r)\).
This function should generally not be overwritten by child classes since it handles the general case of adding up the contributions from outer profile terms.
 Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 Returns
 derivative: array_like
The dimensionless logarithmic derivative; has the same dimensions as
r
.

densityOuter
(self, r)¶ Density of the outer profile as a function of radius.
This function should generally not be overwritten by child classes since it handles the general case of adding up the contributions from all outer profile terms.
 Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 Returns
 density: array_like
Density in physical \(M_{\odot} h^2 / {\rm kpc}^3\); has the same dimensions as
r
.

enclosedMass
(self, r, accuracy=1e06)¶ The mass enclosed within radius r.
 Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 accuracy: float
The minimum accuracy of the integration.
 Returns
 M: array_like
The mass enclosed within radius
r
, in \(M_{\odot}/h\); has the same dimensions asr
.

enclosedMassOuter
(self, r, accuracy=1e06)¶ The mass enclosed within radius r due to the outer profile term.
 Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 accuracy: float
The minimum accuracy of the integration.
 Returns
 M: array_like
The mass enclosed within radius
r
, in \(M_{\odot}/h\); has the same dimensions asr
.

fit
(self, r, q, quantity, q_err=None, q_cov=None, method='leastsq', mask=None, verbose=True, tolerance=1e05, maxfev=0, initial_step=0.1, nwalkers=100, random_seed=None, convergence_step=100, converged_GR=0.01, best_fit='median', output_every_n=100)¶ Fit the density, mass, or surface density profile to a given set of data points.
This function represents a general interface for finding the bestfit parameters of a halo density profile given a set of data points. These points can represent a number of different physical quantities:
quantity
can either be density, enclosed mass, surface density, or Delta Sigma (rho
,M
,Sigma
, orDeltaSigma
).The data points q at radii r can optionally have error bars, and the user can pass a full covariance matrix. Please note that not passing any estimate of the uncertainty, i.e.
q_err = None
andq_cov = None
, can lead to very poor fit results: the fitter will minimize the absolute difference between points, strongly favoring the high densities at the center.There are two fundamental methods for performing the fit, a leastsquares minimization (
method = 'leastsq'
) and a MarkovChain Monte Carlo (method = 'mcmc'
). The MCMC method has some specific options (see below). In either case, the current parameters of the profile instance serve as an initial guess. Finally, the user can choose to vary only a subset of the profile parameters through themask
parameter.The function returns a dictionary with outputs that depend on which method is chosen. After this function has completed, the profile instance represents the bestfit profile to the data points (i.e., its parameters are the bestfit parameters). Note that all output parameters are bundled into one dictionary. The explanations below refer to the entries in this dictionary.
 Parameters
 r: array_like
The radii of the data points, in physical kpc/h.
 q: array_like
The data to fit; can either be density in physical \(M_{\odot} h^2 / {\rm kpc}^3\), enclosed mass in \(M_{\odot} /h\), or surface density in physical \(M_{\odot} h/{\rm kpc}^2\). Must have the same dimensions as r.
 quantity: str
Indicates which quantity is given in as input in
q
, can berho
,M
,Sigma
, orDeltaSigma
. q_err: array_like
Optional; the uncertainty on the values in
q
in the same units. Ifmethod == 'mcmc'
, eitherq_err
orq_cov
must be passed. Ifmethod == 'leastsq'
and neitherq_err
norq_cov
are passed, the absolute different between data points and fit is minimized. In this case, the returnedchi2
is in units of absolute difference, meaning its value will depend on the units ofq
. q_cov: array_like
Optional; the covariance matrix of the elements in
q
, as a 2dimensional numpy array. This array must have dimensions of q**2 and be in units of the square of the units ofq
. Ifq_cov
is passed,q_err
is ignored since the diagonal elements ofq_cov
correspond to q_err**2. method: str
The fitting method; can be
leastsq
for a leastsquares minimization ofmcmc
for a MarkovChain Monte Carlo. mask: array_like
Optional; a numpy array of booleans that has the same length as the variables vector of the density profile class. Only variables where
mask == True
are varied in the fit, all others are kept constant. Important: this has to be a numpy array rather than a list. verbose: bool / int
If true, output information about the fitting process. The flag can also be set as a number, where 1 has the same effect as True, and 2 outputs large amounts of information such as the fit parameters at each iteration.
 tolerance: float
Only active when
method == 'leastsq'
. The accuracy to which the bestfit parameters are found. maxfev: int
Only active when
method == 'leastsq'
. The maximum number of function evaluations before the fit is aborted. If zero, the default value of the scipy leastsq function is used. initial_step: array_like
Only active when
method == 'mcmc'
. The MCMC samples (“walkers”) are initially distributed in a Gaussian around the initial guess. The width of the Gaussian is given by initial_step, either as an array of lengthN_par
(giving the width of each Gaussian) or as a float number, in which case the width is set to initial_step times the initial value of the parameter. nwalkers: int
Only active when
method == 'mcmc'
. The number of MCMC samplers that are run in parallel. random_seed: int
Only active when
method == 'mcmc'
. If random_seed is not None, it is used to initialize the random number generator. This can be useful for reproducing results. convergence_step: int
Only active when
method == 'mcmc'
. The convergence criteria are computed every convergence_step steps (and output is printed ifverbose == True
). converged_GR: float
Only active when
method == 'mcmc'
. The maximum difference between different chains, according to the GelmanRubin criterion. Once the GR indicator is lower than this number in all parameters, the chain is ended. Setting this number too low leads to very long runtimes, but setting it too high can lead to inaccurate results. best_fit: str
Only active when
method == 'mcmc'
. This parameter determines whether themean
ormedian
value of the likelihood distribution is used as the output parameter set. output_every_n: int
Only active when
method == 'mcmc'
. This parameter determines how frequently the MCMC chain outputs information. Only effective ifverbose == True
.
 Returns
 results: dict
A dictionary bundling the various fit results. Regardless of the fitting method, the dictionary always contains the following entries:
x
: array_likeThe bestfit result vector. If mask is passed, this vector only contains those variables that were varied in the fit.
q_fit
: array_likeThe fitted profile at the radii of the data points; has the same units as
q
and the same dimensions asr
.chi2
: floatThe chi^2 of the bestfit profile. If a covariance matrix was passed, the covariances are taken into account. If no uncertainty was passed at all,
chi2
is in units of absolute difference, meaning its value will depend on the units ofq
.ndof
: intThe number of degrees of freedom, i.e. the number of fitted data points minus the number of free parameters.
chi2_ndof
: floatThe chi^2 per degree of freedom.
If
method == 'leastsq'
, the dictionary additionally contains the entries returned by scipy.optimize.leastsq as well as the following:nfev
: intThe number of function calls used in the fit.
x_err
: array_likeAn array of dimensions
[2, nparams]
which contains an estimate of the lower and upper uncertainties on the fitted parameters. These uncertainties are computed from the covariance matrix estimated by the fitter. Please note that this estimate does not exactly correspond to a 68% likelihood. In order to get more statistically meaningful uncertainties, please use the MCMC samples instead of leastsquares. In some cases, the fitter fails to return a covariance matrix, in which casex_err
isNone
.
If
method == 'mcmc'
, the dictionary contains the following entries:x_initial
: array_likeThe initial positions of the walkers, in an array of dimensions
[nwalkers, nparams]
.chain_full
: array_likeA numpy array of dimensions
[n_independent_samples, nparams]
with the parameters at each step in the chain. In this thin chain, only every nth step is output, where n is the autocorrelation time, meaning that the samples in this chain are truly independent.chain_thin
: array_likeLike the thin chain, but including all steps. Thus, the samples in this chain are not indepedent from each other. However, the full chain often gives better plotting results.
R
: array_likeA numpy array containing the GR indicator at each step when it was saved.
x_mean
: array_likeThe mean of the chain for each parameter; has length
nparams
.x_median
: array_likeThe median of the chain for each parameter; has length
nparams
.x_stddev
: array_likeThe standard deviation of the chain for each parameter; has length
nparams
.x_percentiles
: array_likeThe lower and upper values of each parameter that contain a certain percentile of the probability; has dimensions
[n_percentages, 2, nparams]
where the second dimension contains the lower/upper values.

getParameterArray
(self, mask=None)¶ Returns an array of the profile parameters.
The profile parameters are internally stored in an ordered dictionary. For some applications (e.g., fitting), a simply array is more appropriate.
 Parameters
 mask: array_like
Optional; must be a numpy array (not a list) of booleans, with the same length as the parameter vector of the profile class (profile.N_par). Only those parameters that correspond to
True
values are returned.
 Returns
 par: array_like
A numpy array with the profile’s parameter values.

surfaceDensity
(self, r, interpolate=True, accuracy=0.0001, max_r_interpolate=100000000.0, max_r_integrate=1e+20)¶ The projected surface density at radius r.
The surface density is computed by projecting the 3D density along the line of sight,
\[\Sigma(R) = 2 \int_R^{\infty} \frac{r \rho(r)}{\sqrt{r^2R^2}} dr\] Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 interpolate: bool
Use an interpolation table for density during the integration. This should make the evaluation somewhat faster, depending on how large the radius array is.
 accuracy: float
The minimum accuracy of the integration.
 max_r_interpolate: float
The maximum radius in physical kpc/h to which the density profile is integrated when using interpolating density.
 max_r_integrate: float
The maximum radius in physical kpc/h to which the density profile is integrated when using exact densities.
 Returns
 Sigma: array_like
The surface density at radius
r
, in physical \(M_{\odot} h/{\rm kpc}^2\); has the same dimensions asr
.

surfaceDensityInner
(self, r, interpolate=True, accuracy=0.0001, max_r_interpolate=100000000.0, max_r_integrate=1e+20)¶ The projected surface density at radius r due to the inner profile.
 Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 interpolate: bool
Use an interpolation table for density during the integration. This should make the evaluation somewhat faster, depending on how large the radius array is.
 accuracy: float
The minimum accuracy of the integration.
 max_r_interpolate: float
The maximum radius in physical kpc/h to which the density profile is integrated when using interpolating density.
 max_r_integrate: float
The maximum radius in physical kpc/h to which the density profile is integrated when using exact densities.
 Returns
 Sigma: array_like
The surface density at radius
r
, in physical \(M_{\odot} h/{\rm kpc}^2\); has the same dimensions asr
.

surfaceDensityOuter
(self, r, interpolate=True, accuracy=0.0001, max_r_interpolate=100000000.0, max_r_integrate=1e+20)¶ The projected surface density at radius r due to the outer profile.
This function checks whether there are explicit expressions for the surface density of the outer profile terms available, and uses them if possible. Note that there are some outer terms whose surface density integrates to infinity, such as the mean density of the universe which is constant to infinitely large radii.
 Parameters
 r: array_like
Radius in physical kpc/h; can be a number or a numpy array.
 interpolate: bool
Use an interpolation table for density during the integration. This should make the evaluation somewhat faster, depending on how large the radius array is.
 accuracy: float
The minimum accuracy of the integration.
 max_r_interpolate: float
The maximum radius in physical kpc/h to which the density profile is integrated when using interpolating density.
 max_r_integrate: float
The maximum radius in physical kpc/h to which the density profile is integrated when using exact densities.
 Returns
 Sigma: array_like
The surface density at radius
r
, in physical \(M_{\odot} h/{\rm kpc}^2\); has the same dimensions asr
.