def radius_search(tree, datapoint, radius):
""" find all points within radius of datapoint """
stack = [tree[0]]
inside = []
while stack:
leaf_idx, leaf_data, left_hrect, \
right_hrect, left, right = stack.pop()
# leaf
if leaf_idx is not None:
param=leaf_data.shape[0]
#distance = np.sqrt(((leaf_data - datapoint.reshape((param,1)))**2).sum(axis=0))
distance = astro.projected_distance(leaf_data[0], datapoint[0], leaf_data[1], datapoint[1])
near = np.where(distance<=radius)
if len(near[0]):
idx = leaf_idx[near]
distance = distance[near]
inside += (zip(distance, idx))
else:
if intersect(left_hrect, radius, datapoint):
stack.append(tree[left])
if intersect(right_hrect, radius, datapoint):
stack.append(tree[right])
return np.array(inside)
def radius_search(tree, datapoint, radius):
""" find all points within radius of datapoint """
stack = [tree[0]]
inside = []
while stack:
leaf_idx, leaf_data, left_hrect, \
right_hrect, left, right = stack.pop()
# leaf
if leaf_idx is not None:
param = leaf_data.shape[0]
#distance = np.sqrt(((leaf_data - datapoint.reshape((param,1)))**2).sum(axis=0))
distance = astro.projected_distance(leaf_data[0], datapoint[0],
leaf_data[1], datapoint[1])
near = np.where(distance <= radius)
if len(near[0]):
idx = leaf_idx[near]
distance = distance[near]
inside += (zip(distance, idx))
else:
if intersect(left_hrect, radius, datapoint):
stack.append(tree[left])
if intersect(right_hrect, radius, datapoint):
stack.append(tree[right])
return np.array(inside)
def __init__(self, mem):
self.mem = np.array(mem)
self.size = len(self.mem)
self.ra = np.median(self.mem[:, 0])
self.dec = np.median(self.mem[:, 1])
min_ra = min(self.mem[:, 0])
min_dec = max(self.mem[:, 1])
self.radius = astro.deg2rad(astro.projected_distance(self.ra, min_ra, self.dec, min_dec) / 60.0)
def __init__(self, mem):
self.mem = np.array(mem)
self.size = len(self.mem)
self.ra = np.median(self.mem[:, 0])
self.dec = np.median(self.mem[:, 1])
min_ra = min(self.mem[:, 0])
min_dec = max(self.mem[:, 1])
self.radius = astro.deg2rad(
astro.projected_distance(self.ra, min_ra, self.dec, min_dec) /
60.0)
def nn_search(node, query_point, radius, depth, best_neighbours):
if node == None:
return
# if we have reached a leaf, let's add to current best neighbours,
# (if it's better than the worst one or if there is not enough neighbours)
if node.is_leaf():
best_neighbours.add(node.point)
return
# this node is no leaf
# select dimension for comparison (based on current depth)
axis = depth % 2
# figure out which subtree to search
near_subtree = None # near subtree
far_subtree = None # far subtree (perhaps we'll have to traverse it as well)
# compare query_point and point of current node in selected dimension
# and figure out which subtree is farther than the other
if query_point[axis] < node.point[axis]:
near_subtree = node.left
far_subtree = node.right
else:
near_subtree = node.right
far_subtree = node.left
# recursively search through the tree until a leaf is found
nn_search(near_subtree, query_point, radius, depth + 1,
best_neighbours)
# while unwinding the recursion, check if the current node
# is closer to query point than the current best,
# also, until t points have been found, search radius is infinity
best_neighbours.add(node.point)
# check whether there could be any points on the other side of the
# splitting plane that are closer to the query point than the current best
if astro.projected_distance(node.point[0], query_point[0],
node.point[1],
query_point[1]) <= radius:
nn_search(far_subtree, query_point, radius, depth + 1,
best_neighbours)
return
def props(self, bg_expect):
"""
Function that sets Cluster properties.
"""
self.ra = np.median(self.g_ra)
self.dec = np.median(self.g_dec)
self.z = np.median(self.g_z)
self.ngal = len(self.g_id)
distances = []
for i in range(self.ngal):
distances.extend([astro.projected_distance(self.g_ra[i], self.ra, self.g_dec[i], self.dec)])
self.size = np.mean(distances)
self.area = self.size ** 2 * math.pi
if bg_expect != None:
self.sn = (self.ngal) / ((self.area * bg_expect) ** 0.5)
else:
self.sn = 0.0
def friendship(zbin, gal1, gal2, mode):
"""
Function that checks if two galaxies are friends in
a given redshift bin.
"""
if mode == 'spec':
rfriend = zbin.link_r / gal1.da
else:
rfriend = zbin.rfriend
dist = astro.deg2rad(astro.projected_distance(gal1.ra, gal2.ra, gal1.dec, gal2.dec) / 60.0)
check1 = (dist < rfriend)
if mode == 'spec':
check2 = (math.fabs(gal1.v - gal2.v) <= zbin.link_z)
check = (check1 & check2)
else:
check = check1
return check
def friendship(zbin, gal1, gal2, mode):
"""
Function that checks if two galaxies are friends in
a given redshift bin.
"""
if mode == 'spec':
rfriend = zbin.link_r / gal1.da
else:
rfriend = zbin.rfriend
dist = astro.deg2rad(
astro.projected_distance(gal1.ra, gal2.ra, gal1.dec, gal2.dec) / 60.0)
check1 = (dist < rfriend)
if mode == 'spec':
check2 = (math.fabs(gal1.v - gal2.v) <= zbin.link_z)
check = (check1 & check2)
else:
check = check1
return check
def nn_search(node, query_point, radius, depth, best_neighbours):
if node == None:
return
# if we have reached a leaf, let's add to current best neighbours,
# (if it's better than the worst one or if there is not enough neighbours)
if node.is_leaf():
best_neighbours.add(node.point)
return
# this node is no leaf
# select dimension for comparison (based on current depth)
axis = depth % 2
# figure out which subtree to search
near_subtree = None # near subtree
far_subtree = None # far subtree (perhaps we'll have to traverse it as well)
# compare query_point and point of current node in selected dimension
# and figure out which subtree is farther than the other
if query_point[axis] < node.point[axis]:
near_subtree = node.left
far_subtree = node.right
else:
near_subtree = node.right
far_subtree = node.left
# recursively search through the tree until a leaf is found
nn_search(near_subtree, query_point, radius, depth+1, best_neighbours)
# while unwinding the recursion, check if the current node
# is closer to query point than the current best,
# also, until t points have been found, search radius is infinity
best_neighbours.add(node.point)
# check whether there could be any points on the other side of the
# splitting plane that are closer to the query point than the current best
if astro.projected_distance(node.point[0], query_point[0], node.point[1], query_point[1]) <= radius:
nn_search(far_subtree, query_point, radius, depth+1, best_neighbours)
return
def props(self, bg_expect):
"""
Function that sets Cluster properties.
"""
self.ra = np.median(self.g_ra)
self.dec = np.median(self.g_dec)
self.z = np.median(self.g_z)
self.ngal = len(self.g_id)
distances = []
for i in range(self.ngal):
distances.extend([
astro.projected_distance(self.g_ra[i], self.ra, self.g_dec[i],
self.dec)
])
self.size = np.mean(distances)
self.area = self.size**2 * math.pi
if bg_expect != None:
self.sn = (self.ngal) / ((self.area * bg_expect)**0.5)
else:
self.sn = 0.0
for i in range(cluster.size):
c_bin_count[c_rich_bin_index[i], c_z_bin_index[i]] += 1
for i in range(mock.size):
m_bin_count[m_rich_bin_index[i], m_z_bin_index[i]] += 1
if m_match_flag[i] == -1:
#Find clusters that match primary matching conditions.
index1 = np.where((c_match_flag == -1) &
(np.fabs(mock.z[i] - cluster.z) <= (z_factor * opts.delta_z * (1 + mock.z[i]))) &
(cluster.ra >= mock.minra[i]) & (cluster.ra <= mock.maxra[i]) &
(cluster.dec >= mock.mindec[i]) & (cluster.dec <= mock.maxdec[i]))[0]
if len(index1) > 0:
#Calculate the projected distance to halo centre for these clusters.
dists = []
for j in index1:
dist = astro.projected_distance(mock.ra[i], cluster.ra[j], mock.dec[i], cluster.dec[j])
dists.extend([dist])
dists = np.array(dists)
#Find clusters within r200.
index2 = np.where(dists <= mock.r200[i])[0]
if len(index2) > 0:
dists = dists[index2]
index1 = index1[index2]
#Check if any of these have the same N_gal value.
index3 = np.where(cluster.rich[index1] == cluster.rich[index1[0]])[0]
if len(index3) > 0:
dists = dists[index3]
index1 = index1[index3]
#Choose the cluster closest to the halo.
index4 = np.argmin(dists)
index1 = index1[index4]
def add(self, point):
#angular separation in arcminutes
ang_sep = astro.projected_distance(point[0], self.query_point[0],
point[1], self.query_point[1])
if ang_sep <= self.radius:
self.current_best.append([point[2]])
for i in range(mock.size):
m_bin_count[m_rich_bin_index[i], m_z_bin_index[i]] += 1
if m_match_flag[i] == -1:
#Find clusters that match primary matching conditions.
index1 = np.where((c_match_flag == -1)
& (np.fabs(mock.z[i] - cluster.z) <=
(z_factor * opts.delta_z *
(1 + mock.z[i]))) & (cluster.ra >= mock.minra[i])
& (cluster.ra <= mock.maxra[i])
& (cluster.dec >= mock.mindec[i])
& (cluster.dec <= mock.maxdec[i]))[0]
if len(index1) > 0:
#Calculate the projected distance to halo centre for these clusters.
dists = []
for j in index1:
dist = astro.projected_distance(mock.ra[i], cluster.ra[j],
mock.dec[i], cluster.dec[j])
dists.extend([dist])
dists = np.array(dists)
#Find clusters within r200.
index2 = np.where(dists <= mock.r200[i])[0]
if len(index2) > 0:
dists = dists[index2]
index1 = index1[index2]
#Check if any of these have the same N_gal value.
index3 = np.where(
cluster.rich[index1] == cluster.rich[index1[0]])[0]
if len(index3) > 0:
dists = dists[index3]
index1 = index1[index3]
#Choose the cluster closest to the halo.
index4 = np.argmin(dists)
def add(self, point):
#angular separation in arcminutes
ang_sep = astro.projected_distance(point[0], self.query_point[0], point[1], self.query_point[1])
if ang_sep <= self.radius:
self.current_best.append([point[2]])
