Struct sim::Sim

pub struct Sim {
    driving: DrivingSimState,
    parking: ParkingSimState,
    walking: WalkingSimState,
    intersections: IntersectionSimState,
    transit: TransitSimState,
    cap: CapSimState,
    trips: TripManager,
    pandemic: Option<PandemicModel>,
    scheduler: Scheduler,
    time: Time,
    pub(crate) map_name: MapName,
    pub(crate) edits_name: String,
    run_name: String,
    step_count: usize,
    analytics: Analytics,
    recorder: Option<TrafficRecorder>,
    alerts: AlertHandler,
}

The Sim ties together all the pieces of the simulation. Its main property is the current time.

Fields

driving: DrivingSimState

parking: ParkingSimState

walking: WalkingSimState

intersections: IntersectionSimState

transit: TransitSimState

cap: CapSimState

trips: TripManager

pandemic: Option<PandemicModel>

scheduler: Scheduler

time: Time

map_name: MapName

edits_name: String

run_name: String

step_count: usize

analytics: Analytics

recorder: Option<TrafficRecorder>

alerts: AlertHandler

Implementations

impl Sim

pub fn time(&self) -> Time

pub fn is_done(&self) -> bool

pub fn is_empty(&self) -> bool

pub fn num_trips(&self) -> (usize, usize)

(number of finished trips, number of unfinished trips)

pub fn num_agents(&self) -> Counter<AgentType>

pub fn num_commuters_vehicles(&self) -> CommutersVehiclesCounts

pub fn num_ppl(&self) -> (usize, usize, usize)

(total number of people, just in buildings, just off map)

pub fn debug_ped(&self, id: PedestrianID)

pub fn debug_car(&self, id: CarID)

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

pub fn debug_lane(&self, id: LaneID)

pub fn agent_properties(&self, id: AgentID) -> AgentProperties

Only call for active agents, will panic otherwise

pub fn num_transit_passengers(&self, car: CarID) -> usize

pub fn bus_route_id(&self, maybe_bus: CarID) -> Option<BusRouteID>

pub fn active_agents(&self) -> Vec<AgentID>

pub fn num_active_agents(&self) -> usize

pub fn agent_to_trip(&self, id: AgentID) -> Option<TripID>

pub fn trip_to_agent(&self, id: TripID) -> TripResult<AgentID>

pub fn trip_info(&self, id: TripID) -> TripInfo

pub fn all_trip_info(&self) -> Vec<(TripID, TripInfo)>

pub fn finished_trip_details(
    &self,
    id: TripID
) -> Option<(Duration, Duration, Distance)>

If trip is finished, returns (total time, total waiting time, total distance)

pub fn trip_blocked_time(&self, id: TripID) -> Duration

pub fn trip_to_person(&self, id: TripID) -> PersonID

pub fn agent_to_person(&self, id: AgentID) -> Option<PersonID>

pub fn person_to_agent(&self, id: PersonID) -> Option<AgentID>

pub fn get_owner_of_car(&self, id: CarID) -> Option<PersonID>

pub fn lookup_parked_car(&self, id: CarID) -> Option<&ParkedCar>

pub fn all_parked_car_positions(&self, map: &Map) -> Vec<(Position, Position)>

For every parked car, (position of parking spot, position of owner)

pub fn lookup_person(&self, id: PersonID) -> Option<&Person>

pub fn get_person(&self, id: PersonID) -> &Person

pub fn find_person_by_orig_id(&self, id: OrigPersonID) -> Option<PersonID>

pub fn get_all_people(&self) -> &Vec<Person>

pub fn lookup_car_id(&self, idx: usize) -> Option<CarID>

pub fn get_path(&self, id: AgentID) -> Option<&Path>

pub fn get_all_driving_paths(&self) -> Vec<&Path>

pub fn trace_route(
    &self,
    id: AgentID,
    map: &Map,
    dist_ahead: Option<Distance>
) -> Option<PolyLine>

pub fn get_canonical_pt_per_trip(
    &self,
    trip: TripID,
    map: &Map
) -> TripResult<Pt2D>

pub fn get_canonical_pt_per_person(
    &self,
    p: PersonID,
    map: &Map
) -> Option<Pt2D>

pub fn canonical_pt_for_agent(&self, id: AgentID, map: &Map) -> Option<Pt2D>

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 get_blocked_by(&self, a: AgentID) -> HashSet<AgentID>

pub fn get_blocked_by_graph(
    &self,
    map: &Map
) -> BTreeMap<AgentID, (Duration, DelayCause)>

For every agent that's currently not moving, figure out how long they've been waiting and why they're blocked.

pub fn status_of_buses(
    &self,
    route: BusRouteID,
    map: &Map
) -> Vec<(CarID, Option<usize>, f64, Pt2D)>

