def test_distance_comparison():
"""Ensure comparisons of distances work (#2206, #2250)"""
a = Distance(15 * u.kpc)
b = Distance(15 * u.kpc)
assert a == b
c = Distance(1. * u.Mpc)
assert a < c
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_distmod():
d = Distance(10, u.pc)
assert d.distmod.value == 0
d = Distance(distmod=20)
assert d.distmod.value == 20
assert d.kpc == 100
d = Distance(distmod=-1., unit=u.au)
npt.assert_allclose(d.value, 1301442.9440836983)
with pytest.raises(ValueError):
d = Distance(value=d, distmod=20)
with pytest.raises(ValueError):
d = Distance(z=.23, distmod=20)
# check the Mpc/kpc/pc behavior
assert Distance(distmod=1).unit == u.pc
assert Distance(distmod=11).unit == u.kpc
assert Distance(distmod=26).unit == u.Mpc
assert Distance(distmod=-21).unit == u.AU
# if an array, uses the mean of the log of the distances
assert Distance(distmod=[1, 11, 26]).unit == u.kpc
def correct_rgc(coord,
glx_ctr=ICRS('00h42m44.33s +41d16m07.5s'),
glx_PA=Angle('37d42m54s'),
glx_incl=Angle('77.5d'),
glx_dist=Distance(783, unit=u.kpc)):
"""Computes deprojected galactocentric distance.
Inspired by: http://idl-moustakas.googlecode.com/svn-history/
r560/trunk/impro/hiiregions/im_hiiregion_deproject.pro
Parameters
----------
coord : :class:`astropy.coordinates.ICRS`
Coordinate of points to compute galactocentric distance for.
Can be either a single coordinate, or array of coordinates.
glx_ctr : :class:`astropy.coordinates.ICRS`
Galaxy center.
glx_PA : :class:`astropy.coordinates.Angle`
Position angle of galaxy disk.
glx_incl : :class:`astropy.coordinates.Angle`
Inclination angle of the galaxy disk.
glx_dist : :class:`astropy.coordinates.Distance`
Distance to galaxy.
Returns
-------
obj_dist : class:`astropy.coordinates.Distance`
Galactocentric distance(s) for coordinate point(s).
"""
# distance from coord to glx centre
sky_radius = glx_ctr.separation(coord)
avg_dec = 0.5 * (glx_ctr.dec + coord.dec).radian
x = (glx_ctr.ra - coord.ra) * np.cos(avg_dec)
y = glx_ctr.dec - coord.dec
if x == Angle('0d00m00s'):
x = Angle('0d00m0.0001s')
# azimuthal angle from coord to glx -- not completely happy with this
phi = glx_PA - Angle('90d') \
+ Angle(np.arctan(y.arcsec / x.arcsec), unit=u.rad)
# convert to coordinates in rotated frame, where y-axis is galaxy major
# ax; have to convert to arcmin b/c can't do sqrt(x^2+y^2) when x and y
# are angles
xp = (sky_radius * np.cos(phi.radian)).arcmin
yp = (sky_radius * np.sin(phi.radian)).arcmin
# de-project
ypp = yp / np.cos(glx_incl.radian)
obj_radius = np.sqrt(xp**2 + ypp**2) # in arcmin
obj_dist = Distance(Angle(obj_radius, unit=u.arcmin).radian * glx_dist,
unit=glx_dist.unit)
# Computing PA in disk (unused)
# obj_phi = Angle(np.arctan(ypp / xp), unit=u.rad)
# TODO Zero out very small angles, i.e.
# if np.abs(Angle(xp, unit=u.arcmin)) < Angle(1e-5, unit=u.rad):
# obj_phi = Angle(0.0)
return xp, obj_dist
def test_parallax():
d = Distance(parallax=1 * u.arcsecond)
assert d.pc == 1.
with pytest.raises(ValueError):
d = Distance(15 * u.pc, parallax=20 * u.milliarcsecond)
with pytest.raises(ValueError):
d = Distance(parallax=20 * u.milliarcsecond, distmod=20)
# array
plx = [1, 10, 100.] * u.mas
d = Distance(parallax=plx)
assert quantity_allclose(d.pc, [1000., 100., 10.])
assert quantity_allclose(plx, d.parallax)
# check behavior for negative parallax
with pytest.raises(ValueError):
Distance(parallax=-1 * u.mas)
with pytest.raises(ValueError):
Distance(parallax=[10, 1, -1] * u.mas)
with pytest.warns(AstropyWarning):
Distance(parallax=-1 * u.mas, allow_negative=True)
with pytest.warns(AstropyWarning):
Distance(parallax=[10, 1, -1] * u.mas, allow_negative=True)
# Regression test for #12569; `unit` was ignored if `parallax` was given.
d = Distance(parallax=1 * u.mas, unit=u.kpc)
assert d.value == 1.
assert d.unit is u.kpc
def cross_match_umachine_sdss_meert15_with_meert15(mpc_match_dist_cut=1.7,
umachine_sdss_fname=None,
meert15_dir=None,
verbose=False):
"""
Examples
--------
>>> result = cross_match_umachine_sdss_meert15_with_meert15()
"""
if umachine_sdss_fname is None:
umachine_sdss_dirname = "/Users/aphearin/work/sdss/cross_matched_catalogs"
umachine_sdss_basename = "umachine_sdss_dr10_value_added_bt.hdf5"
umachine_sdss_fname = os.path.join(umachine_sdss_dirname,
umachine_sdss_basename)
umachine_sdss = Table.read(umachine_sdss_fname, path='data')
meert15_sdss = load_meert15(datadir=meert15_dir)
# Cross-match the two catalogs on ra and dec
meert15_sdss_coords = SkyCoord(ra=meert15_sdss['ra'] * u.degree,
dec=meert15_sdss['dec'] * u.degree,
distance=Distance(z=meert15_sdss['z']))
umachine_sdss_coords = SkyCoord(ra=umachine_sdss['ra'] * u.degree,
dec=umachine_sdss['dec'] * u.degree,
distance=Distance(z=umachine_sdss['z']))
idx, d2d, d3d = umachine_sdss_coords.match_to_catalog_3d(
meert15_sdss_coords)
cross_matched_meert15_sdss = meert15_sdss[idx]
good_match_mask = d3d.value <= mpc_match_dist_cut
num_good_matches = len(d3d[good_match_mask])
if verbose:
print(
"Fraction of objects in umachine catalog with a clean match = {0:.2f}"
.format(num_good_matches / float(len(d3d))))
umachine_sdss['has_meert15_match'] = 0
umachine_sdss['has_meert15_match'][good_match_mask] = 1
keys_to_inherit = ('r50_magr_kpc', 'Magr_tot', 'Magr_bulge', 'Magr_disk',
'gr_bulge', 'gr_disk', 'morph_type_T', 'gr_kcorr',
'bulge_to_total_rband', 'logsm_bell03')
for key in keys_to_inherit:
umachine_sdss[key + '_meert15'] = np.nan
umachine_sdss[key + '_meert15'][
good_match_mask] = cross_matched_meert15_sdss[key][good_match_mask]
return umachine_sdss
def test_parallax():
d = Distance(parallax=1 * u.arcsecond)
assert d.pc == 1.
with pytest.raises(ValueError):
d = Distance(15 * u.pc, parallax=20 * u.milliarcsecond)
with pytest.raises(ValueError):
d = Distance(parallax=20 * u.milliarcsecond, distmod=20)
# array
plx = [1, 10, 100.] * u.mas
d = Distance(parallax=plx)
assert quantity_allclose(d.pc, [1000., 100., 10.])
assert quantity_allclose(plx, d.parallax)
# check behavior for negative parallax
with pytest.raises(ValueError):
Distance(parallax=-1 * u.mas)
with pytest.raises(ValueError):
Distance(parallax=[10, 1, -1] * u.mas)
with catch_warnings(AstropyWarning) as w:
Distance(parallax=-1 * u.mas, allow_negative=True)
assert len(w) > 0
with catch_warnings(AstropyWarning) as w:
Distance(parallax=[10, 1, -1] * u.mas, allow_negative=True)
assert len(w) > 0
def r(self):
'''Compute the distance of the rock from the center of the coordinate system'''
if not hasattr(self, '_r'):
if hasattr(self, '_position'):
self.r = Distance(self.position.norm)
else:
rs = np.zeros(len(self))
rs[self.e < 1] = self.a[self.e < 1] * \
(1 - self.e[self.e < 1] * np.cos(self.E[self.e < 1].rad))
rs[self.e >= 1] = self.p[self.e >= 1] / \
(1 + self.e[self.e >= 1] *
np.cos(self.f[self.e >= 1]))
self.r = Distance(rs, u.au)
return self._r
def test_distances_scipy():
"""
The distance-related tests that require scipy due to the cosmology
module needing scipy integration routines
"""
from astropy.cosmology import WMAP5
# try different ways to initialize a Distance
d4 = Distance(z=0.23) # uses default cosmology - as of writing, WMAP7
npt.assert_allclose(d4.z, 0.23, rtol=1e-8)
d5 = Distance(z=0.23, cosmology=WMAP5)
npt.assert_allclose(d5.compute_z(WMAP5), 0.23, rtol=1e-8)
d6 = Distance(z=0.23, cosmology=WMAP5, unit=u.km)
npt.assert_allclose(d6.value, 3.5417046898762366e+22)
with pytest.raises(ValueError):
Distance(cosmology=WMAP5, unit=u.km)
with pytest.raises(ValueError):
Distance()
# vectors! regression test for #11949
d4 = Distance(z=[0.23, 0.45]) # as of writing, Planck18
npt.assert_allclose(d4.z, [0.23, 0.45], rtol=1e-8)
def mk_mock_srch(radecfile, nzdictfile, Nsph, simul_cosmo):
if simul_cosmo == "Planck":
# First make h free
Planck13.__init__(100.0, Planck13.Om0)
cosmo = Planck13
elif simul_cosmo == "WMAP":
WMAP5.__init__(100.0, WMAP5.Om0)
cosmo = WMAP5
comv = cosmo.comoving_distance
radecarr = h5_arr(radecfile, "good_pts")
nzdict = json.load(open(nzdictfile))
Nrands = radecarr.shape[0]
Narrs = Nsph / Nrands
remain = Nsph % Nrands
radecz = np.zeros((Nsph, 3))
for i in range(Narrs):
start = Nrands * i
stop = Nrands * (i + 1)
radecz[start:stop, :2] = radecarr[:, :]
endchunk = Nrands * (Narrs)
radecz[endchunk:, :2] = radecarr[:remain, :]
rad = np.arange(1.0, 67.0, 5.0)
zlo = nzdict["zlo"]
zhi = nzdict["zhi"]
radeczlist = len(rad) * [radecz]
for r_i, r in enumerate(rad):
dis_near = Distance(comv(zlo) + r, u.Mpc)
dis_far = Distance(comv(zhi) - r, u.Mpc)
z_a = dis_near.compute_z(cosmology=cosmo)
z_b = dis_far.compute_z(cosmology=cosmo)
randz = (z_a ** 3 + \
(z_b ** 3 - z_a ** 3) * np.random.rand(Nsph)) ** (1. / 3.)
radeczlist[r_i][:, 2] = randz[:]
arr2h5(radeczlist[r_i], "{0}/{1}/mocks/mock_srch_pts.hdf5".format(os.path.dirname(radecfile), simul_cosmo), "radecz_{0}".format(str(r_i * 5 + 1)))
def test_negative_distance():
""" Test optional kwarg allow_negative """
with pytest.raises(ValueError):
Distance([-2, 3.1], u.kpc)
with pytest.raises(ValueError):
Distance([-2, -3.1], u.kpc)
with pytest.raises(ValueError):
Distance(-2, u.kpc)
d = Distance(-2, u.kpc, allow_negative=True)
assert d.value == -2
def geocent(geolong, geolat, height) :
# computes the geocentric coordinates from the geodetic
# (standard map-type) longitude, latitude, and height.
# Notation generally follows 1992 Astr Almanac, p. K11 */
# NOTE that if you replace "geolong" with the local sidereal
# time, this automatically gives you XYZ in the equatorial frame
# of date.
# In this version, geolong and geolat are assumed to be
# Angles and height is assumed to be in meters; returns
# a triplet of explicit Distances.
denom = (1. - thorconsts.FLATTEN) * np.sin(geolat)
denom = np.cos(geolat) * np.cos(geolat) + denom*denom;
C_geo = 1. / np.sqrt(denom);
S_geo = (1. - thorconsts.FLATTEN) * (1. - thorconsts.FLATTEN) * C_geo;
C_geo = C_geo + height / thorconsts.EQUAT_RAD;
# deviation from almanac notation -- include height here.
S_geo = S_geo + height / thorconsts.EQUAT_RAD;
distancemultiplier = Distance(thorconsts.EQUAT_RAD, unit = u.m)
x_geo = thorconsts.EQUAT_RAD * C_geo * np.cos(geolat) * np.cos(geolong)
y_geo = thorconsts.EQUAT_RAD * C_geo * np.cos(geolat) * np.sin(geolong)
z_geo = thorconsts.EQUAT_RAD * S_geo * np.sin(geolat)
return x_geo,y_geo,z_geo
def estimate_mag(self):
'''
Estimate the apparent magnitude of a TNO
https://iopscience.iop.org/article/10.3847/1538-3881/ab18a9/pdf for light curves
'''
e = earth.at(self.epoch)
s = sun.at(self.epoch)
x_helio = self.x + e.x - s.x
y_helio = self.y + e.y - s.y
z_helio = self.z + e.z - s.z
r_helio = Distance(
sqrt(x_helio * x_helio + y_helio * y_helio +
z_helio * z_helio).value, u.au)
earth_dist = ((e.x - s.x)**2 + (e.y - s.y)**2 + (e.z - s.z)**2)**0.5
q = (r_helio.au**2 + self.delta.au**2 - earth_dist.value) / \
(2 * r_helio.au * self.delta.au)
# pyephem
beta = arccos(q)
beta[where(q <= -1)[0]] = pi * u.rad
beta[where(q >= 1)[0]] = 0 * u.rad
Psi_1 = exp(-3.332 * tan(beta / 2)**0.631)
Psi_2 = exp(-1.862 * tan(beta / 2)**1.218)
mag = self.H + 5 * log10(r_helio.au * self.delta.au)
not_zero = where((Psi_1 != 0) | (Psi_2 != 0))[0]
mag[not_zero] -= 2.5 * log10((1 - self.G[not_zero]) * Psi_1[not_zero] +
self.G[not_zero] * Psi_2[not_zero])
return mag
def radecz_skymap(npoints=1, skymap={}):
"""
"""
if not HEALPY_IMPORTED:
raise ImportError(
"healpy could not be imported. Please make sure it is installed.")
prob = skymap["prob"]
prob[~np.isfinite(skymap["distmu"])] = 0.
prob[skymap["distmu"] < 0.] = 0.
npix = len(prob)
nside = hp.npix2nside(npix)
prob = prob / np.sum(prob)
distn = scipy.stats.rv_discrete(values=(np.arange(npix), prob))
ipix = distn.rvs(size=npoints)
ra, dec = hp.pix2ang(nside, ipix, lonlat=True)
zs = []
for ii in ipix:
dist = -1
while (dist < 0):
dist = norm(skymap["distmu"][ii], skymap["distsigma"][ii]).rvs()
zs.append(Distance(dist * u.Mpc).z)
zs = np.array(zs)
return ra, dec, zs
def load_select_effect(sel_func_name,sel_priors,num_sel):
if sel_func_name == False or sel_func_name == 'False': sel_func = lambda *x : 1.
else: sel_func = get_select_func(sel_func_name)
m1lb,m1ub,m2lb,m2ub,dllb,dlub = [float(val) for val in (sel_priors).split(',')]
m1_u = np.random.uniform(m1lb,m1ub,num_sel)
m2_u = np.random.uniform(m2lb,m2ub,num_sel)
dl_select = np.random.uniform(dllb,dlub,num_sel)
z_select = [Distance(dL,unit=u.Mpc).compute_z(cosmology=cosmo) for dL in dl_select]
m1_select = []
m2_select = []
for m1u,m2u in zip(m1_u,m2_u):
while m1u < m2u:
m1u = np.random.uniform(m1lb,m1ub,1)[0]
m2u = np.random.uniform(m2lb,m2ub,1)[0]
m1_select += [m1u]
m2_select += [m2u]
sel_samps = [np.array(m1_select), np.array(m2_select), np.array(dl_select), np.array(z_select)] # uniform m1,m2,dl samples subject to m1 > m2
return sel_func, sel_samps
def coordinate_propagator(ra, dec, parallax, pmra, pmdec, ref_epoch,
target_epoch, tic_id):
'''Authors:
Patrick Tamburo, Boston University, July 2020
Purpose:
Given a target's position, parallax, proper motion, and reference epoch, propagate space motion to target epoch.
See https://docs.astropy.org/en/stable/coordinates/apply_space_motion.html for more examples.
Inputs:
ra (float): The target's DECIMAL RA at your reference epoch
dec (float): The target's DECIMAL Dec at your reference epoch
parallax (float): The target's parallax in milliarcsec
pmra (flaot): The target's RA proper motion in milliarcsec/year
pmdec (float): The target's Dec proper motion in millarcsec/year
ref_epoch (float): Decimal year representing the epoch when coordinates, parallax, and proper motions were measured (e.g., 2015.5 for Gaia measurements)
target_epoch (str): A string representing the epoch you want to propagate motion to (e.g., '2019-09-25')
tic_id (str): The target's TIC ID (e.g., 'TIC 326109505')
Outputs:
new_ra, new_dec (float): The propagated position of the target at target_epoch.
TODO:
'''
c = SkyCoord(ra=ra * u.deg,
dec=dec * u.deg,
distance=Distance(parallax=parallax * u.mas),
pm_ra_cosdec=pmra * u.mas / u.yr,
pm_dec=pmdec * u.mas / u.yr,
obstime=Time(ref_epoch, format='decimalyear'))
target_obstime = Time(target_epoch)
c_target_epoch = c.apply_space_motion(
target_obstime) #Apply space motion to TESS epoch
new_ra = c_target_epoch.ra.value
new_dec = c_target_epoch.dec.value
return new_ra, new_dec
def mk_coords(radecfile, outfile, cosmology):
# Set the cosmology with h free
if cosmology == "Planck":
Planck13.__init__(100.0, Planck13.Om0)
cosmo = Planck13
elif cosmology == "WMAP":
WMAP5.__init__(100.0, WMAP5.Om0)
cosmo = WMAP5
f_in = h5.File(radecfile)
radecz = f_in["radecz"]
f_out = h5.File(outfile)
cart = f_out.create_dataset("cart_pts",
shape=(radecz.shape[0], 3),
dtype='float64')
for i in range(radecz.shape[0]):
ra = Angle(radecz[i, 0], u.deg)
dec = Angle(radecz[i, 1], u.deg)
losd = cosmo.comoving_distance(radecz[i, 2])
dis = Distance(losd)
coord = ICRSCoordinates(ra, dec, distance=dis)
cart[i, :] = np.array([coord.x, coord.y, coord.z])
f_in.close()
f_out.close()
def luminosity(self):
'''Takes the SED that was fit to the data and calcualtes the luminosity of the galaxy'''
T_mcmc,beta_mcmc,log_A_mcmc = self.param_vals()
int_wvs = np.arange(15,1000,0.001) * 1e-6
int_nus = list(_c/int_wvs)
int_nus.reverse()
int_nus_1 = np.array(int_nus)
int_fluxes = list(bb(int_wvs,T_mcmc[0],beta_mcmc[0],10**(log_A_mcmc[0])))
int_fluxes.reverse()
int_fluxes_1 = np.array(int_fluxes)
integrated_flux = simps(int_fluxes_1,int_nus_1) * 1e-26
print integrated_flux, 'integrated flux'
dl = Distance(z = self.z).value * 3.086 * 1e22
L = 4*np.pi*(dl**2)*integrated_flux
L_sun = constants.L_sun.value
L_L_sun = L/L_sun
Ls = {}
Ls['L_IR'] = L
Ls['L_IR/L_sun'] = L_L_sun
return Ls
def test_distance_change():
ra = Longitude("4:08:15.162342", unit=u.hour)
dec = Latitude("-41:08:15.162342", unit=u.degree)
c1 = ICRS(ra, dec, Distance(1, unit=u.kpc))
oldx = c1.cartesian.x.value
assert (oldx - 0.35284083171901953) < 1e-10
# first make sure distances are immutible
with pytest.raises(AttributeError):
c1.distance = Distance(2, unit=u.kpc)
# now x should increase with a bigger distance increases
c2 = ICRS(ra, dec, Distance(2, unit=u.kpc))
assert c2.cartesian.x.value == oldx * 2
def cut_Teff_Mann_on_Mks(df):
'''
Apply the Mks cuts that are given in Mann+2015.
'''
# Find distances:
dft = df.loc[:,df.columns.str.contains("Gaia")].rename(columns = lambda x : str(x)[:-5])
dft = calculate_distance_from_parallax(dft, check_GoF=False)
#Convert to distance modulus:
dft["distmod"] = Distance(np.abs(dft.distance.values), u.pc).distmod
#Calculate Mks
dft["Mks"] = df.K_2MASS - dft.distmod
# Do the cuts:
teffmann = df.loc[:,df.columns.str.startswith('Teff_Mann')].columns.values
e_teffmann = df.loc[:,df.columns.str.startswith('e_Teff_Mann')].columns.values
for col, e_col in zip(teffmann, e_teffmann):
#print("misfits mks: ",
# df.loc[(dft["Mks"] > 9.8), col].shape[0],
# df.loc[(dft["Mks"] < 4.6),col].shape[0],
# df.loc[dft.Mks.isnull(), col].shape[0])
df.loc[((dft["Mks"] > 9.8) | (dft["Mks"] < 4.6) | dft.Mks.isnull()), [col, e_col]] = np.nan
#
return df
def plot_isoc_grid_ages(self, ax, band1, band2, show_cb=False, cb_ax=None):
isoc_set = get_demo_age_grid(
**dict(isoc_kind='parsec_CAF09_v1.2S', photsys_version='yang'))
cmap = cubehelix.cmap(startHue=240,
endHue=-300,
minSat=1,
maxSat=2.5,
minLight=.3,
maxLight=.8,
gamma=.9)
norm = mpl.colors.Normalize(vmin=7., vmax=10.1)
scalar_map = mpl.cm.ScalarMappable(norm=norm, cmap=cmap)
scalar_map.set_array(np.array([isoc.age for isoc in isoc_set]))
d = Distance(785 * u.kpc)
for isoc in isoc_set:
ax.plot(isoc[band1] - isoc[band2],
isoc[band2] + d.distmod.value,
c=scalar_map.to_rgba(np.log10(isoc.age)),
lw=0.8)
if show_cb:
cb = plt.colorbar(mappable=scalar_map,
cax=cb_ax,
ax=ax,
ticks=np.arange(6., 10.2))
cb.set_label(r"log(age)")
def __calc_H_from_mag(self, obscode):
obs = self.observe(obscode=obscode)
e = earth.at(self.epoch)
s = sun.at(self.epoch)
x_helio = self.x - s.x
y_helio = self.y - s.y
z_helio = self.z - s.z
r_helio = Distance(
np.sqrt(x_helio * x_helio + y_helio * y_helio +
z_helio * z_helio).value, u.au)
earth_dist = ((e.x - s.x)**2 + (e.y - s.y)**2 + (e.z - s.z)**2)**0.5
q = (r_helio.au**2 + obs.delta.au**2 -
earth_dist.value**2) / (2 * r_helio.au * obs.delta.au)
beta = np.arccos(q)
beta[np.where(q <= -1)[0]] = np.pi * u.rad
beta[np.where(q >= 1)[0]] = 0 * u.rad
Psi_1 = np.exp(-3.332 * np.tan(beta / 2)**0.631)
Psi_2 = np.exp(-1.862 * np.tan(beta / 2)**1.218)
H = self.mag - 5 * np.log10(r_helio.au * obs.delta.au)
not_zero = np.where((Psi_1 != 0) | (Psi_2 != 0))[0]
H[not_zero] += 2.5 * np.log10(
(1 - self.G[not_zero]) * Psi_1[not_zero] +
self.G[not_zero] * Psi_2[not_zero])
return H
def makeCoordsCol(TableName):
global coordsCol
coordsCol = SkyCoord(TableName['RA'],
TableName['DEC'],
unit=(u.degree, u.degree),
distance=Distance(TableName['DISTANCE'], u.pc),
frame='icrs')
def dust_mass_A(self):
T_mcmc, log_A_mcmc = self.param_vals()
k = 0.192
dl = Distance(z=self.z).value * 3.086 * 1e22
M_sun = constants.M_sun.value
md = (10**log_A_mcmc[0]) * (dl**2) * (1 / k) * 2.3 * 1e-11
mass = md / M_sun
# Get error on dust mass
log_A_error = (log_A_mcmc[1] + log_A_mcmc[2]) / 2
las_rand = np.random.normal(log_A_mcmc[0], log_A_error, 1000)
md_rands = [(10**la) * (dl**2) * (1 / k) * 2.3 * 1e-11
for la in las_rand]
m_e = np.std([m / M_sun for m in md_rands])
Ms = {}
Ms['M_dust/M_sun'] = mass
Ms['M_error'] = m_e
return Ms
def distance_to_theta(redshift, radius):
R = Distance(z=redshift).to(u.kpc)
try:
radius = radius.to(u.kpc)
except AttributeError:
radius = radius * u.kpc
return 2 * np.arcsin(radius / (2 * R)) # RADIUS MUST HAVE ASTROPY UNITS
def make_single_skycoord(stars, index):
"""create a SkyCoord object containing all of the Proper Motion parameters
initialized from the input DataFrame (normal Gaia query result).
Parameters:
stars: normal Gaia DataFrame object
index: the numeric index into the array that you want to retrieve and use
Returns: a single SkyCoord object, representing the star of interest with
Proper Motion params initialized.
"""
pos = stars.iloc[index]
ra = pos['ra'] * u.deg
dec = pos['dec'] * u.deg
pmra = pos['pmra'] * u.mas / u.yr
pmdec = pos['pmdec'] * u.mas / u.yr
distance = Distance(pos['parallax'] * u.mas, allow_negative=True)
sc = SkyCoord(ra,
dec,
pm_ra_cosdec=pmra,
pm_dec=pmdec,
distance=distance,
frame='icrs')
return sc
def sed_flux(self, nu, z, mu_s):
"""Black Body SED generated by the SS Disk:
.. math::
\\nu F_{\\nu} \, [\mathrm{erg}\,\mathrm{cm}^{-2}\,\mathrm{s}^{-1}]
----------
nu : :class:`~astropy.units.Quantity`
array of frequencies, in Hz, to compute the sed, **note** these are
observed frequencies (observer frame).
z : float
redshift of the galaxy, to correct the observed frequencies and to
compute the flux once the distance is obtained
mu_s : float
cosine of the angle between the disk axis and the line of sight,
same as the jet viewing angle
"""
nu = nu.to("Hz").value * (1 + z)
d_L = Distance(z=z).to("cm").value
prefactor = 2 * np.pi * mu_s / np.power(d_L, 2)
R = np.logspace(np.log10(self._R_in), np.log10(self._R_out)) * u.cm
T = self.T(R)
_R = R.value.reshape(R.size, 1)
_T = T.value.reshape(T.size, 1)
_nu = nu.reshape(1, nu.size)
_integrand = _R * I_nu_bb(_nu, _T)
return prefactor * nu * np.trapz(_integrand, R,
axis=0) * u.Unit(SED_UNIT)
def dmod(redshift, distance=None):
if distance is not None:
dist = distance.to(parsec).value / 10.
else:
dist = Distance(z=redshift).parsec / 10.
dm = 5 * np.log10(dist - 5)
return dm
def load_dsph_property(self,
dsph_name,
ra=None,
dec=None,
distance=None,
distance_err=None,
verbose=True):
dsph_prop = ascii.read(__filedir__ +
"NearbyGalaxies.dat").to_pandas().set_index(
"GalaxyName").loc[dsph_name]
self.dsph_prop = dsph_prop
_ra = "{}h{}m{}s".format(dsph_prop.RAh, dsph_prop.RAm,
dsph_prop.RAs) if (ra is None) else ra
_dec = "{}d{}m{}s".format(dsph_prop.DEd, dsph_prop.DEm,
dsph_prop.DEs) if (dec is None) else dec
_distance = Distance(
distmod=dsph_prop["(m-M)o"]).pc if (distance is None) else distance
self.dsph_prop_sc = SkyCoord(ra=_ra,
dec=_dec,
distance=_distance * u.pc)
if verbose:
print(self.dsph_prop_sc)
if not distance_err is None:
self.dsph_prop_sc.distance_err = distance_err
print("distance_err = {}".format(distance_err))
def mk_mock_coords(radeczfile, outfile, simul_cosmo):
if simul_cosmo == "Planck":
Planck13.__init__(100.0, Planck13.Om0)
cosmo = Planck13
elif simul_cosmo == "WMAP":
WMAP5.__init__(100.0, WMAP5.Om0)
cosmo = WMAP5
rad = np.arange(1.0, 67.0, 5.0)
radecz = h5_arr(radeczfile, "radecz")
cart = np.zeros(radecz.shape)
for i, rdz in enumerate(radecz):
ra = Angle(rdz[0], u.deg)
dec = Angle(rdz[1], u.deg)
losd = cosmo.comoving_distance(rdz[2])
dis = Distance(losd)
coord = ICRSCoordinates(ra, dec, distance=dis)
cart[i, :] = np.array([coord.x.value, coord.y.value, coord.z.value])
np.savetxt(outfile, cart)
def test_regression_10094():
"""
Make sure that when we include the proper motion and radial velocity of
a SkyCoord, our velocity corrections remain close to TEMPO2.
We check that tau Ceti is within 5mm/s
"""
# Wright & Eastman (2014) Table2
# Corrections for tau Ceti
wright_table = Table.read(
download_file(
'http://data.astropy.org/coordinates/wright_eastmann_2014_tau_ceti.fits'
))
reduced_jds = wright_table['JD-2400000']
tempo2 = wright_table['TEMPO2']
barycorr = wright_table['BARYCORR']
# tau Ceti Hipparchos data
tauCet = SkyCoord('01 44 05.1275 -15 56 22.4006',
unit=(u.hour, u.deg),
pm_ra_cosdec=-1721.05 * u.mas / u.yr,
pm_dec=854.16 * u.mas / u.yr,
distance=Distance(parallax=273.96 * u.mas),
radial_velocity=-16.597 * u.km / u.s,
obstime=Time(48348.5625, format='mjd'))
# CTIO location as used in Wright & Eastmann
xyz = u.Quantity([1814985.3, -5213916.8, -3187738.1], u.m)
obs = EarthLocation(*xyz)
times = Time(2400000, reduced_jds, format='jd')
tempo2 = tempo2 * speed_of_light
barycorr = barycorr * speed_of_light
astropy = tauCet.radial_velocity_correction(location=obs, obstime=times)
assert_quantity_allclose(astropy, tempo2, atol=5 * u.mm / u.s)
assert_quantity_allclose(astropy, barycorr, atol=5 * u.mm / u.s)
def vpf(dat_dir, Nsph, simul_cosmo, rad):
# Grab the data coordinates
gals = h5_arr("./dat/out/{0}/{1}/gals_cart_coords.hdf5".
format(dat_dir, simul_cosmo), "cart_pts")
# Get details about the redshift interval being considered
nbar_dict = json.load(open("./dat/out/{0}/{1}/nbar_zrange.json".
format(dat_dir, simul_cosmo)))
zlo = nbar_dict["zlo"]
zhi = nbar_dict["zhi"]
# Get the search points
good_pts = h5_arr("./dat/out/{0}/srch_radec.hdf5".format(dat_dir), "good_pts")
bad_pts = h5_arr("./dat/out/{0}/veto.hdf5".format(dat_dir),
"bad_pts")
# Set angular radius of effective area around bad points
bad_r = np.arccos(1.0 - (np.pi * 9.8544099e-05) / (2 * 180 ** 2))
bad_r_deg = np.rad2deg(bad_r)
# Set the cosmology with h free
# Here the cosmology is based on WMAP (for first MultiDark simulation)
if simul_cosmo == "Planck":
# First make h free
Planck13.__init__(100.0, Planck13.Om0)
cosmo = Planck13
elif simul_cosmo == "WMAP":
WMAP5.__init__(100.0, WMAP5.Om0)
cosmo = WMAP5
comv = cosmo.comoving_distance
# Build the trees
# galaxy tree
gal_baum = cKDTree(gals)
# tree of bad points (angular coordinates on unit sphere)
bad_xyz = radec2xyz(bad_pts)
veto_baum = cKDTree(bad_xyz)
# Initialise final output arrays
# rad = np.arange(1.0, 67.0, 5.0) doing it one radius at a time
# P_0 = np.zeros(rad.shape)
# No. of spheres and norm
# Nsph_arr = Nsph * np.array(4 * [0.01] + 4 * [0.1] + 4 * [1.0])
# norm = 1. / Nsph_arr
# norm = 1. / Nsph
rand_i = 0
for r_i, r in enumerate(rad):
# start the count of successful voids
count = 0
# Custom zrange for sphere size
dis_near = Distance(comv(zlo).value + r, u.Mpc)
dis_far = Distance(comv(zhi).value - r, u.Mpc)
z_a = dis_near.compute_z(cosmology=cosmo)
z_b = dis_far.compute_z(cosmology=cosmo)
for i in range(Nsph): # _arr[r_i]):
# compensate for finite length of mask file
rand_i = rand_i % 999999
radec = good_pts[rand_i, :]
rang = Angle(radec[0], u.deg)
decang = Angle(radec[1], u.deg)
randz = (z_a ** 3 + \
(z_b ** 3 - z_a ** 3) * np.random.rand(1)[0]) ** (1. / 3.)
dis = Distance(comv(randz), u.Mpc)
coord = ICRSCoordinates(rang, decang, distance=dis)
sph_cen = np.array([coord.x.value, coord.y.value, coord.z.value])
nn = gal_baum.query(sph_cen)
print "rad: ", r, ", sphere: ", i
if not nn[0] < r:
# add instance to probability count
count += 1
# record quality of sphere using spline values for intersection
# with bad points
# Get radius of circular projection of sphere
R = np.arcsin(r / np.sqrt(np.sum(sph_cen[:] ** 2)))
# Get coordinates of circle centre on unit sphere
crc_cen = radec2xyz(radec)[0]
# Compute tree search radius from Cosine rule
# (include points extending beyond sphere edge to account for
# finite area around bad points)
l_srch = np.sqrt(2. - 2. * np.cos(R))
# Run search
pierce_l = veto_baum.query_ball_point(crc_cen, l_srch)
bad_vol = 0.
R = np.degrees(R) # need in degrees for bad_vol computation
for pt in pierce_l:
pt_ang = bad_pts[pt]
dis = np.degrees(central_angle(pt_ang, radec))
l = dis / R
bad_vol += 1.5 * (bad_r_deg / R) ** 2 \
* np.sqrt(1.0 - l ** 2)
f_r = open("./dat/out/{0}/{1}/vpf_out/volfrac_{2}.dat".
format(dat_dir, simul_cosmo, r),
'a')
f_r.write("{0}\n".format(bad_vol))
f_r.close()
rand_i += 1
def dist_to_z(D):
return Distance.compute_z(D,cosmo)