def assign_orientation(self, **kwargs):
r"""
"""
if 'table' in kwargs.keys():
table = kwargs['table']
N = len(table)
else:
N = kwargs['size']
# assign random orientations
major_v = random_unit_vectors_3d(N)
inter_v = random_perpendicular_directions(major_v)
minor_v = normalized_vectors(np.cross(major_v, inter_v))
if 'table' in kwargs.keys():
try:
mask = (table['gal_type'] == self.gal_type)
except KeyError:
mask = np.array([True] * N)
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
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_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
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))
N_bad_axes = np.sum(mask)
if N_bad_axes > 0:
major_input_vectors[mask, :] = random_unit_vectors_3d(N_bad_axes)
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(N_bad_axes)))
warn(msg)
# get alignment strength for each galaxy
if 'table' in kwargs.keys():
try:
p = table['satellite_alignment_strength']
except KeyError:
msg = (
'`satellite_alignment_strength` key not detected in `table`.'
'The value set in self.param_dict of this class will be used instead.'
)
warn(msg)
p = np.ones(len(
table)) * self.param_dict['satellite_alignment_strength']
else:
N = len(self.param_dict['x'])
p = np.ones(N * self.param_dict['satellite_alignment_strength'])
# set prim_gal_axis orientation
A_v = axes_correlated_with_input_vector(major_input_vectors, p=p)
# check for nan vectors
mask = (~np.isfinite(np.sum(np.prod(A_v, axis=-1))))
N_bad_axes = np.sum(mask)
if N_bad_axes > 0:
A_v[mask, :] = random_unit_vectors_3d(N_bad_axes)
msg = (
'{0} correlated alignment axis(axes) were found to be not finite. '
'These will be re-assigned random vectors.'.format(
int(N_bad_axes)))
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)
# 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
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
def assign_satellite_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['halo_axisA_x']
Ay = kwargs['halo_axisA_y']
Az = kwargs['halo_axisA_z']
# get alignment strength for each galaxy
if 'table' in kwargs.keys():
try:
p = table['satellite_alignment_strength']
except KeyError:
msg = (
'`satellite_alignment_strength` not detected in the table, using value in self.param_dict.'
)
warn(msg)
p = np.ones(
len(Ax)) * self.param_dict['satellite_alignment_strength']
else:
p = np.ones(
len(Ax)) * self.param_dict['satellite_alignment_strength']
# set prim_gal_axis orientation
major_input_vectors = np.vstack((Ax, Ay, Az)).T
A_v = axes_correlated_with_input_vector(major_input_vectors, p=p)
# 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_orientation(self, **kwargs):
r"""
assign a a set of three orthoganl unit vectors indicating the orientation
of the galaxies' major, intermediate, and minor axis
"""
if 'table' in kwargs.keys():
table = kwargs['table']
halo_x = table['halo_x']
halo_y = table['halo_y']
halo_z = table['halo_z']
Ax = table[self.list_of_haloprops_needed[3]]
Ay = table[self.list_of_haloprops_needed[4]]
Az = table[self.list_of_haloprops_needed[5]]
halo_r = table['halo_rvir']
Lbox = self._Lbox
else:
halo_x = kwargs['halo_x']
halo_y = kwargs['halo_y']
halo_z = kwargs['halo_z']
Ax = kwargs['halo_axisA_x']
Ay = kwargs['halo_axisA_y']
Az = kwargs['halo_axisA_z']
halo_r = kwargs['halo_rvir']
Lbox = kwargs['Lbox']
Ngal = len(Ax)
# define halo-center - satellite vector
dx = (x - halo_x)
mask = dx > Lbox[0] / 2.0
dx[mask] = dx[mask] - Lbox[0]
mask = dx < -1.0 * Lbox[0] / 2.0
dx[mask] = dx[mask] + Lbox[0]
dy = (y - halo_y)
mask = dy > Lbox[1] / 2.0
dy[mask] = dy[mask] - Lbox[1]
mask = dy < -1.0 * Lbox[1] / 2.0
dy[mask] = dy[mask] + Lbox[1]
dz = (z - halo_z)
mask = dz > Lbox[2] / 2.0
dz[mask] = dz[mask] - Lbox[2]
mask = dz < -1.0 * Lbox[2] / 2.0
dz[mask] = dz[mask] + Lbox[2]
# radial vector
v1 = normalized_vectors(np.vstack((dx, dy, dz)).T)
# major axis orientation
v2 = normalized_vectors(np.vstack((Ax, Ay, Az)).T)
# account for handedness by randomly flipping alignment components
seed = kwargs.get('seed', None)
with NumpyRNGContext(seed):
uran1 = np.random.random(Ngal)
if seed is not None:
seed = seed + 1
with NumpyRNGContext(seed):
uran2 = np.random.random(Ngal)
flip1 = np.ones(Ngal)
flip1[uran1 < 0.5] = -1.0
flip2 = np.ones(Ngal)
flip2[uran2 < 0.5] = -1.0
v1 = flip1[:, np.newaxis] * v1
v2 = flip2[:, np.newaxis] * v2
# calculate scaled halo virial radius
r = np.sqrt(dx**2 + dy**2 + dz**2) / halo_r
# get alignment strength for each galaxy
if 'table' in kwargs.keys():
try:
p = table['satellite_alignment_strength']
except KeyError:
msg = (
'`satellite_alignment_strength` not detected in the table, using value in self.param_dict.'
)
warn(msg)
p = np.ones(len(
table)) * self.param_dict['satellite_alignment_strength']
else:
N = len(self.param_dict['x'])
p = np.ones(N * self.param_dict['satellite_alignment_strength'])
# get major to radial parameter
a = self.radial_hybrid_alignment_vector_parameter(r)
# define alignment vector inbetween v1 and v2
v3 = normalized_vectors(vectors_between_list_of_vectors(v1, v2, a))
# get galaxy major axis
major_v = axes_correlated_with_input_vector(v3, p=p)
# randomly set minor axis orientation
minor_v = random_perpendicular_directions(major_v)
# the intermediate axis is determined
inter_v = vectors_normal_to_planes(major_v, minor_v)
mask = (table['gal_type'] == self.gal_type)
# 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
def assign_orientation(self, **kwargs):
r"""
assign a a set of three orthoganl unit vectors indicating the orientation
of the galaxies' major, intermediate, and minor axis
"""
if 'table' in kwargs.keys():
table = kwargs['table']
halo_x = table['halo_x']
halo_y = table['halo_y']
halo_z = table['halo_z']
Ax = table[self.list_of_haloprops_needed[3]]
Ay = table[self.list_of_haloprops_needed[4]]
Az = table[self.list_of_haloprops_needed[5]]
else:
halo_x = kwargs['halo_x']
halo_y = kwargs['halo_y']
halo_z = kwargs['halo_z']
Ax = kwargs['halo_axisA_x']
Ay = kwargs['halo_axisA_y']
Az = kwargs['halo_axisA_z']
# get alignment strength for each galaxy
if 'table' in kwargs.keys():
try:
p = table['satellite_alignment_strength']
except KeyError:
msg = (
'`satellite_alignment_strength` not detected in the table, using value in self.param_dict.'
)
warn(msg)
p = np.ones(len(
table)) * self.param_dict['satellite_alignment_strength']
else:
N = len(self.param_dict['x'])
p = np.ones(N * self.param_dict['satellite_alignment_strength'])
# set halo alignment vector
major_input_vectors = np.vstack((Ax, Ay, Az)).T
# set prim_gal_axis orientation
A_v = axes_correlated_with_input_vector(major_input_vectors, p=p)
# 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
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)
# 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