def axes_correlated_with_input_vector(input_vectors, p=0., seed=None):
r"""
Calculate a list of 3d unit-vectors whose orientation is correlated
with the orientation of `input_vectors`.
Parameters
----------
input_vectors : ndarray
Numpy array of shape (npts, 3) storing a list of 3d vectors defining the
preferred orientation with which the returned vectors will be correlated.
Note that the normalization of `input_vectors` will be ignored.
p : ndarray, optional
Numpy array with shape (npts, ) defining the strength of the correlation
between the orientation of the returned vectors and the z-axis.
Default is zero, for no correlation.
Positive (negative) values of `p` produce galaxy principal axes
that are statistically aligned with the positive (negative) z-axis;
the strength of this alignment increases with the magnitude of p.
When p = 0, galaxy axes are randomly oriented.
seed : int, optional
Random number seed used to choose a random orthogonal direction
Returns
-------
unit_vectors : ndarray
Numpy array of shape (npts, 3)
"""
input_unit_vectors = normalized_vectors(input_vectors)
assert input_unit_vectors.shape[1] == 3
npts = input_unit_vectors.shape[0]
z_correlated_axes = axes_correlated_with_z(p, seed)
z_axes = np.tile((0, 0, 1), npts).reshape((npts, 3))
angles = angles_between_list_of_vectors(z_axes, input_unit_vectors)
rotation_axes = vectors_normal_to_planes(z_axes, input_unit_vectors)
matrices = rotation_matrices_from_angles(angles, rotation_axes)
return rotate_vector_collection(matrices, z_correlated_axes)
def assign_central_orientation(self, **kwargs):
r"""
Assign a set of three orthoganl unit vectors indicating the orientation
of the galaxies' major, intermediate, and minor axis
Parameters
==========
halo_axisA_x, halo_axisA_y, halo_axisA_z : array_like
x,y,z components of halo alignment axis
Returns
=======
major_aixs, intermediate_axis, minor_axis : numpy nd.arrays
arrays of galaxies' axes
"""
if 'table' in kwargs.keys():
table = kwargs['table']
Ax = table[self.list_of_haloprops_needed[0]]
Ay = table[self.list_of_haloprops_needed[1]]
Az = table[self.list_of_haloprops_needed[2]]
else:
Ax = kwargs[self.list_of_haloprops_needed[0]]
Ay = kwargs[self.list_of_haloprops_needed[1]]
Az = kwargs[self.list_of_haloprops_needed[2]]
# number of haloes
N = len(Ax)
# set prim_gal_axis orientation
major_input_vectors = np.vstack((Ax, Ay, Az)).T
theta_ma = self.misalignment_rvs(size=N)
# rotate alignment vector by theta_ma
ran_vecs = random_unit_vectors_3d(N)
mrot = rotation_matrices_from_angles(theta_ma, ran_vecs)
A_v = rotate_vector_collection(rotm, major_input_vectors)
# randomly set secondary axis orientation
B_v = random_perpendicular_directions(A_v)
# the tertiary axis is determined
C_v = vectors_normal_to_planes(A_v, B_v)
# depending on the prim_gal_axis, assign correlated axes
if self.prim_gal_axis == 'A':
major_v = A_v
inter_v = B_v
minor_v = C_v
elif self.prim_gal_axis == 'B':
major_v = B_v
inter_v = A_v
minor_v = C_v
elif self.prim_gal_axis == 'C':
major_v = B_v
inter_v = C_v
minor_v = A_v
else:
msg = ('primary galaxy axis {0} is not recognized.'.format(
self.prim_gal_axis))
raise ValueError(msg)
if 'table' in kwargs.keys():
try:
mask = (table['gal_type'] == self.gal_type)
except KeyError:
mask = np.array([True] * len(table))
msg = (
"Because `gal_type` not indicated in `table`.",
"The orientation is being assigned for all galaxies in the `table`."
)
print(msg)
# check to see if the columns exist
for key in list(self._galprop_dtypes_to_allocate.names):
if key not in table.keys():
table[key] = 0.0
# add orientations to the galaxy table
table['galaxy_axisA_x'][mask] = major_v[mask, 0]
table['galaxy_axisA_y'][mask] = major_v[mask, 1]
table['galaxy_axisA_z'][mask] = major_v[mask, 2]
table['galaxy_axisB_x'][mask] = inter_v[mask, 0]
table['galaxy_axisB_y'][mask] = inter_v[mask, 1]
table['galaxy_axisB_z'][mask] = inter_v[mask, 2]
table['galaxy_axisC_x'][mask] = minor_v[mask, 0]
table['galaxy_axisC_y'][mask] = minor_v[mask, 1]
table['galaxy_axisC_z'][mask] = minor_v[mask, 2]
return table
else:
return major_v, inter_v, minor_v
def assign_satellite_orientation(self, **kwargs):
r"""
assign a a set of three orthoganl unit vectors indicating the orientation
of the galaxies' major, intermediate, and minor axis
Returns
=======
major_aixs, intermediate_axis, minor_axis : numpy nd.arrays
arrays of galaxies' axies
"""
if 'table' in kwargs.keys():
table = kwargs['table']
try:
Lbox = kwargs['Lbox']
except KeyError:
Lbox = self._Lbox
else:
try:
Lbox = kwargs['Lbox']
except KeyError:
Lbox = self._Lbox
# calculate the radial vector between satellites and centrals
major_input_vectors, r = self.get_radial_vector(Lbox=Lbox, **kwargs)
# check for length 0 radial vectors
mask = (r <= 0.0) | (~np.isfinite(r))
if np.sum(mask) > 0:
major_input_vectors[mask, 0] = np.random.random((np.sum(mask)))
major_input_vectors[mask, 1] = np.random.random((np.sum(mask)))
major_input_vectors[mask, 2] = np.random.random((np.sum(mask)))
msg = (
'{0} galaxies have a radial distance equal to zero (or infinity) from their host. '
'These galaxies will be re-assigned random alignment vectors.'.
format(int(np.sum(mask))))
warn(msg)
# set prim_gal_axis orientation
theta_ma = self.misalignment_rvs(size=N)
# rotate alignment vector by theta_ma
ran_vecs = random_unit_vectors_3d(N)
mrot = rotation_matrices_from_angles(theta_ma, ran_vecs)
A_v = rotate_vector_collection(rotm, major_input_vectors)
# check for nan vectors
mask = (~np.isfinite(np.sum(np.prod(A_v, axis=-1))))
if np.sum(mask) > 0:
A_v[mask, 0] = np.random.random((np.sum(mask)))
A_v[mask, 1] = np.random.random((np.sum(mask)))
A_v[mask, 2] = np.random.random((np.sum(mask)))
msg = (
'{0} correlated alignment axis(axes) were not found to be not finite. '
'These will be re-assigned random vectors.'.format(
int(np.sum(mask))))
warn(msg)
# randomly set secondary axis orientation
B_v = random_perpendicular_directions(A_v)
# the tertiary axis is determined
C_v = vectors_normal_to_planes(A_v, B_v)
# use galaxy major axis as orientation axis
major_v = A_v
inter_v = B_v
minor_v = C_v
if 'table' in kwargs.keys():
try:
mask = (table['gal_type'] == self.gal_type)
except KeyError:
mask = np.array([True] * len(table))
msg = (
"`gal_type` not indicated in `table`.",
"The orientation is being assigned for all galaxies in the `table`."
)
print(msg)
# check to see if the columns exist
for key in list(self._galprop_dtypes_to_allocate.names):
if key not in table.keys():
table[key] = 0.0
# add orientations to the galaxy table
table['galaxy_axisA_x'][mask] = major_v[mask, 0]
table['galaxy_axisA_y'][mask] = major_v[mask, 1]
table['galaxy_axisA_z'][mask] = major_v[mask, 2]
table['galaxy_axisB_x'][mask] = inter_v[mask, 0]
table['galaxy_axisB_y'][mask] = inter_v[mask, 1]
table['galaxy_axisB_z'][mask] = inter_v[mask, 2]
table['galaxy_axisC_x'][mask] = minor_v[mask, 0]
table['galaxy_axisC_y'][mask] = minor_v[mask, 1]
table['galaxy_axisC_z'][mask] = minor_v[mask, 2]
return table
else:
return major_v, inter_v, minor_v