def Counts(gal_id,
gal_field,
z,
R=10**np.linspace(1.2, 3.6, 13),
delta_z=0.1,
min_mass=9.415):
from astropy.coordinates.sky_coordinate import SkyCoord
from astropy import units as u
#making a list of galaxies in within a redshift range of given z, in the selected field, and above the mass limit#
lst_gal = []
data_tmp = data_flagged[data_flagged['field'] == gal_field]
#separatign the satellite galaxies into four bins based on mass#
mask = ((np.abs(data_tmp['z_peak'] - z) <= delta_z) &
(data_tmp['id'] != gal_id) & (data_tmp['lmass'] >= min_mass))
lst_gal = data_tmp[mask]
lst_gal1 = lst_gal[(lst_gal['lmass'] < 9.8)]
lst_gal2 = lst_gal[((lst_gal['lmass'] < 10.3) & (lst_gal['lmass'] > 9.8))]
lst_gal3 = lst_gal[((lst_gal['lmass'] < 10.8) & (lst_gal['lmass'] > 10.3))]
lst_gal4 = lst_gal[((lst_gal['lmass'] < 11.8) & (lst_gal['lmass'] > 10.8))]
#finding the various aperture radii in arcminutes based on given z#
kpc_per_arcmin = cosmo.kpc_proper_per_arcmin(z)
arcmin_per_kpc = kpc_per_arcmin**(-1)
arcmin = arcmin_per_kpc * (R * u.kpc)
#retrieving RA and DEC data of given galaxy#
p1 = data_tmp[(data_tmp['id'] == gal_id)]
#calculating distance in special ANGLE measure to each galaxy in lst_gal#
sc0 = SkyCoord(p1['ra'] * u.deg, p1['dec'] * u.deg)
sc1 = SkyCoord(lst_gal1['ra'] * u.deg, lst_gal1['dec'] * u.deg)
sc2 = SkyCoord(lst_gal2['ra'] * u.deg, lst_gal2['dec'] * u.deg)
sc3 = SkyCoord(lst_gal3['ra'] * u.deg, lst_gal3['dec'] * u.deg)
sc4 = SkyCoord(lst_gal4['ra'] * u.deg, lst_gal4['dec'] * u.deg)
sep1 = sc0.separation(sc1).to(u.arcmin)
sep2 = sc0.separation(sc2).to(u.arcmin)
sep3 = sc0.separation(sc3).to(u.arcmin)
sep4 = sc0.separation(sc4).to(u.arcmin)
#finding number of "sep's" within the list 'arcmin' already created#
nn1 = np.empty(len(R))
nn2 = np.empty(len(R))
nn3 = np.empty(len(R))
nn4 = np.empty(len(R))
for ii, r in enumerate(arcmin):
nn1[ii] = np.sum(sep1 <= r)
nn2[ii] = np.sum(sep2 <= r)
nn3[ii] = np.sum(sep3 <= r)
nn4[ii] = np.sum(sep4 <= r)
#returning four lists of counts pre radius with lower end number for lower mass bin#
return [nn1, nn2, nn3, nn4]
def Counts(gal_id, gal_field, z, R = 10**np.linspace(1.2,3.6,13), delta_z = 0.1, min_mass = 9.415):
from astropy.coordinates.sky_coordinate import SkyCoord
from astropy import units as u
#making a list of galaxies in within a redshift range of given z, in the selected field, and above the mass limit#
lst_gal = []
data_tmp = data_flagged[data_flagged['field'] == gal_field]
#separatign the satellite galaxies into four bins based on mass#
mask = ((np.abs(data_tmp['z_peak'] - z) <= delta_z) & (data_tmp['id'] != gal_id) & (data_tmp['lmass'] >= min_mass))
lst_gal = data_tmp[mask]
lst_gal1 = lst_gal[(lst_gal['lmass'] < 9.8)]
lst_gal2 = lst_gal[((lst_gal['lmass'] < 10.3) & (lst_gal['lmass'] > 9.8))]
lst_gal3 = lst_gal[((lst_gal['lmass'] < 10.8) & (lst_gal['lmass'] > 10.3))]
lst_gal4 = lst_gal[((lst_gal['lmass'] < 11.8) & (lst_gal['lmass'] > 10.8))]
#finding the various aperture radii in arcminutes based on given z#
kpc_per_arcmin = cosmo.kpc_proper_per_arcmin(z)
arcmin_per_kpc = kpc_per_arcmin**(-1)
arcmin = arcmin_per_kpc*(R*u.kpc)
#retrieving RA and DEC data of given galaxy#
p1 = data_tmp[(data_tmp['id'] == gal_id)]
#calculating distance in special ANGLE measure to each galaxy in lst_gal#
sc0 = SkyCoord(p1['ra']*u.deg, p1['dec']*u.deg)
sc1 = SkyCoord(lst_gal1['ra']*u.deg, lst_gal1['dec']*u.deg)
sc2 = SkyCoord(lst_gal2['ra']*u.deg, lst_gal2['dec']*u.deg)
sc3 = SkyCoord(lst_gal3['ra']*u.deg, lst_gal3['dec']*u.deg)
sc4 = SkyCoord(lst_gal4['ra']*u.deg, lst_gal4['dec']*u.deg)
sep1 = sc0.separation(sc1).to(u.arcmin)
sep2 = sc0.separation(sc2).to(u.arcmin)
sep3 = sc0.separation(sc3).to(u.arcmin)
sep4 = sc0.separation(sc4).to(u.arcmin)
#finding number of "sep's" within the list 'arcmin' already created#
nn1 = np.empty(len(R))
nn2 = np.empty(len(R))
nn3 = np.empty(len(R))
nn4 = np.empty(len(R))
for ii,r in enumerate(arcmin):
nn1[ii] = np.sum(sep1 <= r)
nn2[ii] = np.sum(sep2 <= r)
nn3[ii] = np.sum(sep3 <= r)
nn4[ii] = np.sum(sep4 <= r)
#returning four lists of counts pre radius with lower end number for lower mass bin#
return [nn1, nn2, nn3, nn4]
def Counts(gal_id, gal_field, z, R = 10**np.linspace(1.2,3.6,13), delta_z = 0.1, min_mass = 9.415):
from astropy.coordinates.sky_coordinate import SkyCoord
from astropy import units as u
#making a list of galaxies in within a redshift range of given z, in the selected field, and above the mass limit#
lst_gal = []
data_tmp = data_flagged[data_flagged['field'] == gal_field]
mask = ((np.abs(data_tmp['z_peak'] - z) <= delta_z) & (data_tmp['id'] != gal_id) & (data_tmp['lmass'] >= min_mass))
lst_gal = data_tmp[mask]
#finding the various aperture radii in arcminutes based on given z#
kpc_per_arcmin = cosmo.kpc_proper_per_arcmin(z)
arcmin_per_kpc = kpc_per_arcmin**(-1)
arcmin = arcmin_per_kpc*(R*u.kpc)
#retrieving RA and DEC data of given galaxy#
p1 = data_tmp[(data_tmp['id'] == gal_id)]
#calculating distance in special ANGLE measure to each galaxy in lst_gal#
sc0 = SkyCoord(p1['ra']*u.deg, p1['dec']*u.deg)
sc = SkyCoord(lst_gal['ra']*u.deg, lst_gal['dec']*u.deg)
sep = sc0.separation(sc)
sep = sep.to(u.arcmin)
#finding number of "sep's" within the list 'arcmin' already created#
nn = np.empty(len(R))
for ii,r in enumerate(arcmin):
nn[ii] = np.sum(sep <= r)
return nn
def Counts(gal_id, gal_field, z, R = 10**np.linspace(1.2,3.6,13), delta_z = 0.1, min_mass = 9.415):
#making a list of galaxies in within a redshift range of given z, in the selected field, and above the mass limit#
lst_gal = []
data_tmp = data[data['field'] == gal_field]
#separating the potential satellites into star-forming(b) and quiescent(r) bins#
mask = ((np.abs(data_tmp['z'] - z) <= delta_z) & (data_tmp['id'] != gal_id) & (data_tmp['lmass'] >= min_mass))
lst_gal = data_tmp[mask]
lst_galr = lst_gal[(((lst_gal['vj'] < 0.92) & (lst_gal['uv'] > 1.3)) | ((lst_gal['vj'] > 0.8) & (lst_gal['vj'] < 1.6) & (lst_gal['uv'] > (0.88*lst_gal['vj'] +0.49))))]
lst_galb = lst_gal[(((lst_gal['vj'] < 0.92) & (lst_gal['uv'] < 1.3)) | ((lst_gal['vj'] > 0.8) & (lst_gal['vj'] < 1.6) & (lst_gal['uv'] < (0.88*lst_gal['vj'] +0.49))) | (lst_gal['vj']>1.5))]
#finding the various aperture radii in arcminutes based on given z#
kpc_per_arcmin = cosmo.kpc_proper_per_arcmin(z)
arcmin_per_kpc = kpc_per_arcmin**(-1)
arcmin = arcmin_per_kpc*(R*u.kpc)
#retrieving RA and DEC data of given galaxy#
p1 = data_tmp[(data_tmp['id'] == gal_id)]
#calculating distance in special ANGLE measure to each galaxy in lst_gal#
sc0 = SkyCoord(p1['ra']*u.deg, p1['dec']*u.deg)
sc1 = SkyCoord(lst_galr['ra']*u.deg, lst_galr['dec']*u.deg)
sc2 = SkyCoord(lst_galb['ra']*u.deg, lst_galb['dec']*u.deg)
sep1 = sc0.separation(sc1).to(u.arcmin)
sep2 = sc0.separation(sc2).to(u.arcmin)
#finding number of "sep's" within the list 'arcmin' already created#
nnr = np.empty(len(R))
nnb = np.empty(len(R))
for ii,r in enumerate(arcmin):
nnr[ii] = np.sum(sep1 <= r)
nnb[ii] = np.sum(sep2 <= r)
return [nnr, nnb]
def rand_counts(gal_field,
z,
R=10**np.linspace(1.2, 3.6, 13),
delta_z=0.1,
min_mass=9.415):
#picking random location for galaxy number density#
if gal_field == 'AEGIS':
ra1 = random.uniform(3.746000, 3.756821)
dec1 = random.uniform(0.920312, 0.925897)
elif gal_field == 'COSMOS':
ra1 = random.uniform(2.619737, 2.620718)
dec1 = random.uniform(0.038741, 0.043811)
elif gal_field == 'GOODS-N':
ra1 = random.uniform(3.298072, 3.307597)
dec1 = random.uniform(1.084787, 1.087936)
elif gal_field == 'GOODS-S':
ra1 = random.uniform(0.925775, 0.929397)
dec1 = random.uniform(-0.487098, -0.483591)
elif gal_field == 'UDS':
ra1 = random.uniform(0.59815, 0.602889)
dec1 = random.uniform(-0.091376, -0.090305)
from astropy.coordinates.sky_coordinate import SkyCoord
from astropy import units as u
#switching ra and dec to degrees#
ra1 = ra1 * (180.0 / math.pi)
dec1 = dec1 * (180.0 / math.pi)
#making a list of galaxies in within a redshift range of given z#
lst_gal = []
data_tmp = data_flagged[data_flagged['field'] == gal_field]
mask = (np.abs(data_tmp['z_peak'] - z) <= delta_z) & (data_tmp['lmass'] >=
min_mass)
lst_gal = data_tmp[mask]
#converting radius R (kpc) to radians at given redshift z#
kpc_per = cosmo.kpc_proper_per_arcmin(z)
arcmin_per = kpc_per**(-1)
arcmin = arcmin_per * (R * u.kpc)
#retrieving RA and DEC data of given galaxy#
sc0 = SkyCoord(ra1 * u.deg, dec1 * u.deg)
sc = SkyCoord(lst_gal['ra'] * u.deg, lst_gal['dec'] * u.deg)
sep = sc.separation(sc0)
sep = sep.to(u.arcmin)
nn = np.empty(len(R))
for ii, r in enumerate(arcmin):
nn[ii] = np.sum(sep <= r)
return nn
def rand_counts(gal_field, z, R = 10**np.linspace(1.2,3.6,13), delta_z = 0.1, min_mass = 9.415):
#picking random location for galaxy number density#
if gal_field == 'AEGIS':
ra1 = random.uniform(3.746000, 3.756821)
dec1 = random.uniform(0.920312, 0.925897)
elif gal_field == 'COSMOS':
ra1 = random.uniform(2.619737, 2.620718)
dec1 = random.uniform(0.038741, 0.043811)
elif gal_field == 'GOODS-N':
ra1 = random.uniform(3.298072, 3.307597)
dec1 = random.uniform(1.084787, 1.087936)
elif gal_field == 'GOODS-S':
ra1 = random.uniform(0.925775, 0.929397)
dec1 = random.uniform(-0.487098, -0.483591)
elif gal_field == 'UDS':
ra1 = random.uniform(0.59815, 0.602889)
dec1 = random.uniform(-0.091376, -0.090305)
#switching ra and dec to degrees#
ra1 = ra1*(180.0/math.pi)
dec1 = dec1*(180.0/math.pi)
#making a list of galaxies in within a redshift range of given z, in the selected field, and above the mass limit#
lst_gal = []
data_tmp = data[data['field'] == gal_field]
mask = ((np.abs(data_tmp['z'] - z) <= delta_z) & (data_tmp['lmass'] >= min_mass))
lst_gal = data_tmp[mask]
lst_galr = lst_gal[(((lst_gal['vj'] < 0.92) & (lst_gal['uv'] > 1.3)) | ((lst_gal['vj'] > 0.8) & (lst_gal['vj'] < 1.6) & (lst_gal['uv'] > (0.88*lst_gal['vj'] +0.49))))]
lst_galb = lst_gal[(((lst_gal['vj'] < 0.92) & (lst_gal['uv'] < 1.3)) | ((lst_gal['vj'] > 0.8) & (lst_gal['vj'] < 1.6) & (lst_gal['uv'] < (0.88*lst_gal['vj'] +0.49))) | (lst_gal['vj']>1.5))]
#finding the various aperture radii in arcminutes based on given z#
kpc_per_arcmin = cosmo.kpc_proper_per_arcmin(z)
arcmin_per_kpc = kpc_per_arcmin**(-1)
arcmin = arcmin_per_kpc*(R*u.kpc)
#calculating distance in special ANGLE measure to each galaxy in lst_gal#
sc0 = SkyCoord(ra1*u.deg, dec1*u.deg)
sc1 = SkyCoord(lst_galr['ra']*u.deg, lst_galr['dec']*u.deg)
sc2 = SkyCoord(lst_galb['ra']*u.deg, lst_galb['dec']*u.deg)
sep1 = sc0.separation(sc1).to(u.arcmin)
sep2 = sc0.separation(sc2).to(u.arcmin)
#finding number of "sep's" within the list 'arcmin' already created#
nn1 = np.empty(len(R))
nn2 = np.empty(len(R))
for ii,r in enumerate(arcmin):
nn1[ii] = np.sum(sep1 <= r)
nn2[ii] = np.sum(sep2 <= r)
#nn1 is density list for quiescent, nn2 is for star-forming#
return [nn1, nn2]
def listcord2center(coord_list):
"""
Return the center of a list of coordinates. This is
done by averaging cartesian coordinates to avoid
looping in RA-Dec.
Parameters
----------
- coord_list (SkyCoord list): list of sky coordinates
Outputs
--------
- center (SkyCoord): SkyCoord object, center of the list
"""
# Get the cartesian coordinates
x = coord_list.cartesian.x
y = coord_list.cartesian.y
z = coord_list.cartesian.z
# Average the cartesian coordinates
x_m = np.mean(x)
y_m = np.mean(y)
z_m = np.mean(z)
# Transform to sky coordinates
r, lat, lon = cartesian_to_spherical(x_m, y_m, z_m)
center_guess = SkyCoord(lon, lat, frame='icrs')
# Perform distance minimisation to make sure it is ok
def fun(par):
c = SkyCoord(par[0] * u.deg, par[1] * u.deg, frame='icrs')
dist = coord_list.separation(c)
return np.sum(dist.value**2)
p_guess = np.array(
[center_guess.ra.to_value('deg'),
center_guess.dec.to_value('deg')])
res = minimize(fun, p_guess)
center = SkyCoord(res.x[0] * u.deg, res.x[1] * u.deg, frame='icrs')
# Sanity check
if res.success is not True:
print('!!! WARNING: not sure I found the coordinates barycenter !!!')
print('Separation between cartesian center and my center: ')
print(center.separation(center_guess).to_value('deg'), 'deg')
print('Center: ')
print(center)
return center
def Counts_q(gal_id,
gal_field,
z,
R=10**np.linspace(1.2, 3.6, 13),
delta_z=0.1,
min_mass=9.415):
#making a list of galaxies in within a redshift range of given z, in the selected field, and above the mass limit#
lst_gal = []
data_tmp = data1[data1['field'] == gal_field]
mask = ((np.abs(data_tmp['z'] - z) <= delta_z) & (data_tmp['id'] != gal_id)
& (data_tmp['lmass'] >= min_mass))
#making list of satellites in total and list of satellites that are quiescent#
lst_gal = data_tmp[mask]
lst_galr = lst_gal[(((lst_gal['vj'] < 0.92) & (lst_gal['uv'] > 1.3)) |
((lst_gal['vj'] > 0.8) & (lst_gal['vj'] < 1.6) &
(lst_gal['uv'] > (0.88 * lst_gal['vj'] + 0.49))))]
#finding the various aperture radii in arcminutes based on given z#
kpc_per_arcmin = cosmo.kpc_proper_per_arcmin(z)
arcmin_per_kpc = kpc_per_arcmin**(-1)
arcmin = arcmin_per_kpc * (R * u.kpc)
#retrieving RA and DEC data of given galaxy#
p1 = data_tmp[(data_tmp['id'] == gal_id)]
#calculating distance in special ANGLE measure to each galaxy in lst_gal#
sc0 = SkyCoord(p1['ra'] * u.deg, p1['dec'] * u.deg)
sc1 = SkyCoord(lst_galr['ra'] * u.deg, lst_galr['dec'] * u.deg)
sc2 = SkyCoord(lst_gal['ra'] * u.deg, lst_gal['dec'] * u.deg)
sep1 = sc0.separation(sc1).to(u.arcmin)
sep2 = sc0.separation(sc2).to(u.arcmin)
#finding number of "sep's" within the list 'arcmin' already created#
nnr = np.empty(len(R))
nn = np.empty(len(R))
for ii, r in enumerate(arcmin):
nnr[ii] = np.sum(sep1 <= r)
nn[ii] = np.sum(sep2 <= r)
lst_q = []
#calculating quiescent percentage and adding it to a list#
for i in range(len(nnr)):
#filtering out (making a 5 that later gets ignored) results that divide by 0#
if nn[i] == 0:
lst_q.append(5)
else:
lst_q.append(nnr[i] / nnb[i])
return lst_q
def rand_counts(gal_field, z, R = 10**np.linspace(1.2,3.6,13), delta_z = 0.1, min_mass = 9.415):
#picking random location for galaxy number density#
if gal_field == 'AEGIS':
ra1 = random.uniform(3.746000, 3.756821)
dec1 = random.uniform(0.920312, 0.925897)
elif gal_field == 'COSMOS':
ra1 = random.uniform(2.619737, 2.620718)
dec1 = random.uniform(0.038741, 0.043811)
elif gal_field == 'GOODS-N':
ra1 = random.uniform(3.298072, 3.307597)
dec1 = random.uniform(1.084787, 1.087936)
elif gal_field == 'GOODS-S':
ra1 = random.uniform(0.925775, 0.929397)
dec1 = random.uniform(-0.487098, -0.483591)
elif gal_field == 'UDS':
ra1 = random.uniform(0.59815, 0.602889)
dec1 = random.uniform(-0.091376, -0.090305)
from astropy.coordinates.sky_coordinate import SkyCoord
from astropy import units as u
#switching ra and dec to degrees#
ra1 = ra1*(180.0/math.pi)
dec1 = dec1*(180.0/math.pi)
#making a list of galaxies in within a redshift range of given z#
lst_gal = []
data_tmp = data_flagged[data_flagged['field'] == gal_field]
mask = (np.abs(data_tmp['z_peak'] - z) <= delta_z) & (data_tmp['lmass'] >= min_mass)
lst_gal = data_tmp[mask]
#converting radius R (kpc) to radians at given redshift z#
kpc_per = cosmo.kpc_proper_per_arcmin(z)
arcmin_per = kpc_per**(-1)
arcmin = arcmin_per*(R*u.kpc)
#retrieving RA and DEC data of given galaxy#
sc0 = SkyCoord(ra1*u.deg, dec1*u.deg)
sc = SkyCoord(lst_gal['ra']*u.deg, lst_gal['dec']*u.deg)
sep = sc.separation(sc0)
sep = sep.to(u.arcmin)
nn = np.empty(len(R))
for ii,r in enumerate(arcmin):
nn[ii] = np.sum(sep <= r)
return nn
def _trace_back_obj(self, o, c, t):
"""
computes minimum time and distance of object trajectory with that of c
Arguments:
o: object, SkyCoord
c: object, SkyCoord, presumably cluster center
t: time vector in years over which to perform calculations
Returns:
dict with keys: d_min, t_min and tol
Referenct:
https://arxiv.org/pdf/2005.04762.pdf
"""
#function to constrain dec between -90 and 90 (argument in radians)
fix_lat = np.vectorize(lambda x: x if x <= np.pi/2.0 else \
( np.pi-x if x <=3.0*np.pi/2.0 else x-2.0*np.pi))
# get the ra's and dec's of the two objects at time t
# relying on astropy.units to do proper conversion to degrees
o_ra = (o.ra + o.pm_ra_cosdec * t).wrap_at(360 * u.degree)
c_ra = (c.ra + c.pm_ra * t).wrap_at(360 * u.degree)
o_dec = coord.Angle(
fix_lat((o.dec + o.pm_dec * t).radian % (2.0 * np.pi)) * u.radian)
c_dec = coord.Angle(
fix_lat((c.dec + c.pm_dec * t).radian % (2.0 * np.pi)) * u.radian)
#sky coords at time t for both, using constant distance:
o_t = SkyCoord(ra=o_ra, dec=o_dec, distance=o.distance)
c_t = SkyCoord(ra=c_ra, dec=c_dec, distance=c.distance)
#angular separation as function of time
sep = o_t.separation(c_t)
#find minimum separation and time
min_i = sep.argmin()
d_min = o_t[min_i].separation(c_t[min_i])
t_min = t[min_i]
#calculate the tolerance (see equation 1 in reference)
tol = 10 + 1.3 * c.separation(o) / (1 * u.degree)
return {
"t_min": t_min,
"d_min": d_min,
"tol": tol,
'tracesback': (d_min / (1.0 * u.arcminute)) <= tol
}
def Counts_q(gal_id, gal_field, z, R=10 ** np.linspace(1.2, 3.6, 13), delta_z=0.1, min_mass=9.415):
# making a list of galaxies in within a redshift range of given z, in the selected field, and above the mass limit#
lst_gal = []
data_tmp = data1[data1["field"] == gal_field]
mask = (np.abs(data_tmp["z"] - z) <= delta_z) & (data_tmp["id"] != gal_id) & (data_tmp["lmass"] >= min_mass)
# making list of satellites in total and list of satellites that are quiescent#
lst_gal = data_tmp[mask]
lst_galr = lst_gal[
(
((lst_gal["vj"] < 0.92) & (lst_gal["uv"] > 1.3))
| ((lst_gal["vj"] > 0.8) & (lst_gal["vj"] < 1.6) & (lst_gal["uv"] > (0.88 * lst_gal["vj"] + 0.49)))
)
]
# finding the various aperture radii in arcminutes based on given z#
kpc_per_arcmin = cosmo.kpc_proper_per_arcmin(z)
arcmin_per_kpc = kpc_per_arcmin ** (-1)
arcmin = arcmin_per_kpc * (R * u.kpc)
# retrieving RA and DEC data of given galaxy#
p1 = data_tmp[(data_tmp["id"] == gal_id)]
# calculating distance in special ANGLE measure to each galaxy in lst_gal#
sc0 = SkyCoord(p1["ra"] * u.deg, p1["dec"] * u.deg)
sc1 = SkyCoord(lst_galr["ra"] * u.deg, lst_galr["dec"] * u.deg)
sc2 = SkyCoord(lst_gal["ra"] * u.deg, lst_gal["dec"] * u.deg)
sep1 = sc0.separation(sc1).to(u.arcmin)
sep2 = sc0.separation(sc2).to(u.arcmin)
# finding number of "sep's" within the list 'arcmin' already created#
nnr = np.empty(len(R))
nn = np.empty(len(R))
for ii, r in enumerate(arcmin):
nnr[ii] = np.sum(sep1 <= r)
nn[ii] = np.sum(sep2 <= r)
lst_q = []
# calculating quiescent percentage and adding it to a list#
for i in range(len(nnr)):
# filtering out (making a 5 that later gets ignored) results that divide by 0#
if nn[i] == 0:
lst_q.append(5)
else:
lst_q.append(nnr[i] / nnb[i])
return lst_q
def Counts(gal_id,
gal_field,
z,
R=10**np.linspace(1.2, 3.6, 13),
delta_z=0.1,
min_mass=9.415):
from astropy.coordinates.sky_coordinate import SkyCoord
from astropy import units as u
#making a list of galaxies in within a redshift range of given z, in the selected field, and above the mass limit#
lst_gal = []
data_tmp = data_flagged[data_flagged['field'] == gal_field]
mask = ((np.abs(data_tmp['z_peak'] - z) <= delta_z) &
(data_tmp['id'] != gal_id) & (data_tmp['lmass'] >= min_mass))
lst_gal = data_tmp[mask]
#finding the various aperture radii in arcminutes based on given z#
kpc_per_arcmin = cosmo.kpc_proper_per_arcmin(z)
arcmin_per_kpc = kpc_per_arcmin**(-1)
arcmin = arcmin_per_kpc * (R * u.kpc)
#retrieving RA and DEC data of given galaxy#
p1 = data_tmp[(data_tmp['id'] == gal_id)]
#calculating distance in special ANGLE measure to each galaxy in lst_gal#
sc0 = SkyCoord(p1['ra'] * u.deg, p1['dec'] * u.deg)
sc = SkyCoord(lst_gal['ra'] * u.deg, lst_gal['dec'] * u.deg)
sep = sc0.separation(sc)
sep = sep.to(u.arcmin)
#finding number of "sep's" within the list 'arcmin' already created#
nn = np.empty(len(R))
for ii, r in enumerate(arcmin):
nn[ii] = np.sum(sep <= r)
return nn
def rand_counts(gal_field,
z,
R=10**np.linspace(1.2, 3.6, 13),
delta_z=0.1,
min_mass=9.415):
#picking random location for galaxy number density#
if gal_field == 'AEGIS':
ra1 = random.uniform(3.746000, 3.756821)
dec1 = random.uniform(0.920312, 0.925897)
elif gal_field == 'COSMOS':
ra1 = random.uniform(2.619737, 2.620718)
dec1 = random.uniform(0.038741, 0.043811)
elif gal_field == 'GOODS-N':
ra1 = random.uniform(3.298072, 3.307597)
dec1 = random.uniform(1.084787, 1.087936)
elif gal_field == 'GOODS-S':
ra1 = random.uniform(0.925775, 0.929397)
dec1 = random.uniform(-0.487098, -0.483591)
elif gal_field == 'UDS':
ra1 = random.uniform(0.59815, 0.602889)
dec1 = random.uniform(-0.091376, -0.090305)
from astropy.coordinates.sky_coordinate import SkyCoord
from astropy import units as u
#switching ra and dec to degrees#
ra1 = ra1 * (180.0 / math.pi)
dec1 = dec1 * (180.0 / math.pi)
#making a list of galaxies in within a redshift range of given z, in the selected field, and above the mass limit#
lst_gal = []
data_tmp = data_flagged[data_flagged['field'] == gal_field]
#binning the satellites based on mass#
mask = ((np.abs(data_tmp['z_peak'] - z) <= delta_z) &
(data_tmp['lmass'] >= min_mass))
lst_gal = data_tmp[mask]
lst_gal1 = lst_gal[(lst_gal['lmass'] < 9.8)]
lst_gal2 = lst_gal[((lst_gal['lmass'] < 10.3) & (lst_gal['lmass'] > 9.8))]
lst_gal3 = lst_gal[((lst_gal['lmass'] < 10.8) & (lst_gal['lmass'] > 10.3))]
lst_gal4 = lst_gal[((lst_gal['lmass'] < 11.8) & (lst_gal['lmass'] > 10.8))]
#finding the various aperture radii in arcminutes based on given z#
kpc_per_arcmin = cosmo.kpc_proper_per_arcmin(z)
arcmin_per_kpc = kpc_per_arcmin**(-1)
arcmin = arcmin_per_kpc * (R * u.kpc)
#calculating distance in special ANGLE measure to each galaxy in lst_gal#
sc0 = SkyCoord(ra1 * u.deg, dec1 * u.deg)
sc1 = SkyCoord(lst_gal1['ra'] * u.deg, lst_gal1['dec'] * u.deg)
sc2 = SkyCoord(lst_gal2['ra'] * u.deg, lst_gal2['dec'] * u.deg)
sc3 = SkyCoord(lst_gal3['ra'] * u.deg, lst_gal3['dec'] * u.deg)
sc4 = SkyCoord(lst_gal4['ra'] * u.deg, lst_gal4['dec'] * u.deg)
sep1 = sc0.separation(sc1).to(u.arcmin)
sep2 = sc0.separation(sc2).to(u.arcmin)
sep3 = sc0.separation(sc3).to(u.arcmin)
sep4 = sc0.separation(sc4).to(u.arcmin)
#finding number of "sep's" within the list 'arcmin' already created#
nn1 = np.empty(len(R))
nn2 = np.empty(len(R))
nn3 = np.empty(len(R))
nn4 = np.empty(len(R))
for ii, r in enumerate(arcmin):
nn1[ii] = np.sum(sep1 <= r)
nn2[ii] = np.sum(sep2 <= r)
nn3[ii] = np.sum(sep3 <= r)
nn4[ii] = np.sum(sep4 <= r)
#returning four lists of counts per radius with low end number for low mass bin#
return [nn1, nn2, nn3, nn4]
def rand_counts(gal_field, z, R = 10**np.linspace(1.2,3.6,13), delta_z = 0.1, min_mass = 9.415):
#picking random location for galaxy number density#
if gal_field == 'AEGIS':
ra1 = random.uniform(3.746000, 3.756821)
dec1 = random.uniform(0.920312, 0.925897)
elif gal_field == 'COSMOS':
ra1 = random.uniform(2.619737, 2.620718)
dec1 = random.uniform(0.038741, 0.043811)
elif gal_field == 'GOODS-N':
ra1 = random.uniform(3.298072, 3.307597)
dec1 = random.uniform(1.084787, 1.087936)
elif gal_field == 'GOODS-S':
ra1 = random.uniform(0.925775, 0.929397)
dec1 = random.uniform(-0.487098, -0.483591)
elif gal_field == 'UDS':
ra1 = random.uniform(0.59815, 0.602889)
dec1 = random.uniform(-0.091376, -0.090305)
from astropy.coordinates.sky_coordinate import SkyCoord
from astropy import units as u
#switching ra and dec to degrees#
ra1 = ra1*(180.0/math.pi)
dec1 = dec1*(180.0/math.pi)
#making a list of galaxies in within a redshift range of given z, in the selected field, and above the mass limit#
lst_gal = []
data_tmp = data_flagged[data_flagged['field'] == gal_field]
#binning the satellites based on mass#
mask = ((np.abs(data_tmp['z_peak'] - z) <= delta_z) & (data_tmp['lmass'] >= min_mass))
lst_gal = data_tmp[mask]
lst_gal1 = lst_gal[(lst_gal['lmass'] < 9.8)]
lst_gal2 = lst_gal[((lst_gal['lmass'] < 10.3) & (lst_gal['lmass'] > 9.8))]
lst_gal3 = lst_gal[((lst_gal['lmass'] < 10.8) & (lst_gal['lmass'] > 10.3))]
lst_gal4 = lst_gal[((lst_gal['lmass'] < 11.8) & (lst_gal['lmass'] > 10.8))]
#finding the various aperture radii in arcminutes based on given z#
kpc_per_arcmin = cosmo.kpc_proper_per_arcmin(z)
arcmin_per_kpc = kpc_per_arcmin**(-1)
arcmin = arcmin_per_kpc*(R*u.kpc)
#calculating distance in special ANGLE measure to each galaxy in lst_gal#
sc0 = SkyCoord(ra1*u.deg, dec1*u.deg)
sc1 = SkyCoord(lst_gal1['ra']*u.deg, lst_gal1['dec']*u.deg)
sc2 = SkyCoord(lst_gal2['ra']*u.deg, lst_gal2['dec']*u.deg)
sc3 = SkyCoord(lst_gal3['ra']*u.deg, lst_gal3['dec']*u.deg)
sc4 = SkyCoord(lst_gal4['ra']*u.deg, lst_gal4['dec']*u.deg)
sep1 = sc0.separation(sc1).to(u.arcmin)
sep2 = sc0.separation(sc2).to(u.arcmin)
sep3 = sc0.separation(sc3).to(u.arcmin)
sep4 = sc0.separation(sc4).to(u.arcmin)
#finding number of "sep's" within the list 'arcmin' already created#
nn1 = np.empty(len(R))
nn2 = np.empty(len(R))
nn3 = np.empty(len(R))
nn4 = np.empty(len(R))
for ii,r in enumerate(arcmin):
nn1[ii] = np.sum(sep1 <= r)
nn2[ii] = np.sum(sep2 <= r)
nn3[ii] = np.sum(sep3 <= r)
nn4[ii] = np.sum(sep4 <= r)
#returning four lists of counts per radius with low end number for low mass bin#
return [nn1, nn2, nn3, nn4]
