Struct sim::mechanics::intersection::IntersectionSimState

pub(crate) struct IntersectionSimState {
    state: BTreeMap<IntersectionID, State>,
    use_freeform_policy_everywhere: bool,
    dont_block_the_box: bool,
    break_turn_conflict_cycles: bool,
    handle_uber_turns: bool,
    disable_turn_conflicts: bool,
    blocked_by: BTreeSet<(CarID, CarID)>,
    events: Vec<Event>,
    total_repeat_requests: usize,
    not_allowed_requests: usize,
    blocked_by_someone_requests: usize,
}

Manages conflicts at intersections. When an agent has reached the end of a lane, they call maybe_start_turn to make a Request. Based on the intersection type (stop sign, traffic signal, or a "freeform policy"), the Request gets queued or immediately accepted. When agents finish turns or when some time passes (for traffic signals), the intersection also gets a chance to react, maybe granting one of the pending requests.

Most of the complexity comes from attempting to workaround https://dabreegster.github.io/abstreet/trafficsim/gridlock.html.

Fields

state: BTreeMap<IntersectionID, State>

use_freeform_policy_everywhere: bool

dont_block_the_box: bool

break_turn_conflict_cycles: bool

handle_uber_turns: bool

disable_turn_conflicts: bool

blocked_by: BTreeSet<(CarID, CarID)>

events: Vec<Event>

total_repeat_requests: usize

not_allowed_requests: usize

blocked_by_someone_requests: usize

Implementations

impl IntersectionSimState

pub fn new(
    map: &Map,
    scheduler: &mut Scheduler,
    opts: &SimOptions
) -> IntersectionSimState

pub fn turn_finished(
    &mut self,
    now: Time,
    agent: AgentID,
    turn: TurnID,
    scheduler: &mut Scheduler,
    map: &Map,
    handling_live_edits: bool
)

pub fn cancel_request(&mut self, agent: AgentID, turn: TurnID)

For deleting cars

pub fn space_freed(
    &mut self,
    now: Time,
    i: IntersectionID,
    scheduler: &mut Scheduler,
    map: &Map
)

pub fn vehicle_gone(&mut self, car: CarID)

Vanished at border, stopped biking, etc -- a vehicle disappeared, and didn't have one last turn.

pub fn agent_deleted_mid_turn(&mut self, agent: AgentID, turn: TurnID)

fn wakeup_waiting(
    &self,
    now: Time,
    i: IntersectionID,
    scheduler: &mut Scheduler,
    map: &Map
)

pub fn update_intersection(
    &mut self,
    now: Time,
    id: IntersectionID,
    map: &Map,
    scheduler: &mut Scheduler
)

This is only triggered for traffic signals.

pub fn maybe_start_turn(
    &mut self,
    agent: AgentID,
    turn: TurnID,
    speed: Speed,
    now: Time,
    map: &Map,
    scheduler: &mut Scheduler,
    maybe_cars_and_queues: Option<(&Car, &FixedMap<CarID, Car>, &mut HashMap<Traversable, Queue>)>
) -> bool

For cars: The head car calls this when they're at the end of the lane WaitingToAdvance. If this returns true, then the head car MUST actually start this turn. For peds: Likewise -- only called when the ped is at the start of the turn. They must actually do the turn if this returns true.

If this returns false, the agent should NOT retry. IntersectionSimState will schedule a retry event at some point.

pub fn collect_events(&mut self) -> Vec<Event>

pub fn handle_live_edited_traffic_signals(
    &mut self,
    now: Time,
    map: &Map,
    scheduler: &mut Scheduler
)

pub fn handle_live_edits(&self, map: &Map)

impl IntersectionSimState

pub fn nobody_headed_towards(&self, lane: LaneID, i: IntersectionID) -> bool

pub fn debug(&self, id: IntersectionID, map: &Map)

pub fn get_accepted_agents(&self, id: IntersectionID) -> Vec<(AgentID, TurnID)>

pub fn get_waiting_agents(
    &self,
    id: IntersectionID
) -> Vec<(AgentID, TurnID, Time)>

pub fn delayed_intersections(
    &self,
    now: Time,
    threshold: Duration
) -> Vec<(IntersectionID, Time)>

Returns intersections with travelers waiting for at least threshold since now, ordered so the longest delayed intersection is first.

pub fn current_stage_and_remaining_time(
    &self,
    now: Time,
    i: IntersectionID
) -> (usize, Duration)

pub fn describe_stats(&self) -> Vec<String>

pub fn populate_blocked_by(
    &self,
    now: Time,
    graph: &mut BTreeMap<AgentID, (Duration, DelayCause)>,
    map: &Map,
    cars: &FixedMap<CarID, Car>,
    queues: &HashMap<Traversable, Queue>
)

fn check_for_conflicts_before_uber_turn(
    &self,
    ut: &UberTurn,
    map: &Map
) -> Option<AgentID>

See if any agent is currently performing a turn that conflicts with an uber-turn. Doesn't check for room on the queues.

impl IntersectionSimState

fn stop_sign_policy(
    &mut self,
    req: &Request,
    map: &Map,
    sign: &ControlStopSign,
    now: Time,
    scheduler: &mut Scheduler
) -> bool

fn traffic_signal_policy(
    &mut self,
    req: &Request,
    map: &Map,
    signal: &ControlTrafficSignal,
    speed: Speed,
    now: Time,
    scheduler: Option<&mut Scheduler>
) -> bool

fn handle_accepted_conflicts(
    &mut self,
    req: &Request,
    map: &Map,
    maybe_cars_and_queues: Option<(&FixedMap<CarID, Car>, &HashMap<Traversable, Queue>)>
) -> bool

fn detect_conflict_cycle(
    &self,
    car: CarID,
    pair: (&FixedMap<CarID, Car>, &HashMap<Traversable, Queue>)
) -> Option<HashSet<CarID>>

Trait Implementations

impl Clone for IntersectionSimState

fn clone(&self) -> IntersectionSimState

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for IntersectionSimState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for IntersectionSimState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.