(bus, stop index it's coming from, percent to next stop, location)

pub fn get_analytics(&self) -> &Analytics

pub fn find_blockage_front(&self, car: CarID, map: &Map) -> String

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

For intersections with an agent waiting beyond some threshold, return when they started waiting. Sorted by earliest waiting (likely the root cause of gridlock).

pub fn bldg_to_people(&self, b: BuildingID) -> Vec<PersonID>

pub fn get_pandemic_model(&self) -> Option<&PandemicModel>

pub fn get_end_of_day(&self) -> Time

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

pub fn all_arrivals_at_border(
    &self,
    i: IntersectionID
) -> Vec<(AgentType, Vec<(Time, usize)>)>

pub fn target_lane_penalty(&self, lane: &Lane) -> (usize, usize)

(number of vehicles in the lane, penalty if a bike or other slow vehicle is present)

pub fn get_people_waiting_at_stop(
    &self,
    at: BusStopID
) -> &Vec<(PedestrianID, BusRouteID, Option<BusStopID>, Time)>

pub fn generate_scenario(&self, map: &Map, name: String) -> Scenario

pub fn get_cap_counter(&self, l: LaneID) -> usize

pub fn infinite_parking(&self) -> bool

pub fn all_waiting_people(&self) -> BTreeMap<PersonID, Duration>

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

pub fn debug_queue_lengths(&self, l: LaneID) -> Option<(Distance, Distance)>

impl Sim

pub fn step_count(&self) -> usize

pub fn get_draw_car(&self, id: CarID, map: &Map) -> Option<DrawCarInput>

pub fn get_draw_ped(
    &self,
    id: PedestrianID,
    map: &Map
) -> Option<DrawPedestrianInput>

pub fn get_draw_cars(&self, on: Traversable, map: &Map) -> Vec<DrawCarInput>

pub fn get_draw_peds(
    &self,
    on: Traversable,
    map: &Map
) -> (Vec<DrawPedestrianInput>, Vec<DrawPedCrowdInput>)

pub fn get_all_draw_cars(&self, map: &Map) -> Vec<DrawCarInput>

pub fn get_all_draw_peds(&self, map: &Map) -> Vec<DrawPedestrianInput>

pub fn get_unzoomed_agents(&self, map: &Map) -> Vec<UnzoomedAgent>

impl Sim

pub fn new(map: &Map, opts: SimOptions, timer: &mut Timer<'_>) -> Sim

pub(crate) fn spawn_trips(
    &mut self,
    input: Vec<(PersonID, TripInfo, TripSpec, Vec<TripLeg>)>,
    map: &Map,
    timer: &mut Timer<'_>
)

pub fn get_free_onstreet_spots(&self, l: LaneID) -> Vec<ParkingSpot>

pub fn get_free_offstreet_spots(&self, b: BuildingID) -> Vec<ParkingSpot>

pub fn get_free_lot_spots(&self, pl: ParkingLotID) -> Vec<ParkingSpot>

pub fn get_all_parking_spots(&self) -> (Vec<ParkingSpot>, Vec<ParkingSpot>)

(Filled, available)

pub fn bldg_to_parked_cars(&self, b: BuildingID) -> Vec<CarID>

pub fn walking_path_to_nearest_parking_spot(
    &self,
    map: &Map,
    b: BuildingID
) -> Option<(Path, Distance)>

Also returns the start distance of the building. TODO Do that in the Path properly.

pub(crate) fn new_person(
    &mut self,
    orig_id: Option<OrigPersonID>,
    ped_speed: Speed,
    vehicle_specs: Vec<VehicleSpec>
) -> &Person

pub(crate) fn seed_parked_car(&mut self, vehicle: Vehicle, spot: ParkingSpot)

pub(crate) fn seed_bus_route(&mut self, route: &BusRoute)

fn start_bus(&mut self, route: &BusRoute, map: &Map)

pub fn set_name(&mut self, name: String)

impl Sim

fn minimal_step(
    &mut self,
    map: &Map,
    max_dt: Duration,
    maybe_cb: &mut Option<Box<dyn SimCallback>>
) -> bool

fn do_step(
    &mut self,
    map: &Map,
    time: Time,
    cmd: Command,
    maybe_cb: &mut Option<Box<dyn SimCallback>>
) -> bool

fn dispatch_events(&mut self, events: Vec<Event>, map: &Map)

pub fn timed_step(
    &mut self,
    map: &Map,
    dt: Duration,
    maybe_cb: &mut Option<Box<dyn SimCallback>>,
    timer: &mut Timer<'_>
)

pub fn tiny_step(
    &mut self,
    map: &Map,
    maybe_cb: &mut Option<Box<dyn SimCallback>>
)

pub fn time_limited_step(
    &mut self,
    map: &Map,
    dt: Duration,
    real_time_limit: Duration,
    maybe_cb: &mut Option<Box<dyn SimCallback>>
)

pub fn dump_before_abort(&self)

impl Sim

pub fn save_dir(&self) -> String

fn save_path(&self, base_time: Time) -> String

pub fn save(&mut self) -> String

pub fn find_previous_savestate(&self, base_time: Time) -> Option<String>

pub fn find_next_savestate(&self, base_time: Time) -> Option<String>

pub fn load_savestate(
    path: String,
    map: &Map,
    timer: &mut Timer<'_>
) -> Result<Sim, Box<dyn Error>>

pub fn restore_paths(&mut self, map: &Map, timer: &mut Timer<'_>)

impl Sim

pub fn handle_live_edited_traffic_signals(&mut self, map: &Map)

pub fn handle_live_edits(&mut self, map: &Map) -> (usize, usize)

Respond to arbitrary map edits without resetting the simulation. Returns the number of (trips cancelled, parked cars displaced).

fn find_trips_affected_by_live_edits(
    &mut self,
    map: &Map
) -> (BTreeSet<(AgentID, TripID)>, usize)

Returns (trips affected, number of parked cars displaced)

impl Sim

pub fn delete_car(&mut self, id: CarID, map: &Map)

pub fn clear_alerts(&mut self) -> Vec<(Time, AlertLocation, String)>

impl Sim

pub fn set_periodic_callback(&mut self, frequency: Duration)

Only one at a time supported.

pub fn unset_periodic_callback(&mut self)

impl Sim

pub fn record_traffic_for(&mut self, intersections: BTreeSet<IntersectionID>)

pub fn num_recorded_trips(&self) -> Option<usize>

pub fn save_recorded_traffic(&mut self, map: &Map)

Trait Implementations

impl Clone for Sim

fn clone(&self) -> Sim

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for Sim

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

Deserialize this value from the given Serde deserializer.

impl Serialize for Sim

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

Serialize this value into the given Serde serializer.