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, Option<TripMode>, 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, Option<TripMode>, Duration)>

Finish time, ID, mode, trip duration

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

After we restore from a savestate, don't record anything. This is only going to make sense if savestates are only used for quickly previewing against prebaked results, where we have the full Analytics anyway.

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.