def test_deviation_angle(self, input_df, expected_angle):
"""Verifies the deviation angle function in three different cases"""
input_df["relative_angle"] = AgentMovement.vector_angles(
input_df, ["x_relative", "y_relative"])
angle = AgentMovement.deviation_angle(input_df)
assert round(angle, 12) == round(expected_angle, 12)
def test_update_velocities_group_field_and_indexes_not_None(
self, fixture_update_velocities):
"""
Comparison of the angles of the agents after applying update
velocities through a Kolmogorov-smirnov test. `indexes` and
`group_field` are set not None.
"""
distribution = pytest.distrib
sample_indexes = 500
delta_angles = pytest.delta_angles
df = DataFrame(pytest.data_large_sample)
df["mobility_profile"] = "MG_1"
mobility_group_slice = 300
df.loc[0:mobility_group_slice - 1, "mobility_profile"] = "MG_2"
angles_before = AgentMovement.vector_angles(df, ['vx', 'vy'])
indexes = [i for i in range(sample_indexes + 1)]
df = AgentMovement.update_velocities(df, distribution,
pytest.angle_variance, indexes,
"mobility_profile", "MG_2")
angles_after = AgentMovement.vector_angles(df, ['vx', 'vy'])
angle_variation_1 = angles_after[:mobility_group_slice] - \
angles_before[:mobility_group_slice]
k, p_1 = kstest(angle_variation_1.values, delta_angles)
angle_variation_2 = angles_after[mobility_group_slice:] - \
angles_before[mobility_group_slice:]
k, p_2 = kstest(angle_variation_2.values, delta_angles)
cond_1 = True if p_1 > 0.05 else False
cond_2 = True if p_2 < 0.05 else False
assert cond_1 and cond_2
def test_movement_function_field_existence(self, fixture_raise_errors):
"""
Raises an exception when the input DataFrame does not have any of
the columns: 'x', 'y', 'vx' and 'vy'.
"""
df = DataFrame(pytest.data_without_x)
with pytest.raises(KeyError):
AgentMovement.move_agents(df, pytest.box_size, pytest.dt)
def test_stop_agents_raise_ValueError(self, fixture_stop_agents,
fixture_raise_errors):
"""
Raises an exception when the input DataFrame columns `vx` or `vy`
does not exist.
"""
df = DataFrame(pytest.data_wrong_name_columns)
with pytest.raises(ValueError):
AgentMovement.stop_agents(df, pytest.list_index_stopped)
def test_set_velocities_raise_error(self, fixture_set_velocities):
"""
Raises a ValueError when `vy` column is not in the input
DataFrame.
"""
distribution = fixture_set_velocities[0]
df = DataFrame({"vx": [1, 2, 0, -1, -1]})
with pytest.raises(ValueError):
AgentMovement.set_velocities(df, distribution, 0.1)
def test_initialize_velocities_ValueError_indexes_and_group_field_are_None(
self, fixture_initialize_velocities):
"""
Raises a ValueError when `vx` column is not in the input DataFrame,
`indexes` and `group_field` are None.
"""
distribution = fixture_initialize_velocities[0]
angle_dist = fixture_initialize_velocities[1]
df = DataFrame({"vx": random.randint(9, size=9)})
with pytest.raises(ValueError):
AgentMovement.initialize_velocities(df, distribution, angle_dist)
def test_initialize_velocities_only_indexes_is_not_None(
self, fixture_initialize_velocities):
"""
Verifies whether `initialize_velocities` does not applies
`set_velocities` when `group_label` is not in `group_field` column.
"""
distribution = fixture_initialize_velocities[2]
angle_dist = fixture_initialize_velocities[3]
indexes = fixture_initialize_velocities[4]
input_df = DataFrame({
"vx":
random.randint(9, size=9),
"vy":
random.randint(9, size=9),
"mobility_group": [
"MG_1", "MG_1", "MG_1", "MG_2", "MG_2", "MG_2", "MG_2", "MG_2",
"MG_2"
]
})
df = AgentMovement.initialize_velocities(input_df, distribution,
angle_dist, indexes, None,
None)
assert all(df["vx"][:5] == 1) & all(df["vy"][:5] == 0)
assert all(input_df["vx"][5:] == df["vx"][5:]) & all(
input_df["vy"][5:] == df["vy"][5:])
def test_initialize_velocities_preserve_dtypes_dict(
self, fixture_initialize_velocities):
"""
Verifies whether `initialize_velocities` set the data types when
a `preserve_dtypes_dict` is passed.
"""
angle_dist = fixture_initialize_velocities[3]
distribution = fixture_initialize_velocities[2]
indexes = fixture_initialize_velocities[4]
input_df = DataFrame({
"vx":
random.randint(9, size=9),
"vy":
random.randint(9, size=9),
"mobility_group": [
"MG_1", "MG_1", "MG_1", "MG_2", "MG_2", "MG_2", "MG_2", "MG_2",
"MG_2"
]
})
preserve_dtypes_dict = {"vx": str, "vy": str}
df = AgentMovement.initialize_velocities(input_df, distribution,
angle_dist, indexes,
"mobility_group", "MG_1",
preserve_dtypes_dict)
assert all(df["vx"].apply(lambda vx: isinstance(vx, str)))
assert all(df["vy"].apply(lambda vy: isinstance(vy, str)))
def test_initialize_velocities_group_label_is_not_in_group_field(
self, fixture_initialize_velocities):
"""
Verifies whether `initialize_velocities` does not applies
`set_velocities` when `group_label` is not in `group_field`.
"""
angle_dist = fixture_initialize_velocities[3]
distribution = fixture_initialize_velocities[2]
indexes = fixture_initialize_velocities[4]
input_df = DataFrame({
"vx":
random.randint(9, size=9),
"vy":
random.randint(9, size=9),
"mobility_group": [
"MG_1", "MG_1", "MG_1", "MG_2", "MG_2", "MG_2", "MG_2", "MG_2",
"MG_2"
]
})
df = AgentMovement.initialize_velocities(input_df, distribution,
angle_dist, indexes,
"mobility_group", "MG_3")
assert all(input_df["vx"][:].eq(df["vx"][:])) & all(
input_df["vy"][:].eq(df["vy"][:]))
def test_initialize_velocities_indexes_is_empty(
self, fixture_initialize_velocities):
"""
Verifies whether `initialize_velocities` does not applies
`set_velocities` when `indexes` is an empty list.
"""
angle_dist = fixture_initialize_velocities[3]
distribution = fixture_initialize_velocities[2]
input_df = DataFrame({
"vx":
random.randint(9, size=9),
"vy":
random.randint(9, size=9),
"mobility_group": [
"MG_1", "MG_1", "MG_1", "MG_2", "MG_2", "MG_2", "MG_2", "MG_2",
"MG_2"
]
})
indexes = []
df = AgentMovement.initialize_velocities(input_df, distribution,
angle_dist, indexes,
"mobility_group", "MG_1")
assert all(input_df["vx"][:] == df["vx"][:]) & all(
input_df["vy"][:] == df["vy"][:])
def test_initialize_velocities_indexes_and_group_field_not_None_two_groups(
self, fixture_initialize_velocities):
"""
Verifies whether `initialize_velocities` applies `set_velocities` only
to the agents in the indexes list passed and in the `group_field`
specified.
"""
angle_dist = fixture_initialize_velocities[3]
distribution = fixture_initialize_velocities[2]
indexes = fixture_initialize_velocities[4]
input_df = DataFrame({
"vx":
random.randint(9, size=9),
"vy":
random.randint(9, size=9),
"mobility_group": [
"MG_1", "MG_1", "MG_1", "MG_2", "MG_2", "MG_2", "MG_2", "MG_2",
"MG_2"
]
})
df = AgentMovement.initialize_velocities(input_df, distribution,
angle_dist, indexes,
"mobility_group", "MG_1")
assert all(df["vx"][0:3] == 1) & all(df["vy"][0:3] == 0)
assert all(input_df["vx"][3:] == df["vx"][3:]) & all(
input_df["vy"][3:] == df["vy"][3:])
def test_stop_agents(self, fixture_stop_agents):
"""Stops agent movement with a correct list of index."""
df = DataFrame(pytest.data)
df = AgentMovement.stop_agents(df, pytest.list_index_stopped)
for i in range(len(pytest.list_index_stopped)):
assert df['vx'][i] == df['vy'][i] == 0
def test_crash_with_boundary_wall_(self, fixture_crash_with_wall):
"""Crash of one agent with each of the four box boundary wall."""
df = DataFrame(pytest.data)
df = AgentMovement.move_agents(df, pytest.box_size, pytest.dt)
expected_df = DataFrame(pytest.expected_data)
assert all(df == expected_df)
def test_angle(self, x, y, expected_angle):
"""
Verifies the standardized angle returned by the angle method
of the agents with position components `x` and `y`.
"""
angles = AgentMovement.angle(x, y)
assert round(angles, decimals=10) == round(expected_angle, decimals=10)
def test_update_velocities_angle_variance_zero_indexes_group_field_None(
self, fixture_update_velocities):
"""
Verifies whether there are no changes in the velocities components when
the standard deviation of the numpy normal distribution is set to zero
`angle_variance=0.0`. `indexes` and `group_field` is se to None.
"""
df = DataFrame(pytest.data_large_sample)
angles_before = AgentMovement.vector_angles(df, ['vx', 'vy'])
df = AgentMovement.update_velocities(df, pytest.distrib, 0.0)
angles_after = AgentMovement.vector_angles(df, ['vx', 'vy'])
not_angle_variation = all(
round(angles_before.head() - angles_after.head(), 7))
assert not_angle_variation == 0
def test_initialize_velocities_ValueError_indexes_and_group_field_not_None(
self, fixture_initialize_velocities):
"""
Raises a ValueError when `vx` column is not in the input DataFrame,
`indexes` and `group_field` are not None.
"""
distribution = fixture_initialize_velocities[0]
angle_dist = fixture_initialize_velocities[1]
df = DataFrame({
"vy": random.randint(9, size=9),
"mobility_group": ["MG_1" for i in range(9)]
})
with pytest.raises(ValueError):
AgentMovement.initialize_velocities(df, distribution, angle_dist,
"mobility_group", "MG_1")
def test_vector_angles(self, input_df, expected_angle):
"""
Calculates the angle position of the agents with components
`x` and `y` of the input DataFrame.
"""
angle = AgentMovement.vector_angles(input_df, ['x', 'y'])
assert round(angle[0], decimals=10) == \
round(expected_angle, decimals=10)
def test_update_velocities_comparison_KS_test(self,
fixture_update_velocities):
"""
Comparison of the angles of the agents after applying update
velocities through a Kolmogorov-smirnov test. `indexes` and
`group_field` are set to None.
"""
df = DataFrame(pytest.data_large_sample)
angles_before = AgentMovement.vector_angles(df, ['vx', 'vy'])
df = AgentMovement.update_velocities(df, pytest.distrib,
pytest.angle_variance)
angles_after = AgentMovement.vector_angles(df, ['vx', 'vy'])
angle_variation = angles_after - angles_before
k, p = kstest(angle_variation.values, pytest.delta_angles)
cond = True if p > 0.05 else False
assert cond
def test_avoid_agents_one_avoids_two(self,
fixture_avoid_agents_same_rel_angles):
"""One agent avoids two agents with the same relative angles."""
df = DataFrame(pytest.data)
df_to_avoid = DataFrame(pytest.data_avoid)
df = AgentMovement.avoid_agents(df, df_to_avoid)
expected_angle = 5 * pi / 4
assert round(df.vx[0], 12) == round(cos(expected_angle), 12)
assert round(df.vy[0], 12) == round(sin(expected_angle), 12)
def test_avoid_agents_raise_error(self, fixture_avoid_agents_raise_error):
"""
Raises an exception when the input DataFrame column `agent`
does not exist.
"""
df = DataFrame(pytest.data_without_agent)
df_to_avoid = DataFrame(pytest.data_avoid)
with pytest.raises(ValueError):
assert AgentMovement.avoid_agents(df, df_to_avoid)
def test_avoid_agents_one_avoids_four_in_each_axis(
self, fixture_avoid_agents_one_avoids_four_in_each_axis):
"""One agent avoids four agents in each axis."""
df = DataFrame(pytest.data)
df_to_avoid = DataFrame(pytest.data_avoid)
df = AgentMovement.avoid_agents(df, df_to_avoid)
expected_angle = pi / 4
assert round(abs(df.vx[0]), 12) == round(cos(expected_angle), 12)
assert round(abs(df.vy[0]), 12) == round(sin(expected_angle), 12)
def test_update_velocities_under_field_indexes_None(
self, fixture_update_velocities):
"""Updates velocities only for a group of agents under a field."""
df = DataFrame(pytest.data_field)
df = AgentMovement.update_velocities(df, pytest.distrib,
pytest.angle_variance_field, None,
"field", "field_1")
velocities_field_vx = df.loc[1, 'vx'] != 2.0
velocities_field_vy = df.loc[1, 'vy'] != 2.0
assert velocities_field_vx and velocities_field_vy
def test_update_velocities_raise_error_indexes_and_group_field_None(
self, fixture_update_velocities):
"""
Raises an exception when the input DataFrame columns `vx` and `vy`
does not exist. `indexes` and `group_field` is se to None.
"""
df = DataFrame(pytest.data_wrong_name_columns)
with pytest.raises(ValueError):
assert AgentMovement.update_velocities(df, pytest.distrib,
pytest.angle_variance)
def test_avoid_agents_two_avoid_one_different_rel_angles(
self, fixture_avoid_agents_different_rel_angles):
"""Two agents avoid one agent with different relative angles."""
df = DataFrame(pytest.data)
df_to_avoid = DataFrame(pytest.data_avoid)
df = AgentMovement.avoid_agents(df, df_to_avoid)
expected_angles = [3 * pi / 2, 7 * pi / 4]
for i in range(len(expected_angles)):
assert round(df.vx[i], 12) == round(cos(expected_angles[i]), 12)
assert round(df.vy[i], 12) == round(sin(expected_angles[i]), 12)
def test_avoid_agents_two_avoid_one(
self, fixture_avoid_agents_two_agents_avoid_one):
"""Two agents avoid one agent with the same relative angle."""
df = DataFrame(pytest.data)
df_to_avoid = DataFrame(pytest.data_avoid)
df = AgentMovement.avoid_agents(df, df_to_avoid)
expected_angles = [pi / 2, pi / 2]
for i in range(len(expected_angles)):
assert round(df.vx[i], 12) == round(cos(expected_angles[i]), 12)
assert round(df.vy[i], 12) == round(sin(expected_angles[i]), 12)
def test_vector_angles_raise_error_correct_list(
self, fixture_vector_angles_raise_error):
"""
Raises an exception when the input DataFrame columns are not in the
list, `vx` and `vy` in this case.
"""
df = DataFrame(pytest.wrong_data)
correct_list = pytest.correct_list
with pytest.raises(ValueError):
assert AgentMovement.vector_angles(df, correct_list)
def test_vector_angles_raise_error_wrong_list(
self, fixture_vector_angles_raise_error):
"""
Raises an exception when the input list does not have correct columns
names, `vx` and `vy` in this case.
"""
df = DataFrame(pytest.data)
wrong_list = pytest.wrong_list
with pytest.raises(ValueError):
assert AgentMovement.vector_angles(df, wrong_list)
def test_avoid_agents_one_avoids_two_different_rel_angles(
self, fixture_avoid_agents_one_avoids_two):
"""
One agent avoids two agents with different relative angles."""
df = DataFrame(pytest.data)
df_to_avoid = DataFrame(pytest.data_avoid)
new_df = AgentMovement.avoid_agents(df, df_to_avoid)
condition = round(new_df.vx[new_df.agent == 1][0] - -1.0, 7) == round(
new_df.vy[new_df.agent == 1][0] - 0, 7) == 0
assert condition
def test_set_velocities(self, fixture_set_velocities):
"""
Verifies whether set_velocities method assigns correctly new
velocities to the agents of a DataFrame, using a constant distribution
for the norm of the velocities and a None `angle_distribution`.
"""
distribution = fixture_set_velocities[0]
df = DataFrame({"vx": [1, 2, 0, -1, -1], "vy": [0, 2, 1, 0, 1]})
df = AgentMovement.set_velocities(df, distribution, 0.1)
expected_df = DataFrame({"vx": pytest.vx, "vy": pytest.vy})
assert all(round(df, 10) == round(expected_df, 10))
def test_replace_velocities_norm_equal_zero(
self, fixture_replace_velocities_norm_equal_to_zero):
"""
Verifies the replace velocity function when one agent has its
velocity norm equal to zero.
"""
new_angle = Series(pytest.new_angle)
df = DataFrame(pytest.data)
df = df.apply(
lambda row: AgentMovement.replace_velocities(row, new_angle),
axis=1)
assert df.vx[0] == df.vy[0] == 0