| Function: _check_task_dependency(self, level) | |
| Docstring: | |
| Fill the level list with all the needed modules | |
| .. warning:: | |
| the ordering of modules is obviously dependent on CLASS module order | |
| in the main.c file. This has to be updated in case of a change to | |
| this file. | |
| Parameters | |
| ---------- | |
| level : list | |
| list of strings, containing initially only the last module required. | |
| For instance, to recover all the modules, the input should be | |
| ['lensing'] | |
| --------------------------------- | |
| Function: compute(self, level=["distortions"]) | |
| Docstring: | |
| compute(level=["distortions"]) | |
| Main function, execute all the _init methods for all desired modules. | |
| This is called in MontePython, and this ensures that the Class instance | |
| of this class contains all the relevant quantities. Then, one can deduce | |
| Pk, Cl, etc... | |
| Parameters | |
| ---------- | |
| level : list | |
| list of the last module desired. The internal function | |
| _check_task_dependency will then add to this list all the | |
| necessary modules to compute in order to initialize this last | |
| one. The default last module is "lensing". | |
| .. warning:: | |
| level default value should be left as an array (it was creating | |
| problem when casting as a set later on, in _check_task_dependency) | |
| --------------------------------- | |
| Function: density_factor(self) | |
| Docstring: | |
| The density factor required to convert from the class-units of density to kg/m^3 (SI units) | |
| --------------------------------- | |
| Function: kgm3_to_eVMpc3(self) | |
| Docstring: | |
| Convert from kg/m^3 to eV/Mpc^3 | |
| --------------------------------- | |
| Function: kgm3_to_MsolMpc3(self) | |
| Docstring: | |
| Convert from kg/m^3 to Msol/Mpc^3 | |
| --------------------------------- | |
| Function: raw_cl(self, lmax=-1, nofail=False) | |
| Docstring: | |
| raw_cl(lmax=-1, nofail=False) | |
| Return a dictionary of the primary C_l | |
| Parameters | |
| ---------- | |
| lmax : int, optional | |
| Define the maximum l for which the C_l will be returned | |
| (inclusively). This number will be checked against the maximum l | |
| at which they were actually computed by CLASS, and an error will | |
| be raised if the desired lmax is bigger than what CLASS can | |
| give. | |
| nofail: bool, optional | |
| Check and enforce the computation of the harmonic module | |
| beforehand, with the desired lmax. | |
| Returns | |
| ------- | |
| cl : dict | |
| Dictionary that contains the power spectrum for 'tt', 'te', etc... The | |
| index associated with each is defined wrt. Class convention, and are non | |
| important from the python point of view. It also returns now the | |
| ell array. | |
| --------------------------------- | |
| Function: lensed_cl(self, lmax=-1,nofail=False) | |
| Docstring: | |
| lensed_cl(lmax=-1, nofail=False) | |
| Return a dictionary of the lensed C_l, computed by CLASS, without the | |
| density C_ls. They must be asked separately with the function aptly | |
| named density_cl | |
| Parameters | |
| ---------- | |
| lmax : int, optional | |
| Define the maximum l for which the C_l will be returned (inclusively) | |
| nofail: bool, optional | |
| Check and enforce the computation of the lensing module beforehand | |
| Returns | |
| ------- | |
| cl : dict | |
| Dictionary that contains the power spectrum for 'tt', 'te', etc... The | |
| index associated with each is defined wrt. Class convention, and are non | |
| important from the python point of view. | |
| --------------------------------- | |
| Function: density_cl(self, lmax=-1, nofail=False) | |
| Docstring: | |
| density_cl(lmax=-1, nofail=False) | |
| Return a dictionary of the primary C_l for the matter | |
| Parameters | |
| ---------- | |
| lmax : int, optional | |
| Define the maximum l for which the C_l will be returned (inclusively) | |
| nofail: bool, optional | |
| Check and enforce the computation of the lensing module beforehand | |
| Returns | |
| ------- | |
| cl : numpy array of numpy.ndarrays | |
| Array that contains the list (in this order) of self correlation of | |
| 1st bin, then successive correlations (set by non_diagonal) to the | |
| following bins, then self correlation of 2nd bin, etc. The array | |
| starts at index_ct_dd. | |
| --------------------------------- | |
| Function: luminosity_distance(self, z) | |
| Docstring: | |
| luminosity_distance(z) | |
| --------------------------------- | |
| Function: pk(self,double k,double z) | |
| Docstring: | |
| Gives the total matter pk (in Mpc**3) for a given k (in 1/Mpc) and z (will be non linear if requested to Class, linear otherwise) | |
| .. note:: | |
| there is an additional check that output contains `mPk`, | |
| because otherwise a segfault will occur | |
| --------------------------------- | |
| Function: pk_cb(self,double k,double z) | |
| Docstring: | |
| Gives the cdm+b pk (in Mpc**3) for a given k (in 1/Mpc) and z (will be non linear if requested to Class, linear otherwise) | |
| .. note:: | |
| there is an additional check that output contains `mPk`, | |
| because otherwise a segfault will occur | |
| --------------------------------- | |
| Function: pk_lin(self,double k,double z) | |
| Docstring: | |
| Gives the linear total matter pk (in Mpc**3) for a given k (in 1/Mpc) and z | |
| .. note:: | |
| there is an additional check that output contains `mPk`, | |
| because otherwise a segfault will occur | |
| --------------------------------- | |
| Function: pk_cb_lin(self,double k,double z) | |
| Docstring: | |
| Gives the linear cdm+b pk (in Mpc**3) for a given k (in 1/Mpc) and z | |
| .. note:: | |
| there is an additional check that output contains `mPk`, | |
| because otherwise a segfault will occur | |
| --------------------------------- | |
| Function: pk_numerical_nw(self,double k,double z) | |
| Docstring: | |
| Gives the nowiggle (smoothed) linear total matter pk (in Mpc**3) for a given k (in 1/Mpc) and z | |
| .. note:: | |
| there is an additional check that `numerical_nowiggle` was set to `yes`, | |
| because otherwise a segfault will occur | |
| --------------------------------- | |
| Function: pk_analytic_nw(self,double k) | |
| Docstring: | |
| Gives the linear total matter pk (in Mpc**3) for a given k (in 1/Mpc) and z | |
| .. note:: | |
| there is an additional check that `analytic_nowiggle` was set to `yes`, | |
| because otherwise a segfault will occur | |
| --------------------------------- | |
| Function: get_pk(self, np.ndarray[DTYPE_t,ndim=3] k, np.ndarray[DTYPE_t,ndim=1] z, int k_size, int z_size, int mu_size) | |
| Docstring: | |
| Fast function to get the power spectrum on a k and z array | |
| --------------------------------- | |
| Function: get_pk_cb(self, np.ndarray[DTYPE_t,ndim=3] k, np.ndarray[DTYPE_t,ndim=1] z, int k_size, int z_size, int mu_size) | |
| Docstring: | |
| Fast function to get the power spectrum on a k and z array | |
| --------------------------------- | |
| Function: get_pk_lin(self, np.ndarray[DTYPE_t,ndim=3] k, np.ndarray[DTYPE_t,ndim=1] z, int k_size, int z_size, int mu_size) | |
| Docstring: | |
| Fast function to get the linear power spectrum on a k and z array | |
| --------------------------------- | |
| Function: get_pk_cb_lin(self, np.ndarray[DTYPE_t,ndim=3] k, np.ndarray[DTYPE_t,ndim=1] z, int k_size, int z_size, int mu_size) | |
| Docstring: | |
| Fast function to get the linear power spectrum on a k and z array | |
| --------------------------------- | |
| Function: get_pk_all(self, k, z, nonlinear = True, cdmbar = False, z_axis_in_k_arr = 0, interpolation_kind='cubic') | |
| Docstring: | |
| General function to get the P(k,z) for ARBITRARY shapes of k,z | |
| Additionally, it includes the functionality of selecting wether to use the non-linear parts or not, | |
| and wether to use the cdm baryon power spectrum only | |
| For Multi-Dimensional k-arrays, it assumes that one of the dimensions is the z-axis | |
| This is handled by the z_axis_in_k_arr integer, as described in the source code | |
| --------------------------------- | |
| Function: get_pk_and_k_and_z(self, nonlinear=True, only_clustering_species = False, h_units=False) | |
| Docstring: | |
| Returns a grid of matter power spectrum values and the z and k | |
| at which it has been fully computed. Useful for creating interpolators. | |
| Parameters | |
| ---------- | |
| nonlinear : bool | |
| Whether the returned power spectrum values are linear or non-linear (default) | |
| only_clustering_species : bool | |
| Whether the returned power spectrum is for galaxy clustering and excludes massive neutrinos, or always includes everything (default) | |
| h_units : bool | |
| Whether the units of k in output are h/Mpc or 1/Mpc (default) | |
| Returns | |
| ------- | |
| pk : grid of power spectrum values, pk[index_k,index_z] | |
| k : vector of k values, k[index_k] (in units of 1/Mpc by default, or h/Mpc when setting h_units to True) | |
| z : vector of z values, z[index_z] | |
| --------------------------------- | |
| Function: get_transfer_and_k_and_z(self, output_format='class', h_units=False) | |
| Docstring: | |
| Returns a dictionary of grids of density and/or velocity transfer function values and the z and k at which it has been fully computed. | |
| Useful for creating interpolators. | |
| When setting CLASS input parameters, include at least one of 'dTk' (for density transfer functions) or 'vTk' (for velocity transfer functions). | |
| Following the default output_format='class', all transfer functions will be normalised to 'curvature R=1' at initial time | |
| (and not 'curvature R = -1/k^2' like in CAMB). | |
| You may switch to output_format='camb' for the CAMB definition and normalisation of transfer functions. | |
| (Then, 'dTk' must be in the input: the CAMB format only outputs density transfer functions). | |
| When sticking to output_format='class', you also get the newtonian metric fluctuations phi and psi. | |
| If you set the CLASS input parameter 'extra_metric_transfer_functions' to 'yes', | |
| you get additional metric fluctuations in the synchronous and N-body gauges. | |
| Parameters | |
| ---------- | |
| output_format : ('class' or 'camb') | |
| Format transfer functions according to CLASS (default) or CAMB | |
| h_units : bool | |
| Whether the units of k in output are h/Mpc or 1/Mpc (default) | |
| Returns | |
| ------- | |
| tk : dictionary containing all transfer functions. | |
| For instance, the grid of values of 'd_c' (= delta_cdm) is available in tk['d_c'] | |
| All these grids have indices [index_k,index,z], for instance tk['d_c'][index_k,index,z] | |
| k : vector of k values (in units of 1/Mpc by default, or h/Mpc when setting h_units to True) | |
| z : vector of z values | |
| --------------------------------- | |
| Function: get_Weyl_pk_and_k_and_z(self, nonlinear=False, h_units=False) | |
| Docstring: | |
| Returns a grid of Weyl potential (phi+psi) power spectrum values and the z and k | |
| at which it has been fully computed. Useful for creating interpolators. | |
| Note that this function just calls get_pk_and_k_and_z and corrects the output | |
| by the ratio of transfer functions [(phi+psi)/d_m]^2. | |
| Parameters | |
| ---------- | |
| nonlinear : bool | |
| Whether the returned power spectrum values are linear or non-linear (default) | |
| h_units : bool | |
| Whether the units of k in output are h/Mpc or 1/Mpc (default) | |
| Returns | |
| ------- | |
| Weyl_pk : grid of Weyl potential (phi+psi) spectrum values, Weyl_pk[index_k,index_z] | |
| k : vector of k values, k[index_k] (in units of 1/Mpc by default, or h/Mpc when setting h_units to True) | |
| z : vector of z values, z[index_z] | |
| --------------------------------- | |
| Function: sigma(self,R,z, h_units = False) | |
| Docstring: | |
| Gives sigma (total matter) for a given R and z | |
| (R is the radius in units of Mpc, so if R=8/h this will be the usual sigma8(z). | |
| This is unless h_units is set to true, in which case R is the radius in units of Mpc/h, | |
| and R=8 corresponds to sigma8(z)) | |
| .. note:: | |
| there is an additional check to verify whether output contains `mPk`, | |
| and whether k_max > ... | |
| because otherwise a segfault will occur | |
| --------------------------------- | |
| Function: sigma_cb(self,double R,double z, h_units = False) | |
| Docstring: | |
| Gives sigma (cdm+b) for a given R and z | |
| (R is the radius in units of Mpc, so if R=8/h this will be the usual sigma8(z) | |
| This is unless h_units is set to true, in which case R is the radius in units of Mpc/h, | |
| and R=8 corresponds to sigma8(z)) | |
| .. note:: | |
| there is an additional check to verify whether output contains `mPk`, | |
| and whether k_max > ... | |
| because otherwise a segfault will occur | |
| --------------------------------- | |
| Function: pk_tilt(self,double k,double z) | |
| Docstring: | |
| Gives effective logarithmic slope of P_L(k,z) (total matter) for a given k and z | |
| (k is the wavenumber in units of 1/Mpc, z is the redshift, the output is dimensionless) | |
| .. note:: | |
| there is an additional check to verify whether output contains `mPk` and whether k is in the right range | |
| --------------------------------- | |
| Function: angular_distance(self, z) | |
| Docstring: | |
| angular_distance(z) | |
| Return the angular diameter distance (exactly, the quantity defined by Class | |
| as index_bg_ang_distance in the background module) | |
| Parameters | |
| ---------- | |
| z : float | |
| Desired redshift | |
| --------------------------------- | |
| Function: angular_distance_from_to(self, z1, z2) | |
| Docstring: | |
| angular_distance_from_to(z) | |
| Return the angular diameter distance of object at z2 as seen by observer at z1, | |
| that is, sin_K((chi2-chi1)*np.sqrt(|k|))/np.sqrt(|k|)/(1+z2). | |
| If z1>z2 returns zero. | |
| Parameters | |
| ---------- | |
| z1 : float | |
| Observer redshift | |
| z2 : float | |
| Source redshift | |
| Returns | |
| ------- | |
| d_A(z1,z2) in Mpc | |
| --------------------------------- | |
| Function: comoving_distance(self, z) | |
| Docstring: | |
| comoving_distance(z) | |
| Return the comoving distance | |
| Parameters | |
| ---------- | |
| z : float | |
| Desired redshift | |
| --------------------------------- | |
| Function: scale_independent_growth_factor(self, z) | |
| Docstring: | |
| scale_independent_growth_factor(z) | |
| Return the scale invariant growth factor D(a) for CDM perturbations | |
| (exactly, the quantity defined by Class as index_bg_D in the background module) | |
| Parameters | |
| ---------- | |
| z : float | |
| Desired redshift | |
| --------------------------------- | |
| Function: scale_independent_growth_factor_f(self, z) | |
| Docstring: | |
| scale_independent_growth_factor_f(z) | |
| Return the scale independent growth factor f(z)=d ln D / d ln a for CDM perturbations | |
| (exactly, the quantity defined by Class as index_bg_f in the background module) | |
| Parameters | |
| ---------- | |
| z : float | |
| Desired redshift | |
| --------------------------------- | |
| Function: scale_dependent_growth_factor_f(self, k, z, h_units=False, nonlinear=False, Nz=20) | |
| Docstring: | |
| scale_dependent_growth_factor_f(k,z) | |
| Return the scale dependent growth factor | |
| f(z)= 1/2 * [d ln P(k,a) / d ln a] | |
| = - 0.5 * (1+z) * [d ln P(k,z) / d z] | |
| where P(k,z) is the total matter power spectrum | |
| Parameters | |
| ---------- | |
| z : float | |
| Desired redshift | |
| k : float | |
| Desired wavenumber in 1/Mpc (if h_units=False) or h/Mpc (if h_units=True) | |
| --------------------------------- | |
| Function: scale_dependent_growth_factor_f_cb(self, k, z, h_units=False, nonlinear=False, Nz=20) | |
| Docstring: | |
| scale_dependent_growth_factor_f_cb(k,z) | |
| Return the scale dependent growth factor calculated from CDM+baryon power spectrum P_cb(k,z) | |
| f(z)= 1/2 * [d ln P_cb(k,a) / d ln a] | |
| = - 0.5 * (1+z) * [d ln P_cb(k,z) / d z] | |
| Parameters | |
| ---------- | |
| z : float | |
| Desired redshift | |
| k : float | |
| Desired wavenumber in 1/Mpc (if h_units=False) or h/Mpc (if h_units=True) | |
| --------------------------------- | |
| Function: scale_independent_f_sigma8(self, z) | |
| Docstring: | |
| scale_independent_f_sigma8(z) | |
| Return the scale independent growth factor f(z) multiplied by sigma8(z) | |
| Parameters | |
| ---------- | |
| z : float | |
| Desired redshift | |
| Returns | |
| ------- | |
| f(z)*sigma8(z) (dimensionless) | |
| --------------------------------- | |
| Function: effective_f_sigma8(self, z, z_step=0.1) | |
| Docstring: | |
| effective_f_sigma8(z) | |
| Returns the time derivative of sigma8(z) computed as (d sigma8/d ln a) | |
| Parameters | |
| ---------- | |
| z : float | |
| Desired redshift | |
| z_step : float | |
| Default step used for the numerical two-sided derivative. For z < z_step the step is reduced progressively down to z_step/10 while sticking to a double-sided derivative. For z< z_step/10 a single-sided derivative is used instead. | |
| Returns | |
| ------- | |
| (d ln sigma8/d ln a)(z) (dimensionless) | |
| --------------------------------- | |
| Function: effective_f_sigma8_spline(self, z, Nz=20) | |
| Docstring: | |
| effective_f_sigma8_spline(z) | |
| Returns the time derivative of sigma8(z) computed as (d sigma8/d ln a) | |
| Parameters | |
| ---------- | |
| z : float | |
| Desired redshift | |
| Nz : integer | |
| Number of values used to spline sigma8(z) in the range [z-0.1,z+0.1] | |
| Returns | |
| ------- | |
| (d ln sigma8/d ln a)(z) (dimensionless) | |
| --------------------------------- | |
| Function: z_of_tau(self, tau) | |
| Docstring: | |
| Redshift corresponding to a given conformal time. | |
| Parameters | |
| ---------- | |
| tau : float | |
| Conformal time | |
| --------------------------------- | |
| Function: Hubble(self, z) | |
| Docstring: | |
| Hubble(z) | |
| Return the Hubble rate (exactly, the quantity defined by Class as index_bg_H | |
| in the background module) | |
| Parameters | |
| ---------- | |
| z : float | |
| Desired redshift | |
| --------------------------------- | |
| Function: Om_m(self, z) | |
| Docstring: | |
| Omega_m(z) | |
| Return the matter density fraction (exactly, the quantity defined by Class as index_bg_Omega_m | |
| in the background module) | |
| Parameters | |
| ---------- | |
| z : float | |
| Desired redshift | |
| --------------------------------- | |
| Function: Om_b(self, z) | |
| Docstring: | |
| Omega_b(z) | |
| Return the baryon density fraction (exactly, the ratio of quantities defined by Class as | |
| index_bg_rho_b and index_bg_rho_crit in the background module) | |
| Parameters | |
| ---------- | |
| z : float | |
| Desired redshift | |
| --------------------------------- | |
| Function: Om_cdm(self, z) | |
| Docstring: | |
| Omega_cdm(z) | |
| Return the cdm density fraction (exactly, the ratio of quantities defined by Class as | |
| index_bg_rho_cdm and index_bg_rho_crit in the background module) | |
| Parameters | |
| ---------- | |
| z : float | |
| Desired redshift | |
| --------------------------------- | |
| Function: Om_ncdm(self, z) | |
| Docstring: | |
| Omega_ncdm(z) | |
| Return the ncdm density fraction (exactly, the ratio of quantities defined by Class as | |
| Sum_m [ index_bg_rho_ncdm1 + n ], with n=0...N_ncdm-1, and index_bg_rho_crit in the background module) | |
| Parameters | |
| ---------- | |
| z : float | |
| Desired redshift | |
| --------------------------------- | |
| Function: ionization_fraction(self, z) | |
| Docstring: | |
| ionization_fraction(z) | |
| Return the ionization fraction for a given redshift z | |
| Parameters | |
| ---------- | |
| z : float | |
| Desired redshift | |
| --------------------------------- | |
| Function: baryon_temperature(self, z) | |
| Docstring: | |
| baryon_temperature(z) | |
| Give the baryon temperature for a given redshift z | |
| Parameters | |
| ---------- | |
| z : float | |
| Desired redshift | |
| --------------------------------- | |
| Function: T_cmb(self) | |
| Docstring: | |
| Return the CMB temperature | |
| --------------------------------- | |
| Function: Omega0_m(self) | |
| Docstring: | |
| Return the sum of Omega0 for all non-relativistic components | |
| --------------------------------- | |
| Function: get_background(self) | |
| Docstring: | |
| Return an array of the background quantities at all times. | |
| Parameters | |
| ---------- | |
| Returns | |
| ------- | |
| background : dictionary containing background. | |
| --------------------------------- | |
| Function: get_thermodynamics(self) | |
| Docstring: | |
| Return the thermodynamics quantities. | |
| Returns | |
| ------- | |
| thermodynamics : dictionary containing thermodynamics. | |
| --------------------------------- | |
| Function: get_primordial(self) | |
| Docstring: | |
| Return the primordial scalar and/or tensor spectrum depending on 'modes'. | |
| 'output' must be set to something, e.g. 'tCl'. | |
| Returns | |
| ------- | |
| primordial : dictionary containing k-vector and primordial scalar and tensor P(k). | |
| --------------------------------- | |
| Function: get_perturbations(self, return_copy=True) | |
| Docstring: | |
| Return scalar, vector and/or tensor perturbations as arrays for requested | |
| k-values. | |
| .. note:: | |
| you need to specify both 'k_output_values', and have some | |
| perturbations computed, for instance by setting 'output' to 'tCl'. | |
| Do not enable 'return_copy=False' unless you know exactly what you are doing. | |
| This will mean that you get access to the direct C pointers inside CLASS. | |
| That also means that if class is deallocated, | |
| your perturbations array will become invalid. Beware! | |
| Returns | |
| ------- | |
| perturbations : dict of array of dicts | |
| perturbations['scalar'] is an array of length 'k_output_values' of | |
| dictionary containing scalar perturbations. | |
| Similar for perturbations['vector'] and perturbations['tensor']. | |
| --------------------------------- | |
| Function: get_transfer(self, z=0., output_format='class') | |
| Docstring: | |
| Return the density and/or velocity transfer functions for all initial | |
| conditions today. You must include 'mTk' and/or 'vCTk' in the list of | |
| 'output'. The transfer functions can also be computed at higher redshift z | |
| provided that 'z_pk' has been set and that 0<z<z_pk. | |
| Parameters | |
| ---------- | |
| z : redshift (default = 0) | |
| output_format : ('class' or 'camb') Format transfer functions according to | |
| CLASS convention (default) or CAMB convention. | |
| Returns | |
| ------- | |
| tk : dictionary containing transfer functions. | |
| --------------------------------- | |
| Function: get_current_derived_parameters(self, names) | |
| Docstring: | |
| get_current_derived_parameters(names) | |
| Return a dictionary containing an entry for all the names defined in the | |
| input list. | |
| Parameters | |
| ---------- | |
| names : list | |
| Derived parameters that can be asked from Monte Python, or | |
| elsewhere. | |
| Returns | |
| ------- | |
| derived : dict | |
| .. warning:: | |
| This method used to take as an argument directly the data class from | |
| Monte Python. To maintain compatibility with this old feature, a | |
| check is performed to verify that names is indeed a list. If not, it | |
| returns a TypeError. The old version of this function, when asked | |
| with the new argument, will raise an AttributeError. | |
| --------------------------------- | |
| Function: nonlinear_scale(self, np.ndarray[DTYPE_t,ndim=1] z, int z_size) | |
| Docstring: | |
| nonlinear_scale(z, z_size) | |
| Return the nonlinear scale for all the redshift specified in z, of size | |
| z_size | |
| Parameters | |
| ---------- | |
| z : numpy array | |
| Array of requested redshifts | |
| z_size : int | |
| Size of the redshift array | |
| --------------------------------- | |
| Function: nonlinear_scale_cb(self, np.ndarray[DTYPE_t,ndim=1] z, int z_size) | |
| Docstring: | |
| make nonlinear_scale_cb(z, z_size) | |
| Return the nonlinear scale for all the redshift specified in z, of size | |
| z_size | |
| Parameters | |
| ---------- | |
| z : numpy array | |
| Array of requested redshifts | |
| z_size : int | |
| Size of the redshift array | |
| --------------------------------- | |
| Function: __call__(self, ctx) | |
| Docstring: | |
| Function to interface with CosmoHammer | |
| Parameters | |
| ---------- | |
| ctx : context | |
| Contains several dictionaries storing data and cosmological | |
| information | |
| --------------------------------- | |
| Function: get_pk_array(self, np.ndarray[DTYPE_t,ndim=1] k, np.ndarray[DTYPE_t,ndim=1] z, int k_size, int z_size, nonlinear) | |
| Docstring: | |
| Fast function to get the power spectrum on a k and z array | |
| --------------------------------- | |
| Function: get_pk_cb_array(self, np.ndarray[DTYPE_t,ndim=1] k, np.ndarray[DTYPE_t,ndim=1] z, int k_size, int z_size, nonlinear) | |
| Docstring: | |
| Fast function to get the power spectrum on a k and z array | |
| --------------------------------- | |
| Function: Omega0_k(self) | |
| Docstring: | |
| Curvature contribution | |
| --------------------------------- | |
| Function: get_sources(self) | |
| Docstring: | |
| Return the source functions for all k, tau in the grid. | |
| Returns | |
| ------- | |
| sources : dictionary containing source functions. | |
| k_array : numpy array containing k values. | |
| tau_array: numpy array containing tau values. | |
| --------------------------------- | |