Exemple #1
0
    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)
Exemple #2
0
    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:])
Exemple #3
0
    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)))
Exemple #4
0
    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"][:]))
Exemple #5
0
    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"][:])
Exemple #6
0
    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:])
Exemple #7
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")
Exemple #8
0
    def test_initialize_velocities_raise_error_no_group_field(
            self, fixture_initialize_velocities):
        """
        Raises a ValueError when `group_field` column is not in the input
        DataFrame.
        """
        distribution = fixture_initialize_velocities[0]
        angle_dist = fixture_initialize_velocities[1]

        df = DataFrame({
            "vx": random.randint(9, size=9),
            "vy": random.randint(9, size=9)
        })

        with pytest.raises(ValueError):
            assert AgentMovement.initialize_velocities(df, distribution,
                                                       angle_dist, None,
                                                       "mobility_group")
Exemple #9
0
    def test_initialize_velocities_angle_distribution_constant(
            self, fixture_initialize_velocities):
        """
        Verifies whether `vx` and `vy` agent velocities components are the same
        when the `angle_distribution` is set to constant with the constant
        equals to pi/4 for all the agents.
        """
        distribution = fixture_initialize_velocities[0]
        angle_dist = fixture_initialize_velocities[1]

        df = DataFrame({
            "vx": random.randint(9, size=9),
            "vy": random.randint(9, size=9)
        })
        df = AgentMovement.initialize_velocities(df, distribution, angle_dist,
                                                 None, None, None)

        assert all(round(df["vx"], 12) == round(df["vy"], 12))
Exemple #10
0
    def test_initialize_velocities_indexes_not_None_group_field_not_in_df(
            self, fixture_initialize_velocities):
        """
        Verifies whether `initialize_velocities` returns unaltered df when
        `group_field` passed is not in the input DataFrame.
        """
        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_2" for i in range(9)]
        })
        df = AgentMovement.initialize_velocities(input_df, distribution,
                                                 angle_dist, None,
                                                 "mobility_group", "MG_1")

        assert all(input_df["vx"][:] == df["vx"][:]) & all(
            input_df["vy"][:] == df["vy"][:])