traj_planner.py

Documentation for the functions in route_planning.py.

agent_positions_to_MOOS_strings(agent_positions, num_agents, agent_index_dict, agent_tasks=None)[source]

Parses agent positions and tasks into string form to send to MOOS.

The final format of the output strings is “state1-state1:start_time-end_time:task1; state1-state2:start_time:end_time:None; …”

The task “None” specifies that the agent does not have a task. Note that all agents have the task “None” when traversing edges between states.

Parameters
  • agent_positions (list) – A list of lists containing the positions of each agent at each time step. The first index corresponds to time step, and the second index corresponds to agent number. For example, agent_positions[ii][jj] is the position of the jjth agent at time step ii. If agent jj is in a state at time ii, then agent_positions[ii][jj] is an integer corresponding to the state (e.g. 7 for state Q7). If agent jj is traversing an edge between states at time ii, then agent_positions[ii][jj] is a list with entries [state1, state2, time_duration] meaning it has time_duration steps to transfer from state1 to state2.

  • num_agents (int) – Number of agents in the network. TODO: This is redundant; we can compute this from agent_positions itself.

  • agent_index_dict (dict) – A dictionary mapping agent number to column index (second dimension index) in agent_positions. The ordering of agent numbers does not correspond to the column order; i.e. the iith agent does not correspond to the iith column in agent_positions. Instead, it corresponds to the agent_index_dict[ii] index in agent_positions.

  • agent_tasks (list) – A list of lists similar to agent_positions, but containing the task that each agent is doing at each time step. Work in progress; final format TBA.

Returns

A list of strings with the format specified previously.

Return type

(list)

create_random_tasks(agent_positions, agent_index_dict)[source]

Creates random tasks for agents. Placeholder function.

Task string options are:

  • NULL

  • LOITER

  • RASTER

  • DEFENSE

  • ESCORT

  • KILLCHAIN

  • BLOCKADE

All agents have have the task “NONE” when they are traversing an edge

Parameters
  • agent_positions (list) – A list of lists containing the positions of each agent at each time step. The first index corresponds to time step, and the second index corresponds to agent number. For example, agent_positions[ii][jj] is the position of the jjth agent at time step ii. If agent jj is in a state at time ii, then agent_positions[ii][jj] is an integer corresponding to the state (e.g. 7 for state Q7). If agent jj is traversing an edge between states at time ii, then agent_positions[ii][jj] is a list with entries [state1, state2, time_duration] meaning it has time_duration steps to transfer from state1 to state2.

  • agent_index_dict (dict) – A dictionary mapping agent number to column index in the agent_positions matrix. The column in agent_positions corresponding to agent ii is given by agent_index_dict[ii].

Returns

List of lists agent_tasks. The first dimension indexes time step, the second dimension indexes agent number. For example, agent_tasks[ii][jj] contains the task string for the jjth agent at time step ii (e.g. “BLOCKADE”).

Return type

(list)

expand_agent_positions(ts, agent_positions)[source]

Edits agent_positions in-place to reinsert removed states and edges. This is meant for use with reduce_ts in decomposition_functions.py, which removes unnecessary states and combines the edge weights.

This function takes agent paths described by agent positions and replaces edges with the expanded path by reinserting removed states and edges.

Example

q0 -weight:2-> q1 -weight:4-> q2

q1 was removed by reduce_ts

solution has q0-weight:6->q2

this function edits the solution to go through q1 again

Parameters
  • ts – the reduced TS

  • agent_positions – a numpy array where each row is a time and each column is an agent elements can be a state or an edge

get_agent_capabilities(states)[source]

Returns a list of agent capabilities.

The order of capabilities in the list corresponds to the columns in agent_positions, but does not correspond to the agent order in the casefile agent list.

randint(low, high=None, size=None, dtype=int)

Return random integers from low (inclusive) to high (exclusive).

Return random integers from the “discrete uniform” distribution of the specified dtype in the “half-open” interval [low, high). If high is None (the default), then results are from [0, low).

Note

New code should use the integers method of a default_rng() instance instead; please see the random-quick-start.

Parameters
  • low (int or array-like of ints) – Lowest (signed) integers to be drawn from the distribution (unless high=None, in which case this parameter is one above the highest such integer).

  • high (int or array-like of ints, optional) – If provided, one above the largest (signed) integer to be drawn from the distribution (see above for behavior if high=None). If array-like, must contain integer values

  • size (int or tuple of ints, optional) – Output shape. If the given shape is, e.g., (m, n, k), then m * n * k samples are drawn. Default is None, in which case a single value is returned.

  • dtype (dtype, optional) –

    Desired dtype of the result. Byteorder must be native. The default value is int.

    New in version 1.11.0.

Returns

outsize-shaped array of random integers from the appropriate distribution, or a single such random int if size not provided.

Return type

int or ndarray of ints

See also

random_integers

similar to randint, only for the closed interval [low, high], and 1 is the lowest value if high is omitted.

Generator.integers

which should be used for new code.

Examples

>>> np.random.randint(2, size=10)
array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0]) # random
>>> np.random.randint(1, size=10)
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

Generate a 2 x 4 array of ints between 0 and 4, inclusive:

>>> np.random.randint(5, size=(2, 4))
array([[4, 0, 2, 1], # random
       [3, 2, 2, 0]])

Generate a 1 x 3 array with 3 different upper bounds

>>> np.random.randint(1, [3, 5, 10])
array([2, 2, 9]) # random

Generate a 1 by 3 array with 3 different lower bounds

>>> np.random.randint([1, 5, 7], 10)
array([9, 8, 7]) # random

Generate a 2 by 4 array using broadcasting with dtype of uint8

>>> np.random.randint([1, 3, 5, 7], [[10], [20]], dtype=np.uint8)
array([[ 8,  6,  9,  7], # random
       [ 1, 16,  9, 12]], dtype=uint8)