Struct sim::analytics::Analytics

pub struct Analytics {
    pub road_thruput: TimeSeriesCount<RoadID>,
    pub intersection_thruput: TimeSeriesCount<IntersectionID>,
    pub traffic_signal_thruput: TimeSeriesCount<CompressedMovementID>,
    pub demand: BTreeMap<MovementID, usize>,
    pub bus_arrivals: Vec<(Time, CarID, BusRouteID, BusStopID)>,
    pub passengers_boarding: BTreeMap<BusStopID, Vec<(Time, BusRouteID, Duration)>>,
    pub passengers_alighting: BTreeMap<BusStopID, Vec<(Time, BusRouteID)>>,
    pub started_trips: BTreeMap<TripID, Time>,
    pub finished_trips: Vec<(Time, TripID, TripMode, Option<Duration>)>,
    pub trip_intersection_delays: BTreeMap<TripID, BTreeMap<TurnID, u8>>,
    pub lane_speed_percentage: BTreeMap<TripID, BTreeMap<LaneID, u8>>,
    pub trip_log: Vec<(Time, TripID, Option<PathRequest>, TripPhaseType)>,
    pub intersection_delays: BTreeMap<IntersectionID, Vec<(u8, Time, Duration, AgentType)>>,
    pub parking_lane_changes: BTreeMap<LaneID, Vec<(Time, bool)>>,
    pub parking_lot_changes: BTreeMap<ParkingLotID, Vec<(Time, bool)>>,
    pub(crate) alerts: Vec<(Time, AlertLocation, String)>,
    record_anything: bool,
}

As a simulation runs, different pieces emit Events. The Analytics object listens to these, organizing and storing some information from them. The UI queries Analytics to draw time-series and display statistics.

For all maps whose weekday scenario fully runs, the game's release includes some "prebaked results." These are just serialized Analytics after running the simulation on a map without any edits for the full day. This is the basis of A/B testing -- the player can edit the map, start running the simulation, and compare the live Analytics to the prebaked baseline Analytics.

Fields

road_thruput: TimeSeriesCount<RoadID>

intersection_thruput: TimeSeriesCount<IntersectionID>

traffic_signal_thruput: TimeSeriesCount<CompressedMovementID>

demand: BTreeMap<MovementID, usize>

Most fields in Analytics are cumulative over time, but this is just for the current moment in time.

bus_arrivals: Vec<(Time, CarID, BusRouteID, BusStopID)>

passengers_boarding: BTreeMap<BusStopID, Vec<(Time, BusRouteID, Duration)>>

For each passenger boarding, how long did they wait at the stop?

passengers_alighting: BTreeMap<BusStopID, Vec<(Time, BusRouteID)>>

started_trips: BTreeMap<TripID, Time>

finished_trips: Vec<(Time, TripID, TripMode, Option<Duration>)>

Finish time, ID, mode, trip duration if successful (or None if cancelled)

trip_intersection_delays: BTreeMap<TripID, BTreeMap<TurnID, u8>>

Records how long was spent waiting at each turn (Intersection) for a given trip Over a certain threshold TripID, [(TurnID, Time Waiting In Seconds)]

lane_speed_percentage: BTreeMap<TripID, BTreeMap<LaneID, u8>>

Records the average speed/maximum speed for each lane If it is over a certain threshold (<95% of max speed) TripID, [(LaneID, Percent of maximum speed as an integer (0-100)]

trip_log: Vec<(Time, TripID, Option<PathRequest>, TripPhaseType)>

intersection_delays: BTreeMap<IntersectionID, Vec<(u8, Time, Duration, AgentType)>>

Only for traffic signals. The u8 is the movement index from a CompressedMovementID.

parking_lane_changes: BTreeMap<LaneID, Vec<(Time, bool)>>

Per parking lane or lot, when does a spot become filled (true) or free (false)

parking_lot_changes: BTreeMap<ParkingLotID, Vec<(Time, bool)>>

alerts: Vec<(Time, AlertLocation, String)>

record_anything: bool

For benchmarking, we may want to disable collecting data.

Implementations

impl Analytics

pub fn new(record_anything: bool) -> Analytics

pub fn event(&mut self, ev: Event, time: Time, map: &Map)

pub fn record_demand(&mut self, path: &Path, map: &Map)

pub fn finished_trip_time(&self, trip: TripID) -> Option<Duration>

Ignores the current time. Returns None for cancelled trips.

pub fn both_finished_trips(
    &self,
    now: Time,
    before: &Analytics
) -> Vec<(TripID, Duration, Duration, TripMode)>

Returns pairs of trip times for finished trips in both worlds. (ID, before, after, mode)

pub fn get_trip_phases(&self, trip: TripID, map: &Map) -> Vec<TripPhase>

If calling on prebaked Analytics, be careful to pass in an unedited map, to match how the simulation was originally run. Otherwise the paths may be nonsense.

pub fn get_all_trip_phases(&self) -> BTreeMap<TripID, Vec<TripPhase>>

pub fn active_agents(&self, now: Time) -> Vec<(Time, usize)>

pub fn parking_lane_availability(
    &self,
    now: Time,
    l: LaneID,
    capacity: usize
) -> Vec<(Time, usize)>

Returns the free spots over time

pub fn parking_lot_availability(
    &self,
    now: Time,
    pl: ParkingLotID,
    capacity: usize
) -> Vec<(Time, usize)>

fn parking_spot_availability(
    now: Time,
    changes: &Vec<(Time, bool)>,
    capacity: usize
) -> Vec<(Time, usize)>

Trait Implementations

impl Clone for Analytics

fn clone(&self) -> Analytics

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for Analytics

fn default() -> Analytics

Returns the "default value" for a type.

impl<'de> Deserialize<'de> for Analytics

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

Deserialize this value from the given Serde deserializer.

impl Serialize for Analytics

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

Serialize this value into the given Serde serializer.