def redshift_temperature(cosmology=None, **atzkw):
"""Convert quantities between redshift and CMB temperature.
Care should be taken to not misinterpret a relativistic, gravitational, etc
redshift as a cosmological one.
Parameters
----------
cosmology : `~astropy.cosmology.Cosmology`, str, or None, optional
A cosmology realization or built-in cosmology's name (e.g. 'Planck18').
If None, will use the default cosmology
(controlled by :class:`~astropy.cosmology.default_cosmology`).
**atzkw
keyword arguments for :func:`~astropy.cosmology.z_at_value`
Returns
-------
`~astropy.units.equivalencies.Equivalency`
Equivalency between redshift and temperature.
"""
from astropy.cosmology import default_cosmology, z_at_value
# get cosmology: None -> default and process str / class
cosmology = cosmology if cosmology is not None else default_cosmology.get()
with default_cosmology.set(cosmology): # if already cosmo, passes through
cosmology = default_cosmology.get()
def z_to_Tcmb(z):
return cosmology.Tcmb(z)
def Tcmb_to_z(T):
return z_at_value(cosmology.Tcmb, T << u.K, **atzkw)
return u.Equivalency([(redshift, u.K, z_to_Tcmb, Tcmb_to_z)],
"redshift_temperature", {'cosmology': cosmology})
def test_pipeline_cosmology():
# Define function for testing pipeline cosmology
from skypy.utils import uses_default_cosmology
@uses_default_cosmology
def return_cosmology(cosmology):
return cosmology
# Initial default_cosmology
initial_default = default_cosmology.get()
# Test pipeline correctly sets default cosmology from parameters
# N.B. astropy cosmology class has not implemented __eq__ for comparison
H0, Om0 = 70, 0.3
config = {'parameters': {'H0': H0, 'Om0': Om0},
'cosmology': (FlatLambdaCDM, ['$H0', '$Om0']),
'test': (return_cosmology, ),
}
pipeline = Pipeline(config)
pipeline.execute()
assert type(pipeline['test']) == FlatLambdaCDM
assert pipeline['test'].H0.value == H0
assert pipeline['test'].Om0 == Om0
# Test pipeline correctly updates cosmology from new parameters
H0_new, Om0_new = 75, 0.25
pipeline.execute({'H0': H0_new, 'Om0': Om0_new})
assert type(pipeline['test']) == FlatLambdaCDM
assert pipeline['test'].H0.value == H0_new
assert pipeline['test'].Om0 == Om0_new
# Check that the astropy default cosmology is unchanged
assert default_cosmology.get() == initial_default
def redshift_distance(cosmology=None, kind="comoving", **atzkw):
"""Convert quantities between redshift and distance.
Care should be taken to not misinterpret a relativistic, gravitational, etc
redshift as a cosmological one.
Parameters
----------
cosmology : `~astropy.cosmology.Cosmology`, str, or None, optional
A cosmology realization or built-in cosmology's name (e.g. 'Planck18').
If None, will use the default cosmology
(controlled by :class:`~astropy.cosmology.default_cosmology`).
kind : {'comoving', 'lookback', 'luminosity'} or None, optional
The distance type for the Equivalency.
Note this does NOT include the angular diameter distance as this
distance measure is not monotonic.
**atzkw
keyword arguments for :func:`~astropy.cosmology.z_at_value`
Returns
-------
`~astropy.units.equivalencies.Equivalency`
Equivalency between redshift and temperature.
Examples
--------
>>> import astropy.units as u
>>> import astropy.cosmology.units as cu
>>> from astropy.cosmology import WMAP9
>>> z = 1100 * cu.redshift
>>> z.to(u.Mpc, cu.redshift_distance(WMAP9, kind="comoving")) # doctest: +FLOAT_CMP
<Quantity 14004.03157418 Mpc>
"""
from astropy.cosmology import default_cosmology, z_at_value
# get cosmology: None -> default and process str / class
cosmology = cosmology if cosmology is not None else default_cosmology.get()
with default_cosmology.set(cosmology): # if already cosmo, passes through
cosmology = default_cosmology.get()
allowed_kinds = ('comoving', 'lookback', 'luminosity')
if kind not in allowed_kinds:
raise ValueError(f"`kind` is not one of {allowed_kinds}")
method = getattr(cosmology, kind + "_distance")
def z_to_distance(z):
"""Redshift to distance."""
return method(z)
def distance_to_z(d):
"""Distance to redshift."""
return z_at_value(method, d << u.Mpc, **atzkw)
return u.Equivalency([(redshift, u.Mpc, z_to_distance, distance_to_z)],
"redshift_distance", {
'cosmology': cosmology,
"distance": kind
})
def test_uses_default_cosmology():
from astropy.cosmology import default_cosmology, WMAP9
from skypy.utils import uses_default_cosmology
@uses_default_cosmology
def function_with_cosmology(cosmology):
return cosmology
assert function_with_cosmology() == default_cosmology.get()
assert WMAP9 != default_cosmology.get()
assert function_with_cosmology(WMAP9) == WMAP9
def test_schechter_lf():
from pytest import raises
from skypy.galaxies import schechter_lf
from astropy import units
# redshift and magnitude distributions are tested separately
# only test that output is consistent here
# parameters for the sampling
z = np.linspace(0., 1., 100)
M_star = -20
phi_star = 1e-3
alpha = -0.5
m_lim = 30.
sky_area = 1.0 * units.deg**2
cosmo = default_cosmology.get()
# sample redshifts and magnitudes
z_gal, M_gal = schechter_lf(z, M_star, phi_star, alpha, m_lim, sky_area, cosmo)
# check length
assert len(z_gal) == len(M_gal)
# turn M_star, phi_star, alpha into arrays
z, M_star, phi_star, alpha = np.broadcast_arrays(z, M_star, phi_star, alpha)
# sample s.t. arrays need to be interpolated
# alpha array not yet supported
with raises(NotImplementedError):
z_gal, M_gal = schechter_lf(z, M_star, phi_star, alpha, m_lim, sky_area, cosmo)
def get_pc_per_arcsec(distance, cosmo=WMAP9):
"""
Args:
distance: float
Distance in Mpc
cosmo: astropy.cosmology
Cosmology. Default is None: will then
use the default_cosmology from astropy
Returns:
pc_per_arcsec: float
Conversion parsec per arcsecond
"""
from astropy.cosmology import default_cosmology
from astropy.coordinates import Distance
from astropy import units as u
# Use default cosmology from astropy
if cosmo is None:
cosmo = default_cosmology.get()
# Use astropy units
dist = Distance(distance, u.Mpc)
# get the corresponding redshift
redshift = dist.compute_z(cosmo)
# And nore the proper conversion
kpc_per_arcmin = cosmo.kpc_proper_per_arcmin(redshift)
return kpc_per_arcmin.to(u.pc / u.arcsec)
def test_temperature(self, cosmo):
"""Test temperature equivalency component."""
default_cosmo = default_cosmology.get()
z = 15 * cu.redshift
Tcmb = cosmo.Tcmb(z)
# 1) Default (without specifying the cosmology)
with default_cosmology.set(cosmo):
equivalency = cu.with_redshift(Tcmb=True)
assert_quantity_allclose(z.to(u.K, equivalency), Tcmb)
assert_quantity_allclose(Tcmb.to(cu.redshift, equivalency), z)
# showing the answer changes if the cosmology changes
# this test uses the default cosmology
equivalency = cu.with_redshift(Tcmb=True)
assert_quantity_allclose(z.to(u.K, equivalency), default_cosmo.Tcmb(z))
assert default_cosmo.Tcmb(z) != Tcmb
# 2) Specifying the cosmology
equivalency = cu.with_redshift(cosmo, Tcmb=True)
assert_quantity_allclose(z.to(u.K, equivalency), Tcmb)
assert_quantity_allclose(Tcmb.to(cu.redshift, equivalency), z)
# Test `atzkw`
# this is really just a test that 'atzkw' doesn't fail
equivalency = cu.with_redshift(cosmo, Tcmb=True, atzkw={"ztol": 1e-10})
assert_quantity_allclose(Tcmb.to(cu.redshift, equivalency), z)
def test_redshift_temperature():
"""Test :func:`astropy.cosmology.units.redshift_temperature`."""
cosmo = Planck13.clone(Tcmb0=3 * u.K)
default_cosmo = default_cosmology.get()
z = 15 * cu.redshift
Tcmb = cosmo.Tcmb(z)
# 1) Default (without specifying the cosmology)
with default_cosmology.set(cosmo):
equivalency = cu.redshift_temperature()
assert_quantity_allclose(z.to(u.K, equivalency), Tcmb)
assert_quantity_allclose(Tcmb.to(cu.redshift, equivalency), z)
# showing the answer changes if the cosmology changes
# this test uses the default cosmology
equivalency = cu.redshift_temperature()
assert_quantity_allclose(z.to(u.K, equivalency), default_cosmo.Tcmb(z))
assert default_cosmo.Tcmb(z) != Tcmb
# 2) Specifying the cosmology
equivalency = cu.redshift_temperature(cosmo)
assert_quantity_allclose(z.to(u.K, equivalency), Tcmb)
assert_quantity_allclose(Tcmb.to(cu.redshift, equivalency), z)
# Test `atzkw`
equivalency = cu.redshift_temperature(cosmo, ztol=1e-10)
assert_quantity_allclose(Tcmb.to(cu.redshift, equivalency), z)
def with_H0(H0=None):
"""
Convert between quantities with little-h and the equivalent physical units.
Parameters
----------
H0 : None or `~astropy.units.Quantity` ['frequency']
The value of the Hubble constant to assume. If a
`~astropy.units.Quantity`, will assume the quantity *is* ``H0``. If
`None` (default), use the ``H0`` attribute from
:mod:`~astropy.cosmology.default_cosmology`.
References
----------
For an illuminating discussion on why you may or may not want to use
little-h at all, see https://arxiv.org/pdf/1308.4150.pdf
"""
if H0 is None:
from .realizations import default_cosmology
H0 = default_cosmology.get().H0
h100_val_unit = u.Unit(100 / (H0.to_value((u.km / u.s) / u.Mpc)) * littleh)
return u.Equivalency([(h100_val_unit, None)], "with_H0", kwargs={"H0": H0})
def __init__(self,
z_lens,
z_source,
kwargs_model,
cosmo_fiducial=None,
lens_model_kinematics_bool=None,
light_model_kinematics_bool=None,
kwargs_seeing={},
kwargs_aperture={},
anisotropy_model=None):
if cosmo_fiducial is None:
cosmo_fiducial = default_cosmology.get()
self._z_lens = z_lens
self._z_source = z_source
self._cosmo_fiducial = cosmo_fiducial
self._lens_cosmo = LensCosmo(z_lens=z_lens,
z_source=z_source,
cosmo=self._cosmo_fiducial)
self.LensModel, self.SourceModel, self.LensLightModel, self.PointSource, extinction_class = class_creator.create_class_instances(
all_models=True, **kwargs_model)
super(TDCosmography, self).__init__(
z_lens=z_lens,
z_source=z_source,
kwargs_model=kwargs_model,
cosmo=cosmo_fiducial,
lens_model_kinematics_bool=lens_model_kinematics_bool,
light_model_kinematics_bool=light_model_kinematics_bool,
kwargs_seeing=kwargs_seeing,
kwargs_aperture=kwargs_aperture,
anisotropy_model=anisotropy_model)
def test_distance(self, kind):
"""Test distance equivalency."""
cosmo = Planck13
z = 15 * cu.redshift
dist = getattr(cosmo, kind + "_distance")(z)
default_cosmo = default_cosmology.get()
assert default_cosmo != cosmo # shows changing default
# 1) without specifying the cosmology
with default_cosmology.set(cosmo):
equivalency = cu.with_redshift(distance=kind)
assert_quantity_allclose(z.to(u.Mpc, equivalency), dist)
# showing the answer changes if the cosmology changes
# this test uses the default cosmology
equivalency = cu.with_redshift(distance=kind)
assert_quantity_allclose(z.to(u.Mpc, equivalency),
getattr(default_cosmo, kind + "_distance")(z))
assert not u.allclose(getattr(default_cosmo, kind + "_distance")(z), dist)
# 2) Specifying the cosmology
equivalency = cu.with_redshift(cosmo, distance=kind)
assert_quantity_allclose(z.to(u.Mpc, equivalency), dist)
assert_quantity_allclose(dist.to(cu.redshift, equivalency), z)
# Test atzkw
# this is really just a test that 'atzkw' doesn't fail
equivalency = cu.with_redshift(cosmo, distance=kind, atzkw={"ztol": 1e-10})
assert_quantity_allclose(dist.to(cu.redshift, equivalency), z)
def __init__(self,
mass=u.Quantity(mass.default, mass.unit),
concentration=concentration.default,
redshift=redshift.default,
massfactor=("critical", 200),
cosmo=None,
**kwargs):
# Set default cosmology
if cosmo is None:
# LOCAL
from astropy.cosmology import default_cosmology
cosmo = default_cosmology.get()
# Set mass overdensity type and factor
self._density_delta(massfactor, cosmo, redshift)
# Establish mass units for density calculation (default solar masses)
if not isinstance(mass, u.Quantity):
in_mass = u.Quantity(mass, u.M_sun)
else:
in_mass = mass
# Obtain scale radius
self._radius_s(mass, concentration)
# Obtain scale density
self._density_s(mass, concentration)
super().__init__(mass=in_mass,
concentration=concentration,
redshift=redshift,
**kwargs)
def with_redshift(cosmology=None, *, Tcmb=True, atzkw=None):
"""Convert quantities between measures of cosmological distance.
Note: by default all equivalencies are on and must be explicitly turned off.
Care should be taken to not misinterpret a relativistic, gravitational, etc
redshift as a cosmological one.
Parameters
----------
cosmology : `~astropy.cosmology.Cosmology`, str, or None, optional
A cosmology realization or built-in cosmology's name (e.g. 'Planck18').
If None, will use the default cosmology
(controlled by :class:`~astropy.cosmology.default_cosmology`).
Tcmb : bool (optional, keyword-only)
Whether to create a CMB temperature <-> redshift equivalency, using
``Cosmology.Tcmb``. Default is False.
atzkw : dict or None (optional, keyword-only)
keyword arguments for :func:`~astropy.cosmology.z_at_value`
Returns
-------
`~astropy.units.equivalencies.Equivalency`
With equivalencies between redshift and temperature.
"""
from astropy.cosmology import default_cosmology, z_at_value
# get cosmology: None -> default and process str / class
cosmology = cosmology if cosmology is not None else default_cosmology.get()
with default_cosmology.set(cosmology): # if already cosmo, passes through
cosmology = default_cosmology.get()
atzkw = atzkw if atzkw is not None else {}
equivs = [] # will append as built
# -----------
# CMB Temperature <-> Redshift
if Tcmb:
equivs.extend(redshift_temperature(cosmology, **atzkw))
# -----------
return u.Equivalency(equivs, "with_redshift", {
'cosmology': cosmology,
'Tcmb': Tcmb
})
def test_distance_default(self):
"""Test distance equivalency default."""
z = 15 * cu.redshift
d = default_cosmology.get().comoving_distance(z)
equivalency = cu.with_redshift()
assert_quantity_allclose(z.to(u.Mpc, equivalency), d)
assert_quantity_allclose(d.to(cu.redshift, equivalency), z)
def test_growth():
"""
Test a FlatLambdaCDM cosmology with omega_matter = 1.0
and astropy default cosmology
"""
redshift = np.linspace(0., 10., 101)
cosmology_flat = FlatLambdaCDM(H0=70.0, Om0=1.0)
fz = growth_factor(redshift, cosmology_flat)
Dz = growth_function(redshift, cosmology_flat)
Dzprime = growth_function_derivative(redshift, cosmology_flat)
# Test growth factor
assert redshift.shape == fz.shape,\
"Length of redshift array and growth rate array do not match"
assert isclose(fz[0], 1.0),\
"Growth factor at redshift 0 is not close to 1.0"
# Test growth function
assert redshift.shape == Dz.shape,\
"Length of redshift array and growth function array do not match"
assert allclose(Dz, 1. / (1. + redshift)),\
"Growth function is not close to the scale factor"
# make sure that growth_function with scalar returns scalar
Dz2 = growth_function(redshift[2], cosmology_flat)
assert np.isscalar(
Dz2), 'growth function with scalar did not produce scalar'
assert Dz2 == Dz[
2], 'growth function with scalar produced inconsistent result'
# Test growth function derivative
assert redshift.shape == Dzprime.shape,\
"Length of redshift array and growth function array do not match"
assert isclose(Dzprime[0], -1.0),\
"Derivative of growth function at redshift 0 is not close to -1.0"
# Test against precomputed values using astropy default cosmology
default = default_cosmology.get()
zvec = np.linspace(0.0, 1.0, 4)
fz_default = growth_factor(zvec, default)
Dz_default = growth_function(zvec, default)
Dzprime_default = growth_function_derivative(zvec, default)
precomputed_fz_default = np.array(
[0.5255848, 0.69412802, 0.80439553, 0.87179376])
precomputed_Dz_default = np.array(
[0.66328939, 0.55638978, 0.4704842, 0.40368459])
precomputed_Dzprime_default = np.array(
[-0.34861482, -0.2896543, -0.22707323, -0.17596485])
assert allclose(fz_default, precomputed_fz_default)
assert allclose(Dz_default, precomputed_Dz_default)
assert allclose(Dzprime_default, precomputed_Dzprime_default)
def __init__(self, cosmo=None):
"""
:param cosmo: astropy.cosmology instance
"""
from astropy.cosmology import default_cosmology
if cosmo is None:
cosmo = default_cosmology.get()
self.cosmo = cosmo
def __init__(self, cosmo=None):
"""
:param cosmo: instance of astropy.cosmology
:return: Background class with instance of astropy.cosmology
"""
from astropy.cosmology import default_cosmology
if cosmo is None:
cosmo = default_cosmology.get()
self.cosmo = cosmo
def __init__(self,
z_lens,
z_source,
kwargs_model,
cosmo_fiducial=None,
lens_model_kinematics_bool=None,
light_model_kinematics_bool=None,
kwargs_seeing={},
kwargs_aperture={},
anisotropy_model=None,
multi_observations=False,
kwargs_lens_eqn_solver={}):
"""
:param z_lens: redshift of deflector
:param z_source: redshift of source
:param kwargs_model: model configurations (according to FittingSequence)
:param cosmo_fiducial: fiducial cosmology used to compute angular diameter distances where required
:param lens_model_kinematics_bool: (optional) bool list, corresponding to lens models being included into the
kinematics modeling
:param light_model_kinematics_bool: (optional) bool list, corresponding to lens light models being included
into the kinematics modeling
:param kwargs_seeing: seeing conditions (see observation class in Galkin)
:param kwargs_aperture: aperture keyword arguments (see aperture class in Galkin)
:param anisotropy_model: string, anisotropy model type
:param multi_observations: bool, if True, interprets kwargs_aperture and kwargs_seeing as lists of multiple
observations
"""
if cosmo_fiducial is None:
cosmo_fiducial = default_cosmology.get()
self._z_lens = z_lens
self._z_source = z_source
self._cosmo_fiducial = cosmo_fiducial
self._lens_cosmo = LensCosmo(z_lens=z_lens,
z_source=z_source,
cosmo=self._cosmo_fiducial)
self.LensModel, self.SourceModel, self.LensLightModel, self.PointSource, extinction_class = class_creator.create_class_instances(
all_models=True,
**kwargs_model,
kwargs_lens_eqn_solver=kwargs_lens_eqn_solver)
super(TDCosmography, self).__init__(
z_lens=z_lens,
z_source=z_source,
kwargs_model=kwargs_model,
cosmo=cosmo_fiducial,
lens_model_kinematics_bool=lens_model_kinematics_bool,
light_model_kinematics_bool=light_model_kinematics_bool,
kwargs_seeing=kwargs_seeing,
kwargs_aperture=kwargs_aperture,
anisotropy_model=anisotropy_model,
multi_observations=multi_observations,
kwargs_lens_eqn_solver=kwargs_lens_eqn_solver)
def __init__(self,
z_source,
lens_model_list,
redshift_list,
cosmo=None,
**lensmodel_kwargs):
"""
:param cosmo: instance of astropy.cosmology
:return: Background class with instance of astropy.cosmology
"""
if cosmo is None:
from astropy.cosmology import default_cosmology
cosmo = default_cosmology.get()
self._cosmo_bkg = Background(cosmo)
self._z_source = z_source
if not len(lens_model_list) == len(redshift_list):
raise ValueError(
"The length of lens_model_list does not correspond to redshift_list"
)
self._lens_model_list = lens_model_list
self._redshift_list = redshift_list
if len(lens_model_list) < 1:
self._sorted_redshift_index = []
else:
self._sorted_redshift_index = self._index_ordering(redshift_list)
self._lens_model = SinglePlane(lens_model_list, **lensmodel_kwargs)
z_before = 0
self._T_ij_list = []
self._T_z_list = []
self._reduced2physical_factor = []
for idex in self._sorted_redshift_index:
z_lens = self._redshift_list[idex]
if z_before == z_lens:
delta_T = 0
else:
delta_T = self._cosmo_bkg.T_xy(z_before, z_lens)
self._T_ij_list.append(delta_T)
T_z = self._cosmo_bkg.T_xy(0, z_lens)
self._T_z_list.append(T_z)
factor = self._cosmo_bkg.D_xy(0, z_source) / self._cosmo_bkg.D_xy(
z_lens, z_source)
self._reduced2physical_factor.append(factor)
z_before = z_lens
delta_T = self._cosmo_bkg.T_xy(z_before, z_source)
self._T_ij_list.append(delta_T)
self._T_z_source = self._cosmo_bkg.T_xy(0, z_source)
sum_partial = np.sum(self._T_ij_list)
if np.abs(sum_partial - self._T_z_source) > 0.1:
print(
"Numerics in multi-plane compromised by too narrow spacing of too many redshift bins"
)
def execute(self, parameters={}):
r'''Run a pipeline.
This function runs a pipeline of functions to generate variables and
the columns of a set of tables. It uses a Directed Acyclic Graph to
determine a non-blocking order of execution that resolves any
dependencies, see [1]_.
Parameters
----------
parameters : dict
Updated parameter values for this execution.
References
----------
.. [1] https://networkx.github.io/documentation/stable/
'''
# update parameter state
self.parameters.update(parameters)
# initialise state object
self.state = copy(self.parameters)
# Initialise cosmology from config parameters or use astropy default
if self.cosmology:
self.state['cosmology'] = self.get_value(self.cosmology)
else:
self.state['cosmology'] = default_cosmology.get()
# Execute pipeline setting state cosmology as the default
with default_cosmology.set(self.state['cosmology']):
# go through the jobs in dependency order
for job in networkx.topological_sort(self.dag):
if job in self.skip_jobs:
continue
elif job in self.config:
settings = self.config.get(job)
self.state[job] = self.get_value(settings)
else:
table, column = job.split('.')
settings = self.table_config[table][column]
names = [n.strip() for n in column.split(',')]
if len(names) > 1:
# Multi-column assignment
t = Table(self.get_value(settings), names=names)
self.state[table].add_columns(t.columns.values())
else:
# Single column assignment
self.state[table][column] = self.get_value(settings)
def test_schechter_lf_magnitude():
from skypy.galaxy.luminosity import schechter_lf_magnitude
from astropy.cosmology import default_cosmology
import pytest
# use default cosmology
cosmo = default_cosmology.get()
# Schechter function parameters for tests
M_star = -20.5
alpha = -1.3
# sample 1000 galaxies at a fixed redshift of 1.0
z = np.repeat(1.0, 1000)
M = schechter_lf_magnitude(z, M_star, alpha, 30., cosmo)
# get the distribution function
log10_x_min = -0.4 * (30. - cosmo.distmod(1.0).value - M_star)
x = np.logspace(log10_x_min, log10_x_min + 3, 1000)
pdf = x**(alpha + 1) * np.exp(-x)
cdf = np.concatenate([[0.],
np.cumsum(
(pdf[1:] + pdf[:-1]) / 2 * np.diff(np.log(x)))])
cdf /= cdf[-1]
# test the samples against the CDF
D, p = kstest(10.**(-0.4 * (M - M_star)), lambda t: np.interp(t, x, cdf))
assert p > 0.01, 'D = {}, p = {}'.format(D, p)
# test for 1000 galaxies with Pareto redshift distribution
z = np.random.pareto(3., size=1000)
# for scalar parameters, sample galaxies with magnitude limit of 30
M = schechter_lf_magnitude(z, M_star, alpha, 30., cosmo)
# check that the output has the correct shape
assert np.shape(M) == (1000, )
# make sure magnitude limit was respected
M_lim = 30. - cosmo.distmod(z).value
assert np.all(M <= M_lim)
# sample with array for alpha
# not implemented at the moment
with pytest.raises(NotImplementedError):
M = schechter_lf_magnitude(z, M_star, np.broadcast_to(alpha, z.shape),
30., cosmo)
# sample with an explicit size
schechter_lf_magnitude(1.0, M_star, alpha, 30., cosmo, size=100)
def test_magnitude_functions():
from astropy.cosmology import default_cosmology
from skypy.galaxy.luminosity import (absolute_to_apparent_magnitude,
apparent_to_absolute_magnitude,
distance_modulus, luminosity_in_band,
luminosity_from_absolute_magnitude,
absolute_magnitude_from_luminosity)
cosmo = default_cosmology.get()
# sample some redshifts
z = np.random.uniform(0, 10, size=1000)
# sample some absolute magnitudes
M = np.random.uniform(15, 25, size=1000)
# sample distance moduli
DM = cosmo.distmod(z).value
# compare with function
np.testing.assert_allclose(distance_modulus(z), DM)
# compute apparent magnitudes
m = absolute_to_apparent_magnitude(M, DM)
# compare with values
np.testing.assert_allclose(m, M + DM)
# go back to absolute magnitudes
M_ = apparent_to_absolute_magnitude(m, DM)
# compare with original values
np.testing.assert_allclose(M_, M)
# convert between absolute luminosity and magnitude
assert np.isclose(luminosity_from_absolute_magnitude(-22), 630957344.5)
assert np.isclose(absolute_magnitude_from_luminosity(630957344.5), -22)
# convert with standard luminosities
for ref, mag in luminosity_in_band.items():
assert np.isclose(luminosity_from_absolute_magnitude(mag, ref), 1.0)
assert np.isclose(absolute_magnitude_from_luminosity(1.0, ref), mag)
# error when unknown reference is used
with pytest.raises(KeyError):
luminosity_from_absolute_magnitude(0., 'unknown')
with pytest.raises(KeyError):
absolute_magnitude_from_luminosity(1., 'unknown')
def test_distance_off(self, cosmo):
"""Test ``with_redshift`` with the distance off."""
default_cosmo = default_cosmology.get()
z = 15 * cu.redshift
# 1) Default (without specifying the cosmology)
with default_cosmology.set(cosmo):
equivalency = cu.with_redshift(distance=None)
with pytest.raises(u.UnitConversionError, match="'redshift' and 'Mpc'"):
z.to(u.Mpc, equivalency)
# 2) Specifying the cosmology
equivalency = cu.with_redshift(cosmo, distance=None)
with pytest.raises(u.UnitConversionError, match="'redshift' and 'Mpc'"):
z.to(u.Mpc, equivalency)
def test_temperature_off(self, cosmo):
"""Test ``with_redshift`` with the temperature off."""
default_cosmo = default_cosmology.get()
z = 15 * cu.redshift
Tcmb = cosmo.Tcmb(z)
# 1) Default (without specifying the cosmology)
with default_cosmology.set(cosmo):
equivalency = cu.with_redshift(Tcmb=False)
with pytest.raises(u.UnitConversionError, match="'redshift' and 'K'"):
z.to(u.K, equivalency)
# 2) Specifying the cosmology
equivalency = cu.with_redshift(cosmo, Tcmb=False)
with pytest.raises(u.UnitConversionError, match="'redshift' and 'K'"):
z.to(u.K, equivalency)
def __init__(self, cosmo=None, interp=False, **kwargs_interp):
"""
:param cosmo: instance of astropy.cosmology
:param interp: boolean, if True, uses interpolated cosmology to evaluate specific redshifts
:param kwargs_interp: keyword arguments of CosmoInterp specifying the interpolation interval and maximum
redshift
:return: Background class with instance of astropy.cosmology
"""
if cosmo is None:
from astropy.cosmology import default_cosmology
cosmo = default_cosmology.get()
if interp:
self.cosmo = CosmoInterp(cosmo, **kwargs_interp)
else:
self.cosmo = cosmo
def test_hubble_off(self, cosmo):
"""Test ``with_redshift`` with Hubble off."""
unit = u.km / u.s / u.Mpc
default_cosmo = default_cosmology.get()
z = 15 * cu.redshift
H = cosmo.H(z)
# 1) Default (without specifying the cosmology)
with default_cosmology.set(cosmo):
equivalency = cu.with_redshift(hubble=False)
with pytest.raises(u.UnitConversionError, match="'redshift' and 'km / "):
z.to(unit, equivalency)
# 2) Specifying the cosmology
equivalency = cu.with_redshift(cosmo, hubble=False)
with pytest.raises(u.UnitConversionError, match="'redshift' and 'km / "):
z.to(unit, equivalency)
def __init__(self, z_source, lens_model_list, redshift_list, cosmo=None):
"""
:param cosmo: instance of astropy.cosmology
:return: Background class with instance of astropy.cosmology
"""
from astropy.cosmology import default_cosmology
if cosmo is None:
cosmo = default_cosmology.get()
self._cosmo_bkg = Background(cosmo)
self._z_source = z_source
if not len(lens_model_list) == len(redshift_list):
raise ValueError("The length of lens_model_list does not correspond to redshift_list")
self._lens_model_list = lens_model_list
self._redshift_list = redshift_list
self._sorted_redshift_index = self._index_ordering(redshift_list)
self._lens_model = SinglePlane(lens_model_list)
def __init__(self, lens_model_list, z_lens=None, z_source=None, lens_redshift_list=None, cosmo=None,
multi_plane=False, numerical_alpha_class=None, observed_convention_index=None, z_source_convention=None):
"""
:param lens_model_list: list of strings with lens model names
:param z_lens: redshift of the deflector (only considered when operating in single plane mode).
Is only needed for specific functions that require a cosmology.
:param z_source: redshift of the source: Needed in multi_plane option only,
not required for the core functionalities in the single plane mode.
:param lens_redshift_list: list of deflector redshift (corresponding to the lens model list),
only applicable in multi_plane mode.
:param cosmo: instance of the astropy cosmology class. If not specified, uses the default cosmology.
:param multi_plane: bool, if True, uses multi-plane mode. Default is False.
:param numerical_alpha_class: an instance of a custom class for use in NumericalAlpha() lens model
(see documentation in Profiles/numerical_alpha)
:param observed_convention_index: a list of lens indexes that correspond to observed positions on the sky, not
physical positions
:param z_source_convention: float, redshift of a source to define the reduced deflection angles of the lens
models. If None, 'z_source' is used.
"""
self.lens_model_list = lens_model_list
self.z_lens = z_lens
if z_source_convention is None:
z_source_convention = z_source
self.z_source = z_source
self._z_source_convention = z_source_convention
self.redshift_list = lens_redshift_list
if cosmo is None:
cosmo = default_cosmology.get()
self.cosmo = cosmo
self.multi_plane = multi_plane
if multi_plane is True:
if z_source is None:
raise ValueError('z_source needs to be set for multi-plane lens modelling.')
self.lens_model = MultiPlane(z_source, lens_model_list, lens_redshift_list, cosmo=cosmo,
numerical_alpha_class=numerical_alpha_class,
observed_convention_index=observed_convention_index,
z_source_convention=z_source_convention)
else:
self.lens_model = SinglePlane(lens_model_list, numerical_alpha_class=numerical_alpha_class)
if z_lens is not None and z_source is not None:
self._lensCosmo = LensCosmo(z_lens, z_source, cosmo=cosmo)
def compute_z(self, cosmology=None, **atzkw):
"""
The redshift for this distance assuming its physical distance is
a luminosity distance.
Parameters
----------
cosmology : `~astropy.cosmology.Cosmology` or None
The cosmology to assume for this calculation, or `None` to use the
current cosmology (see `astropy.cosmology` for details).
**atzkw
keyword arguments for :func:`~astropy.cosmology.z_at_value`
Returns
-------
z : `~astropy.units.Quantity`
The redshift of this distance given the provided ``cosmology``.
Warnings
--------
This method can be slow for large arrays.
The redshift is determined using :func:`astropy.cosmology.z_at_value`,
which handles vector inputs (e.g. an array of distances) by
element-wise calling of :func:`scipy.optimize.minimize_scalar`.
For faster results consider using an interpolation table;
:func:`astropy.cosmology.z_at_value` provides details.
See Also
--------
:func:`astropy.cosmology.z_at_value`
Find the redshift corresponding to a
:meth:`astropy.cosmology.FLRW.luminosity_distance`.
"""
from astropy.cosmology import z_at_value
if cosmology is None:
from astropy.cosmology import default_cosmology
cosmology = default_cosmology.get()
atzkw.setdefault("ztol", 1.e-10)
return z_at_value(cosmology.luminosity_distance, self, **atzkw)
def test_littleh():
"""Test :func:`astropy.cosmology.units.with_H0`."""
H0_70 = 70 * u.km / u.s / u.Mpc
h70dist = 70 * u.Mpc / cu.littleh
assert_quantity_allclose(h70dist.to(u.Mpc, cu.with_H0(H0_70)), 100 * u.Mpc)
# make sure using the default cosmology works
cosmodist = default_cosmology.get().H0.value * u.Mpc / cu.littleh
assert_quantity_allclose(cosmodist.to(u.Mpc, cu.with_H0()), 100 * u.Mpc)
# Now try a luminosity scaling
h1lum = 0.49 * u.Lsun * cu.littleh ** -2
assert_quantity_allclose(h1lum.to(u.Lsun, cu.with_H0(H0_70)), 1 * u.Lsun)
# And the trickiest one: magnitudes. Using H0=10 here for the round numbers
H0_10 = 10 * u.km / u.s / u.Mpc
# assume the "true" magnitude M = 12.
# Then M - 5*log_10(h) = M + 5 = 17
withlittlehmag = 17 * (u.mag - u.MagUnit(cu.littleh ** 2))
assert_quantity_allclose(withlittlehmag.to(u.mag, cu.with_H0(H0_10)), 12 * u.mag)
def thermodynamic_temperature(frequency, T_cmb=None):
r"""Defines the conversion between Jy/sr and "thermodynamic temperature",
:math:`T_{CMB}`, in Kelvins. The thermodynamic temperature is a unit very
commonly used in cosmology. See eqn 8 in [1]
:math:`K_{CMB} \equiv I_\nu / \left(2 k \nu^2 / c^2 f(\nu) \right)`
with :math:`f(\nu) = \frac{ x^2 e^x}{(e^x - 1 )^2}`
where :math:`x = h \nu / k T`
Parameters
----------
frequency : `~astropy.units.Quantity` with spectral units
The observed `spectral` equivalent `~astropy.units.Unit` (e.g.,
frequency or wavelength)
T_cmb : `~astropy.units.Quantity` with temperature units or None
The CMB temperature at z=0. If `None`, the default cosmology will be
used to get this temperature.
Notes
-----
For broad band receivers, this conversion do not hold
as it highly depends on the frequency
References
----------
.. [1] Planck 2013 results. IX. HFI spectral response
https://arxiv.org/abs/1303.5070
Examples
--------
Planck HFI 143 GHz::
>>> from astropy import units as u
>>> from astropy.cosmology import Planck15
>>> freq = 143 * u.GHz
>>> equiv = u.thermodynamic_temperature(freq, Planck15.Tcmb0)
>>> (1. * u.mK).to(u.MJy / u.sr, equivalencies=equiv) # doctest: +FLOAT_CMP
<Quantity 0.37993172 MJy / sr>
"""
nu = frequency.to(si.GHz, spectral())
if T_cmb is None:
from astropy.cosmology import default_cosmology
T_cmb = default_cosmology.get().Tcmb0
def f(nu, T_cmb=T_cmb):
x = _si.h * nu / _si.k_B / T_cmb
return x**2 * np.exp(x) / np.expm1(x)**2
def convert_Jy_to_K(x_jybm):
factor = (f(nu) * 2 * _si.k_B * si.K * nu**2 / _si.c**2).to_value(astrophys.Jy)
return x_jybm / factor
def convert_K_to_Jy(x_K):
factor = (astrophys.Jy / (f(nu) * 2 * _si.k_B * nu**2 / _si.c**2)).to_value(si.K)
return x_K / factor
return Equivalency([(astrophys.Jy/si.sr, si.K, convert_Jy_to_K, convert_K_to_Jy)],
"thermodynamic_temperature", {'frequency': frequency, "T_cmb": T_cmb})
import healpy as hp
import numpy as np
from scipy.stats import norm
from scipy.special import gammaincinv
from scipy.special import gammaincc
import cosmolopy.magnitudes as mag
from astropy.utils.data import download_file
from astropy.cosmology import default_cosmology
cosmo = default_cosmology.get()
from observational_const import *
import sys
#parameters:
credzone = 0.99
nsigmas_in_d = 3
ngalaxtoshow = 200
airmass_thresholdp = 10
completenessp = 0.5
minGalaxies = 60
#schecter funtion parameters:
alpha = -1.07
MB_star = -20.7 ## random slide from https://www.astro.umd.edu/~richard/ASTRO620/LumFunction-pp.pdf but not really...?
def find_galaxy_list(map_path, airmass_threshold = airmass_thresholdp, completeness = completenessp, credzone = 0.99):
#loading the map:
prob, distmu, distsigma, distnorm = hp.read_map(map_path, field=[0, 1, 2, 3], verbose=False)
