Luminosity functions (simqso.lumfun)

Reference/API

simqso.lumfun.interp_dVdzdO(zrange, cosmo)

Interpolate the differential comoving solid volume element \((dV/dz){d\Omega}\) over zrange = \((z_1,z_2)\). Much faster than full calculation without significant loss in accuracy.

Parameters:

zrange : tuple

Redshift range for interpolation.

cosmo : astropy.cosmology.Cosmology

simqso.lumfun.doublePL_Lintegral(x, a, b)

Indefinite integral of a double power law function \(f(x,a,b) = (x^a + x^b)^{-1}\).

simqso.lumfun.integrateDPL(Mrange, logPhiStar, MStar, alpha, beta)

Integrate a double power law luminosity function of the form

\[\Phi(M,z){dM}{dz} = \frac{\Phi^*{dM}{dz}}{10^{0.4(\alpha+1)(M-M^*)} + 10^{0.4(\beta+1)(M-M^*)}}\]

over the range Mrange = \((M_\mathrm{min}, M_\mathrm{max})\).

class simqso.lumfun.QlfEvolParam(par, fixed=False, z0=0.0)

Bases: object

A redshift-evolving parameter in a luminosity function.

Parameters:

par : sequence

initial values

fixed : bool or sequence

False means none, True means all, otherwise same shape as x

z0 : float

evaluate at z-z0; i.e., z0=-1 means (1+z), z0=6 means (z-6.0)

set(val, i=None)

get()

iterfree()

fix(i=None)

free(i=None)

eval_at_z(z, par=None)

class simqso.lumfun.PolyEvolParam(par, fixed=False, z0=0.0)

Bases: simqso.lumfun.QlfEvolParam

A luminosity function parameter that evolves with redshift according to a polynomial function.

eval_at_z(z, par=None)

class simqso.lumfun.LuminosityFunction(cosmo=None)

Bases: object

set_cosmology(cosmo)

getpar()

setpar(par)

eval_par_at_z(z, par=None)

logPhi(M, z, *args)

Phi(M, z, *args)

set_scale(scale)

copy()

set_param_bounds(paramName, paramBounds)

get_param_bounds(paramName)

class simqso.lumfun.DoublePowerLawLF(logPhiStar=None, MStar=None, alpha=None, beta=None, **kwargs)

Bases: simqso.lumfun.LuminosityFunction

logPhi(M, z, par=None)

sample_from_fluxrange(mrange, zrange, kcorr, p=None, **kwargs)

sample_from_Lrange(Mrange, zrange, p=None, **kwargs)

sample_at_flux_intervals(mrange, zbins, Nintervals, nPerBin, kcorr, p=None)

integrate(mrange, zrange, kcorr, p=None)

ionizing_emissivity(z, Mrange, p=None, **kwargs)

class simqso.lumfun.SinglePowerLawLF(logPhiStar=None, alpha=None, **kwargs)

Bases: simqso.lumfun.LuminosityFunction

logPhi(M, z, par=None)

class simqso.lumfun.SchechterLF(logPhiStar=None, MStar=None, alpha=None, **kwargs)

Bases: simqso.lumfun.LuminosityFunction

logPhi(M, z, par=None)

simqso.lumfun.arr_between(a, b)

class simqso.lumfun.QuasarSurvey(m, z, m_lim, skyArea, m2M)

Bases: object

A collection of quasars formed with uniform selection criteria.

Parameters:

m : apparent magnitudes of objects

z : redshifts

m_lim : limiting apparent magnitude of survey

skyArea : area of survey in deg^2

m2M : f(m,z,inverse=False)

function taking apparent mag and redshift as arguments, along with a keyword “inverse”, and returning the conversion from apparent mag to absolute mag, or the reverse if inverse=True. Must include both cosmological and k-corrections, i.e., \(M = m - \mathrm{m2M}(m,z) = m - DM(z) - K(m,z)\) and \(m = M + \mathrm{m2M}(M,z,\mathrm{inverse=True})\) Allows for luminosity-dependent k-corrections.

set_selection_function(selfun)

Nofz(zedges)

take(ii)

static init_lf_table(Mbins, zbins)

getinbounds(Medges, zedges)

calcBinnedLF(Medges, zedges, **kwargs)

Calculate binned luminosity function from the stored survey data.

Parameters:

Medges : array defining bin edges in absolute mag

zedges : array defining bin edges in redshift

class simqso.lumfun.QLFIntegrator(Mrange, zrange, dVdzdO)

Bases: object

class simqso.lumfun.FullQLFIntegrator(Mrange, zrange, dVdzdO, **kwargs)

Bases: simqso.lumfun.QLFIntegrator

class simqso.lumfun.FastQLFIntegrator(Mrange, zrange, dVdzdO, **kwargs)

Bases: simqso.lumfun.QLFIntegrator

class simqso.lumfun.FasterQLFIntegrator(Mrange, zrange, dVdzdO, **kwargs)

Bases: simqso.lumfun.QLFIntegrator

simqso.lumfun.joint_qlf_likelihood_fun(par, surveys, lfintegrator, Phi_Mz, verbose)

class simqso.lumfun.FitMethod

Bases: object

set_bounds(exclude_list=[])

class simqso.lumfun.NelderMeadFit(verbose=False)

Bases: simqso.lumfun.FitMethod

class simqso.lumfun.JointQLFFitter(Mrange, zrange, cosmo, qlfModel, **kwargs)

Bases: object

set_integrate_mode(mode, integrate_kwargs={})

fit(surveys, qlfModel=None, initVals=None)

getModel()

getS(surveys, qlfModel=None, par=None)

varyFitParam(paramName, surveys, ntry=None, logRange=None)

sampleModels(sigParam, surveys, n=100)

simqso.lumfun.deltaPhi(z, cosmo2, cosmo1)

n/V’ = (n/V)*(V/V’)

simqso.lumfun.deltaLogPhi(n/V') = log[(n/V)*(V/V')] = log(n/V) + log(V/V')

simqso.lumfun.deltaM(z, cosmo2, cosmo1)

m = M + DM = M’ + DM’ –> M’ = M + (DM - DM’)