void TourData::Attraction_Report (void)
{
int i, zone, attr;
Integers totals;
Table_Itr table_itr;
Int_Map_Itr map_itr;
Show_Message ("Zone Attractions Report -- Record");
Set_Progress ();
Header_Number (ATTRACTIONS);
New_Page ();
totals.assign (table_groups.size (), 0);
for (map_itr = zone_map.begin (); map_itr != zone_map.end (); map_itr++) {
zone = map_itr->first;
Show_Progress ();
Print (1, String ("%5d") % zone);
for (i=0, table_itr = table_groups.begin (); table_itr != table_groups.end (); table_itr++, i++) {
attr = table_itr->zone_wt [zone];
Print (0, String (" %8d") % attr);
totals [i] += attr;
}
}
End_Progress ();
Print (2, "Total");
for (i=0, table_itr = table_groups.begin (); table_itr != table_groups.end (); table_itr++, i++) {
Print (0, String (" %8d") % totals [i]);
}
Header_Number (0);
}
void LinkSum::Top_100_Ratios (int type)
{
int i, j, k, num, anode, bnode, min_ratio, ratio, tod_list, tod, lanes;
int load, base, cap, capacity, tim, vol, time0, len;
Link_Data *link_ptr;
Performance_Data *perf_ptr;
Link_Use_Data *use_ptr;
Range_Data *range_ptr;
//---- Top 100 Ratio Report Data ----
typedef struct {
int link;
int from;
int to;
int period;
int base;
int load;
int ratio;
} Ratio_Data;
Ratio_Data ratios [100], *ptr;
Show_Message ("Creating the Top 100 Ratios Report -- Record");
Set_Progress (10000);
memset (ratios, '\0', 100 * sizeof (Ratio_Data));
//---- find Top 100 Ratios ----
min_ratio = 0;
for (link_ptr = link_data.First (); link_ptr; link_ptr = link_data.Next ()) {
Show_Progress ();
if (select_flag && link_ptr->Use () == 0) continue;
len = link_ptr->Length ();
for (i=0; i < 2; i++) {
if (i) {
if (link_ptr->Use () == -1) continue;
perf_ptr = performance_data [link_ptr->BA_Dir ()];
anode = link_ptr->Bnode ();
bnode = link_ptr->Anode ();
} else {
if (link_ptr->Use () == -2) continue;
perf_ptr = performance_data [link_ptr->AB_Dir ()];
anode = link_ptr->Anode ();
bnode = link_ptr->Bnode ();
}
if (perf_ptr == NULL) continue;
time0 = perf_ptr->Time0 ();
if (time0 == 0) continue;
capacity = cap = (int) (perf_ptr->Capacity () * cap_factor + 0.5);
tod_list = perf_ptr->TOD_List ();
lanes = perf_ptr->Thru ();
if (lanes < 1) lanes = 1;
num = perf_ptr->Periods ();
//---- scan each time period ----
for (j=1; j <= num; j++) {
vol = perf_ptr->Volume (j);
if (vol < min_volume) continue;
switch (type) {
case TOP_SPEED:
tim = Round (perf_ptr->TTime (j));
if (tim == 0) continue;
base = (len * 10 + time0 / 2) / time0;
load = (len * 10 + tim / 2) / tim;
ratio = ((base - load) * 1000 + base / 2) / base;
break;
case TOP_TIME_RATIO:
base = Resolve (time0 * 10);
load = Resolve (Round (perf_ptr->TTime (j)) * 10);
ratio = (load * 1000 + base / 2) / base;
break;
case TOP_VC_RATIO:
if (tod_list > 0) {
//---- get the time period ----
range_ptr = time_periods [j];
tod = Round ((range_ptr->High () + range_ptr->Low () + 1) / 2);
cap = capacity;
for (k = tod_list; k; k = use_ptr->TOD_List ()) {
use_ptr = link_use_data [k];
if (use_ptr->Start () <= tod && tod < use_ptr->End ()) {
cap = capacity * use_ptr->Lanes () / lanes;
break;
}
}
}
base = cap;
if (base == 0) continue;
load = vol;
ratio = (load * 1000 + base / 2) / base;
break;
case TOP_TIME_CHANGE:
if (perf_ptr->Volume2 (j) < min_volume) continue;
base = Resolve (Round (perf_ptr->TTime2 (j)) * 10);
if (base == 0) continue;
load= Resolve (Round (perf_ptr->TTime (j)) * 10);
ratio = ((load - base) * 1000 + base / 2) / base;
break;
case TOP_VOL_CHANGE:
base = perf_ptr->Volume2 (j);
if (base < min_volume) continue;
load = vol;
ratio = ((load - base) * 1000 + base / 2) / base;
break;
}
if (ratio > min_ratio) {
ptr = ratios;
for (k=0; k < 100; k++, ptr++) {
if (ratio > ptr->ratio) {
if (ptr->ratio > 0 && k < 99) {
memmove (ptr+1, ptr, (99-k) * sizeof (Ratio_Data));
min_ratio = ratios [99].ratio;
}
ptr->link = link_ptr->Link ();
ptr->from = anode;
ptr->to = bnode;
ptr->period = j;
ptr->base = base;
ptr->load = load;
ptr->ratio = ratio;
break;
}
}
}
}
}
}
End_Progress ();
//---- print the report ----
Header_Number (type);
New_Page ();
ptr = ratios;
for (i=0; i < 100; i++, ptr++) {
if (ptr->ratio == 0) break;
//---- print the data record ----
Print (1, "%10ld%10ld%10ld %12.12s ",
ptr->link, ptr->from, ptr->to,
time_periods.Range_Format (ptr->period));
if (type == TOP_VC_RATIO) {
Print (0, "%7d %7d %5.2lf", ptr->base, ptr->load, ptr->ratio / 1000.0);
} else if (type == TOP_VOL_CHANGE) {
Print (0, "%7d %7d %5.1lf", ptr->base, ptr->load, ptr->ratio / 10.0);
} else {
Print (0, "%7.1lf %7.1lf %5.1lf", ptr->base / 10.0, ptr->load / 10.0, ptr->ratio / 10.0);
}
}
if (i) {
Print (2, "Number of Records in the Report = %d", i);
}
Header_Number (0);
}
void LineSum::Compare (void)
{
int mode;
Dtime time;
Db_Header *fh;
File_Itr file_itr;
Sort_Key sort_key;
Route_Data route_rec, *base_ptr, *alt_ptr;
Route_Map_Itr route_itr, base_itr;
Route_Map_Stat route_stat;
Route_Map base_map, alt_map;
//---- compare files ----
Show_Message ("Reading Base Route Files -- Record");
Set_Progress ();
for (mode=1, file_itr = base_routes.begin (); file_itr != base_routes.end (); file_itr++, mode++) {
fh = *file_itr;
while (fh->Read ()) {
Show_Progress ();
sort_key.mode = (short) mode; //(short) fh->Get_Integer ("MODE");
sort_key.leg = (short) 1;
sort_key.name = fh->Get_String ("NAME");
time = fh->Get_Time ("HEADWAY1");
route_rec.headway1 = (int) time.Minutes ();
time = fh->Get_Time ("HEADWAY2");
route_rec.headway2 = (int) time.Minutes ();
time = fh->Get_Time ("TTIME1");
route_rec.ttime1 = (int) time.Minutes ();
time = fh->Get_Time ("TTIME2");
route_rec.ttime2 = (int) time.Minutes ();
route_rec.nodes = fh->Get_Integer ("NODES");
route_rec.notes = fh->Get_String ("NOTES");
route_rec.match = 0;
route_stat = base_map.insert (Route_Map_Data (sort_key, route_rec));
if (!route_stat.second) {
sort_key.leg = (short) 2;
route_stat = base_map.insert (Route_Map_Data (sort_key, route_rec));
}
}
}
End_Progress ();
//---- compare files ----
Show_Message ("Reading Alternative Route Files -- Record");
Set_Progress ();
New_Page ();
Header_Number (DIFFERENCE_REPORT);
Compare_Header ();
for (mode=1, file_itr = alt_routes.begin (); file_itr != alt_routes.end (); file_itr++, mode++) {
fh = *file_itr;
while (fh->Read ()) {
Show_Progress ();
sort_key.mode = (short) mode; //(short) fh->Get_Integer ("MODE");
sort_key.leg = (short) 1;
sort_key.name = fh->Get_String ("NAME");
time = fh->Get_Time ("HEADWAY1");
route_rec.headway1 = (int) time.Minutes ();
time = fh->Get_Time ("HEADWAY2");
route_rec.headway2 = (int) time.Minutes ();
time = fh->Get_Time ("TTIME1");
route_rec.ttime1 = (int) time.Minutes ();
time = fh->Get_Time ("TTIME2");
route_rec.ttime2 = (int) time.Minutes ();
route_rec.nodes = fh->Get_Integer ("NODES");
route_rec.notes = fh->Get_String ("NOTES");
route_rec.match = 0;
route_stat = alt_map.insert (Route_Map_Data (sort_key, route_rec));
if (!route_stat.second) {
sort_key.leg = (short) 2;
route_stat = alt_map.insert (Route_Map_Data (sort_key, route_rec));
}
}
}
End_Progress ();
for (route_itr = alt_map.begin (); route_itr != alt_map.end (); route_itr++) {
sort_key = route_itr->first;
alt_ptr = &route_itr->second;
base_itr = base_map.find (route_itr->first);
if (base_itr == base_map.end ()) {
Print (1, String ("%3d %-12.12s") % sort_key.mode % sort_key.name);
Print (0, String (" %6.1lf %6.1lf %6.1lf %6.1lf %5d %6.1lf %6.1lf %6.1lf %6.1lf %5d ") %
0 % 0 % 0 % 0 % 0 %
alt_ptr->headway1 % alt_ptr->ttime1 % alt_ptr->headway2 % alt_ptr->ttime2 % alt_ptr->nodes);
Print (0, alt_ptr->notes);
} else {
base_ptr = &base_itr->second;
base_ptr->match = 1;
if (base_ptr->headway1 != alt_ptr->headway1 || base_ptr->headway2 != alt_ptr->headway2 ||
base_ptr->ttime1 != alt_ptr->ttime1 || base_ptr->ttime2 != alt_ptr->ttime2 ||
base_ptr->nodes != alt_ptr->nodes) {
Print (1, String ("%3d %-12.12s") % sort_key.mode % sort_key.name);
Print (0, String (" %6.1lf %6.1lf %6.1lf %6.1lf %5d %6.1lf %6.1lf %6.1lf %6.1lf %5d ") %
base_ptr->headway1 % base_ptr->ttime1 % base_ptr->headway2 % base_ptr->ttime2 % base_ptr->nodes %
alt_ptr->headway1 % alt_ptr->ttime1 % alt_ptr->headway2 % alt_ptr->ttime2 % alt_ptr->nodes);
Print (0, base_ptr->notes);
}
}
}
for (base_itr = base_map.begin (); base_itr != base_map.end (); base_itr++) {
if (base_itr->second.match == 0) {
sort_key = base_itr->first;
base_ptr = &base_itr->second;
Print (1, String ("%3d %-12.12s") % sort_key.mode % sort_key.name);
Print (0, String (" %6.1lf %6.1lf %6.1lf %6.1lf %5d %6.1lf %6.1lf %6.1lf %6.1lf %5d ") %
base_ptr->headway1 % base_ptr->ttime1 % base_ptr->headway2 % base_ptr->ttime2 % base_ptr->nodes %
0 % 0 % 0 % 0 % 0);
Print (0, base_ptr->notes);
}
}
Header_Number (0);
}
void LinkSum::Link_Report (double min_volume)
{
bool flag;
int i, ab_index, ba_index, ab_flow, ba_flow, an, bn;
double flow;
String ab, ba;
Link_Itr link_itr;
Link_Perf_Period_Itr period_itr;
Flow_Time_Data flow_data;
Show_Message ("Creating a Link Event Report -- Record");
Set_Progress ();
//---- find volumes greater than min_volume ----
header_value = DTOI (min_volume);
Header_Number (LINK_REPORT);
New_Page ();
for (link_itr = link_array.begin (); link_itr != link_array.end (); link_itr++) {
Show_Progress ();
if (select_flag && link_itr->Use () == 0) continue;
ab_index = (link_itr->Use () != -2) ? link_itr->AB_Dir () : -1;
ba_index = (link_itr->Use () != -1) ? link_itr->BA_Dir () : -1;
ab_flow = (ab_index >= 0) ? dir_array [ab_index].Flow_Index () : -1;
ba_flow = (ba_index >= 0) ? dir_array [ba_index].Flow_Index () : -1;
//---- scan each period volume ----
for (i=0, period_itr = link_perf_array.begin (); period_itr != link_perf_array.end (); period_itr++, i++) {
ab.clear ();
ba.clear ();
flag = false;
if (ab_index >= 0) {
flow_data = period_itr->Total_Flow_Time (ab_index, ab_flow);
flow = flow_data.Flow ();
if (flow >= min_volume) {
ab = String ("%d") % DTOI (flow);
flag = true;
}
}
if (ba_index >= 0) {
flow_data = period_itr->Total_Flow_Time (ba_index, ba_flow);
flow = flow_data.Flow ();
if (flow >= min_volume) {
ba = String ("%d") % DTOI (flow);
flag = true;
}
}
if (!flag) continue;
Show_Progress ();
//---- print the data record ----
an = node_array [link_itr->Anode ()].Node ();
bn = node_array [link_itr->Bnode ()].Node ();
Print (1, String ("%10d%10d%10d %12.12s%10.10s %10.10s") % link_itr->Link () % an %
bn % sum_periods.Range_Format (i) % ab % ba);
}
}
End_Progress ();
if (Progress_Count ()) {
Print (2, "Number of Records in the Report = ") << Progress_Count ();
}
Header_Number (0);
}
void LinkSum::Top_100_Report (int type)
{
int i, j, k, anode, bnode, an, bn, max_tim, max_an, max_bn;
int tod_list, lanes, max_lanes, index, flow_index;
double flow, min_flow, max_flow;
Dtime low, high, tod;
Link_Itr link_itr;
Dir_Data *dir_ptr;
Link_Perf_Period_Itr period_itr;
Flow_Time_Data flow_time;
Lane_Use_Period *use_ptr;
//---- Top 100 Data ----
typedef struct {
int link;
int from;
int to;
int period;
double flow;
} Flow_Data;
Flow_Data flow_data [100], *flow_ptr;
Show_Message ("Creating the Top 100 Flow Report -- Record");
Set_Progress ();
memset (flow_data, '\0', 100 * sizeof (Flow_Data));
//---- find Top 100 Flows ----
min_flow = 0;
for (link_itr = link_array.begin (); link_itr != link_array.end (); link_itr++) {
Show_Progress ();
if (select_flag && link_itr->Use () == 0) continue;
an = node_array [link_itr->Anode ()].Node ();
bn = node_array [link_itr->Bnode ()].Node ();
for (i=0; i < 2; i++) {
if (i) {
if (link_itr->Use () == -1) continue;
index = link_itr->BA_Dir ();
anode = bn;
bnode = an;
} else {
if (link_itr->Use () == -2) continue;
index = link_itr->AB_Dir ();
anode = an;
bnode = bn;
}
if (index < 0) continue;
dir_ptr = &dir_array [index];
max_flow = max_tim = max_an = max_bn = 0;
max_lanes = lanes = dir_ptr->Lanes ();
tod_list = dir_ptr->First_Lane_Use ();
flow_index = dir_ptr->Flow_Index ();
//---- scan each time period ----
for (j=0, period_itr = link_perf_array.begin (); period_itr != link_perf_array.end (); period_itr++, j++) {
flow_time = period_itr->Total_Flow_Time (index, flow_index);
flow = flow_time.Flow ();
if (flow < minimum_flow) continue;
if (type == TOP_PERIOD) {
if (flow <= min_flow) continue;
flow_ptr = flow_data;
for (k=0; k < 100; k++, flow_ptr++) {
if (flow > flow_ptr->flow) {
if (flow_ptr->flow > 0 && k < 99) {
memmove (flow_ptr+1, flow_ptr, (99-k) * sizeof (Flow_Data));
min_flow = flow_data [99].flow;
}
flow_ptr->link = link_itr->Link ();
flow_ptr->from = anode;
flow_ptr->to = bnode;
flow_ptr->period = j;
flow_ptr->flow = flow;
break;
}
}
} else {
if (type == TOP_LANE_FLOW) {
if (tod_list >= 0) {
//---- get the time period ----
sum_periods.Period_Range (j, low, high);
tod = (low + high + 1) / 2;
lanes = max_lanes;
k = tod_list;
for (use_ptr = &use_period_array [k]; ; use_ptr = &use_period_array [++k]) {
if (use_ptr->Start () <= tod && tod < use_ptr->End ()) {
lanes = use_ptr->Lanes0 () + use_ptr->Lanes1 ();
break;
}
if (use_ptr->Periods () == 0) break;
}
}
if (lanes > 1) flow /= lanes;
}
flow = DTOI (flow);
if (flow > max_flow) {
max_flow = flow;
max_tim = j;
max_an = anode;
max_bn = bnode;
}
}
}
//---- add to the list ----
if (max_flow > min_flow) {
flow_ptr = flow_data;
for (k=0; k < 100; k++, flow_ptr++) {
if (max_flow > flow_ptr->flow) {
if (flow_ptr->flow > 0 && k < 99) {
memmove (flow_ptr+1, flow_ptr, (99-k) * sizeof (Flow_Data));
min_flow = flow_data [99].flow;
}
flow_ptr->link = link_itr->Link ();
flow_ptr->from = max_an;
flow_ptr->to = max_bn;
flow_ptr->period = max_tim;
flow_ptr->flow = max_flow;
break;
}
}
}
}
}
End_Progress ();
//---- print the report ----
flow_ptr = flow_data;
Header_Number (type);
New_Page ();
for (i=0; i < 100; i++, flow_ptr++) {
if (flow_ptr->flow <= 0.0) break;
//---- print the data record ----
Print (1, String ("%10d%10d%10d %12.12s%12.1lf") % flow_ptr->link % flow_ptr->from % flow_ptr->to %
sum_periods.Range_Format (flow_ptr->period) % flow_ptr->flow);
}
if (i) {
Print (2, "Number of Records in the Report = ") << i;
}
Header_Number (0);
}
void LinkSum::Top_100_Ratios (int type)
{
int i, j, k, anode, bnode, an, bn, min_ratio, ratio, tod_list, lanes, lane;
int load, base, cap, capacity, tim, vol, time0, len, index, flow_index;
double flow;
Dtime low, high, tod;
Link_Itr link_itr;
Dir_Data *dir_ptr;
Link_Perf_Period_Itr period_itr;
Link_Perf_Array *period_ptr;
Flow_Time_Data flow_data;
Lane_Use_Period *use_ptr;
//---- Top 100 Ratio Report Data ----
typedef struct {
int link;
int from;
int to;
int period;
int base;
int load;
int ratio;
} Ratio_Data;
Ratio_Data ratios [100], *ptr;
Show_Message ("Creating the Top 100 Ratios Report -- Record");
Set_Progress ();
memset (ratios, '\0', 100 * sizeof (Ratio_Data));
//---- find Top 100 Ratios ----
min_ratio = base = load = ratio = 0;
for (link_itr = link_array.begin (); link_itr != link_array.end (); link_itr++) {
Show_Progress ();
if (select_flag && link_itr->Use () == 0) continue;
an = node_array [link_itr->Anode ()].Node ();
bn = node_array [link_itr->Bnode ()].Node ();
for (i=0; i < 2; i++) {
if (i) {
if (link_itr->Use () == -1) continue;
index = link_itr->BA_Dir ();
anode = bn;
bnode = an;
} else {
if (link_itr->Use () == -2) continue;
index = link_itr->AB_Dir ();
anode = an;
bnode = bn;
}
if (index < 0) continue;
dir_ptr = &dir_array [index];
len = link_itr->Length ();
lanes = dir_ptr->Lanes ();
if (lanes < 1) lanes = 1;
tod_list = dir_ptr->First_Lane_Use ();
flow_index = dir_ptr->Flow_Index ();
time0 = dir_ptr->Time0 ();
if (time0 == 0) continue;
capacity = cap = DTOI (dir_ptr->Capacity () * cap_factor);
//---- scan each time period ----
for (j=0, period_itr = link_perf_array.begin (); period_itr != link_perf_array.end (); period_itr++, j++) {
flow_data = period_itr->Total_Flow_Time (index, flow_index);
flow = flow_data.Flow ();
if (flow < minimum_flow) continue;
tim = flow_data.Time ();
vol = DTOI (flow);
switch (type) {
case TOP_SPEED:
if (tim == 0) continue;
base = (len * 10 + time0 / 2) / time0;
load = (len * 10 + tim / 2) / tim;
ratio = ((base - load) * 1000 + base / 2) / base;
break;
case TOP_TIME_RATIO:
base = time0;
load = tim;
ratio = (load * 1000 + base / 2) / base;
break;
case TOP_VC_RATIO:
if (tod_list >= 0) {
sum_periods.Period_Range (j, low, high);
tod = (low + high + 1) / 2;
cap = capacity;
k = tod_list;
for (use_ptr = &use_period_array [k]; ; use_ptr = &use_period_array [++k]) {
if (use_ptr->Start () <= tod && tod < use_ptr->End ()) {
lane = use_ptr->Lanes0 () + use_ptr->Lanes1 ();
cap = capacity * lane / lanes;
break;
}
if (use_ptr->Periods () == 0) break;
}
}
base = cap;
if (base == 0) continue;
load = vol;
ratio = (load * 1000 + base / 2) / base;
break;
case TOP_TIME_CHANGE:
period_ptr = &compare_link_array [j];
flow_data = period_ptr->Total_Flow_Time (index, flow_index);
if (flow_data.Flow () < minimum_flow) continue;
base = flow_data.Time ();
if (base == 0) continue;
load = tim;
ratio = ((load - base) * 1000 + base / 2) / base;
break;
case TOP_VOL_CHANGE:
period_ptr = &compare_link_array [j];
flow_data = period_ptr->Total_Flow_Time (index, flow_index);
base = DTOI (flow_data.Flow ());
if (base < minimum_flow) continue;
load = vol;
ratio = ((load - base) * 1000 + base / 2) / base;
break;
}
if (ratio > min_ratio) {
ptr = ratios;
for (k=0; k < 100; k++, ptr++) {
if (ratio > ptr->ratio) {
if (ptr->ratio > 0 && k < 99) {
memmove (ptr+1, ptr, (99-k) * sizeof (Ratio_Data));
min_ratio = ratios [99].ratio;
}
ptr->link = link_itr->Link ();
ptr->from = anode;
ptr->to = bnode;
ptr->period = j;
ptr->base = base;
ptr->load = load;
ptr->ratio = ratio;
break;
}
}
}
}
}
}
End_Progress ();
//---- print the report ----
Header_Number (type);
New_Page ();
ptr = ratios;
for (i=0; i < 100; i++, ptr++) {
if (ptr->ratio == 0) break;
//---- print the data record ----
Print (1, String ("%10ld%10ld%10ld %12.12s ") % ptr->link % ptr->from % ptr->to %
sum_periods.Range_Format (ptr->period));
if (type == TOP_VC_RATIO) {
Print (0, String ("%7d %7d %5.2lf") % ptr->base % ptr->load % (ptr->ratio / 1000.0));
} else if (type == TOP_VOL_CHANGE) {
Print (0, String ("%7d %7d %5.1lf") % ptr->base % ptr->load % (ptr->ratio / 10.0));
} else {
Print (0, String ("%7.1lf %7.1lf %5.1lf") % (ptr->base / 10.0) % (ptr->load / 10.0) % (ptr->ratio / 10.0));
}
}
if (i) {
Print (2, "Number of Records in the Report = ") << i;
}
Header_Number (0);
}
void LinkSum::Link_Report (double min_volume)
{
bool flag;
int i, num;
char ab [12], ba [12];
Link_Data *link_ptr;
Performance_Data *ttime_ab, *ttime_ba;
Show_Message ("Creating a Link Event Report -- Record");
Set_Progress (10000);
//---- find volumes greater than min_volume ----
header_value = (int) (min_volume + 0.5);
Header_Number (LINK_REPORT);
New_Page ();
for (link_ptr = link_data.First_Key (); link_ptr; link_ptr = link_data.Next_Key ()) {
if (select_flag && link_ptr->Use () == 0) continue;
//---- get the directional information ----
ttime_ab = performance_data [link_ptr->AB_Dir ()];
ttime_ba = performance_data [link_ptr->BA_Dir ()];
num = 0;
if (ttime_ab != NULL) {
num = ttime_ab->Periods ();
} else if (ttime_ba != NULL) {
num = ttime_ba->Periods ();
}
if (num == 0) continue;
//---- scan each period volume ----
for (i=1; i <= num; i++) {
ab [0] = ba [0] = '\0';
flag = false;
if (ttime_ab != NULL && link_ptr->Use () != -2) {
if (ttime_ab->Volume (i) > header_value) {
str_fmt (ab, sizeof (ab), "%d", ttime_ab->Volume (i));
flag = true;
}
}
if (ttime_ba != NULL && link_ptr->Use () != -1) {
if (ttime_ba->Volume (i) > header_value) {
str_fmt (ba, sizeof (ba), "%d", ttime_ba->Volume (i));
flag = true;
}
}
if (!flag) continue;
Show_Progress ();
//---- print the data record ----
Print (1, "%10d%10d%10d %12.12s%10.10s %10.10s",
link_ptr->Link (), link_ptr->Anode (), link_ptr->Bnode (),
time_periods.Range_Format (i), ab, ba);
}
}
End_Progress ();
if (Progress_Count ()) {
Print (2, "Number of Records in the Report = %d", Progress_Count ());
}
Header_Number (0);
}
void LineSum::Link_Report (Link_Report_Data &report)
{
int i, anode, bnode, mode, dir;
int ab_pk_tot, ab_op_tot, ba_pk_tot, ba_op_tot, ab_tot, ba_tot, pk_tot, op_tot, total;
int ab_pk_max, ab_op_max, ba_pk_max, ba_op_max, ab_max, ba_max, pk_max, op_max, maximum;
int ab_pk_pmt, ab_op_pmt, ba_pk_pmt, ba_op_pmt, ab_pmt, ba_pmt, pk_pmt, op_pmt, pmt;
int ab_pk_pht, ab_op_pht, ba_pk_pht, ba_op_pht, ab_pht, ba_pht, pk_pht, op_pht, pht;
Leg_Data *leg_ptr;
Line_Map_Itr map_itr;
Str_Itr str_itr;
Str_Map_Itr name_itr;
String name;
Int_Itr int_itr, b_itr;
Range_Array_Itr range_itr;
Link_Map link_map;
Sort_Key sort_key;
Link_Data link_rec, *link_ptr;
Link_Map_Itr link_itr;
Link_Map_Stat map_stat;
memset (&link_rec, '\0', sizeof (link_rec));
Show_Message (String ("Creating Link Report #%d -- Records") % report.number);
Set_Progress ();
//---- report header ----
New_Page ();
Print (2, "Title: ") << report.title;
Print (1, "Links: ") << report.links;
if (!report.all_modes) {
Print (1, "Modes:");
for (i=0, range_itr = report.modes.begin (); range_itr != report.modes.end (); range_itr++, i++) {
if (!(i % 10)) {
if (i) {
Print (1, " ") << range_itr->Low ();
} else {
Print (0, " ") << range_itr->Low ();
}
} else {
Print (0, ", ") << range_itr->Low ();
}
if (range_itr->High () > range_itr->Low ()) {
Print (0, "..") << range_itr->High ();
}
}
}
if (!report.all_lines) {
Print (1, "Lines:");
for (i=0, str_itr = report.lines.begin (); str_itr != report.lines.end (); str_itr++, i++) {
if (!(i % 10)) {
if (i) {
Print (1, " ") << *str_itr;
} else {
Print (0, " ") << *str_itr;
}
} else {
Print (0, ", ") << *str_itr;
}
}
}
//---- flag connected links ----
for (i=0, int_itr = report.nodes.begin (); int_itr != report.nodes.end (); int_itr += 2, i++) {
anode = *int_itr;
for (b_itr = report.nodes.begin (); b_itr != report.nodes.end (); b_itr++) {
bnode = *(++b_itr);
if (bnode == anode) {
*(int_itr) = -anode;
break;
}
}
}
Header_Number (LINK_REPORT);
Link_Header ();
ab_pk_tot = ab_op_tot = ba_pk_tot = ba_op_tot = ab_tot = ba_tot = pk_tot = op_tot = total = 0;
ab_pk_max = ab_op_max = ba_pk_max = ba_op_max = ab_max = ba_max = pk_max = op_max = maximum = 0;
ab_pk_pmt = ab_op_pmt = ba_pk_pmt = ba_op_pmt = ab_pmt = ba_pmt = pk_pmt = op_pmt = pmt = 0;
ab_pk_pht = ab_op_pht = ba_pk_pht = ba_op_pht = ab_pht = ba_pht = pk_pht = op_pht = pht = 0;
//---- gather peak ridership ----
for (map_itr = peak_map.begin (); map_itr != peak_map.end (); map_itr++) {
mode = map_itr->first.mode;
if (!report.all_modes && !report.modes.In_Range (mode)) continue;
name = map_itr->first.name;
if (!report.all_lines) {
for (str_itr = report.lines.begin (); str_itr != report.lines.end (); str_itr++) {
if (name.In_Range (*str_itr)) break;
}
if (str_itr == report.lines.end ()) continue;
}
dir = anode = bnode = 0;
leg_ptr = &map_itr->second;
for (int_itr = report.nodes.begin (); int_itr != report.nodes.end (); int_itr++) {
anode = *int_itr;
bnode = *(++int_itr);
if (abs (leg_ptr->a) == abs (anode) && abs (leg_ptr->b) == bnode) {
dir = 1;
break;
} else if (abs (leg_ptr->a) == bnode && abs (leg_ptr->b) == abs (anode)) {
dir = 2;
break;
}
}
if (dir == 0) continue;
Show_Progress ();
//---- search for the link ----
sort_key.mode = (short) mode;
sort_key.leg = 0;
sort_key.name = name;
map_stat = link_map.insert (Link_Map_Data (sort_key, link_rec));
if (dir == 1) {
if (anode < 0) {
map_stat.first->second.ab_pk_ride += leg_ptr->ab.on;
ab_pk_tot += leg_ptr->ab.on;
} else {
map_stat.first->second.ab_pk_ride += leg_ptr->ab.ride;
ab_pk_tot += leg_ptr->ab.ride;
}
ab_pk_pmt += leg_ptr->ab.ride * leg_ptr->dist;
ab_pk_pht += leg_ptr->ab.ride * leg_ptr->time;
if (!report.dir_flag) {
if (anode < 0) {
map_stat.first->second.ba_pk_ride += leg_ptr->ba.off;
ba_pk_tot += leg_ptr->ba.off;
} else {
map_stat.first->second.ba_pk_ride += leg_ptr->ba.ride;
ba_pk_tot += leg_ptr->ba.ride;
}
ba_pk_pmt += leg_ptr->ba.ride * leg_ptr->dist;
ba_pk_pht += leg_ptr->ba.ride * leg_ptr->time;
}
} else {
if (anode < 0) {
map_stat.first->second.ab_pk_ride += leg_ptr->ba.on;
ab_pk_tot += leg_ptr->ba.on;
} else {
map_stat.first->second.ab_pk_ride += leg_ptr->ba.ride;
ab_pk_tot += leg_ptr->ba.ride;
}
ab_pk_pmt += leg_ptr->ba.ride * leg_ptr->dist;
ab_pk_pht += leg_ptr->ba.ride * leg_ptr->time;
if (!report.dir_flag) {
if (anode < 0) {
map_stat.first->second.ba_pk_ride += leg_ptr->ab.off;
ba_pk_tot += leg_ptr->ab.off;
} else {
map_stat.first->second.ba_pk_ride += leg_ptr->ab.ride;
ba_pk_tot += leg_ptr->ab.ride;
}
ba_pk_pmt += leg_ptr->ab.ride * leg_ptr->dist;
ba_pk_pht += leg_ptr->ab.ride * leg_ptr->time;
}
}
}
//---- gather offpeak ridership ----
for (map_itr = offpeak_map.begin (); map_itr != offpeak_map.end (); map_itr++) {
mode = map_itr->first.mode;
if (!report.all_modes && !report.modes.In_Range (mode)) continue;
name = map_itr->first.name;
if (!report.all_lines) {
for (str_itr = report.lines.begin (); str_itr != report.lines.end (); str_itr++) {
if (name.In_Range (*str_itr)) break;
}
if (str_itr == report.lines.end ()) continue;
}
dir = anode = bnode = 0;
leg_ptr = &map_itr->second;
for (int_itr = report.nodes.begin (); int_itr != report.nodes.end (); int_itr++) {
anode = *int_itr;
bnode = *(++int_itr);
if (abs (leg_ptr->a) == abs (anode) && abs (leg_ptr->b) == bnode) {
dir = 1;
break;
} else if (abs (leg_ptr->a) == bnode && abs (leg_ptr->b) == abs (anode)) {
dir = 2;
break;
}
}
if (dir == 0) continue;
Show_Progress ();
//---- search for the link ----
sort_key.mode = (short) mode;
sort_key.leg = 0;
sort_key.name = name;
map_stat = link_map.insert (Link_Map_Data (sort_key, link_rec));
if (dir == 1) {
if (anode < 0) {
map_stat.first->second.ab_op_ride += leg_ptr->ab.on;
ab_op_tot += leg_ptr->ab.on;
} else {
map_stat.first->second.ab_op_ride += leg_ptr->ab.ride;
ab_op_tot += leg_ptr->ab.ride;
}
ab_op_pmt += leg_ptr->ab.ride * leg_ptr->dist;
ab_op_pht += leg_ptr->ab.ride * leg_ptr->time;
if (!report.dir_flag) {
if (anode < 0) {
map_stat.first->second.ba_op_ride += leg_ptr->ba.off;
ba_op_tot += leg_ptr->ba.off;
} else {
map_stat.first->second.ba_op_ride += leg_ptr->ba.ride;
ba_op_tot += leg_ptr->ba.ride;
}
ba_op_pmt += leg_ptr->ba.ride * leg_ptr->dist;
ba_op_pht += leg_ptr->ba.ride * leg_ptr->time;
}
} else {
if (anode < 0) {
map_stat.first->second.ab_op_ride += leg_ptr->ba.on;
ab_op_tot += leg_ptr->ba.on;
} else {
map_stat.first->second.ab_op_ride += leg_ptr->ba.ride;
ab_op_tot += leg_ptr->ba.ride;
}
ab_op_pmt += leg_ptr->ba.ride * leg_ptr->dist;
ab_op_pht += leg_ptr->ba.ride * leg_ptr->time;
if (!report.dir_flag) {
if (anode < 0) {
map_stat.first->second.ba_op_ride += leg_ptr->ab.off;
ba_op_tot += leg_ptr->ab.off;
} else {
map_stat.first->second.ba_op_ride += leg_ptr->ab.ride;
ba_op_tot += leg_ptr->ab.ride;
}
ba_op_pmt += leg_ptr->ab.ride * leg_ptr->dist;
ba_op_pht += leg_ptr->ab.ride * leg_ptr->time;
}
}
}
//---- exit if no data ----
if (link_map.size () == 0) {
Warning ("No Link Data to Report");
return;
}
//---- print the report ----
for (link_itr = link_map.begin (); link_itr != link_map.end (); link_itr++) {
sort_key = link_itr->first;
link_ptr = &link_itr->second;
ab_tot = link_ptr->ab_pk_ride + link_ptr->ab_op_ride;
ba_tot = link_ptr->ba_pk_ride + link_ptr->ba_op_ride;
pk_tot = link_ptr->ab_pk_ride + link_ptr->ba_pk_ride;
op_tot = link_ptr->ab_op_ride + link_ptr->ba_op_ride;
total = pk_tot + op_tot;
Print (1, String ("%3d %-12.12s %7d %7d %7d %7d %7d %7d %7d %7d %7d") %
(int) sort_key.mode % sort_key.name % link_ptr->ab_pk_ride % link_ptr->ab_op_ride % ab_tot %
link_ptr->ba_pk_ride % link_ptr->ba_op_ride % ba_tot % pk_tot % op_tot % total);
if (link_ptr->ab_pk_ride > ab_pk_max) ab_pk_max = link_ptr->ab_pk_ride;
if (link_ptr->ab_op_ride > ab_op_max) ab_op_max = link_ptr->ab_op_ride;
if (ab_tot > ab_max) ab_max = ab_tot;
if (pk_tot > pk_max) pk_max = pk_tot;
if (link_ptr->ba_pk_ride > ba_pk_max) ba_pk_max = link_ptr->ba_pk_ride;
if (link_ptr->ba_op_ride > ba_op_max) ba_op_max = link_ptr->ba_op_ride;
if (ba_tot > ba_max) ba_max = ba_tot;
if (op_tot > op_max) op_max = op_tot;
if (total > maximum) maximum = total;
}
//---- print the totals ----
ab_tot = ab_pk_tot + ab_op_tot;
ba_tot = ba_pk_tot + ba_op_tot;
pk_tot = ab_pk_tot + ba_pk_tot;
op_tot = ab_op_tot + ba_op_tot;
total = pk_tot + op_tot;
Print (2, String ("Total %-3d %7d %7d %7d %7d %7d %7d %7d %7d %7d") %
(int) link_map.size () % ab_pk_tot % ab_op_tot % ab_tot %
ba_pk_tot % ba_op_tot % ba_tot % pk_tot % op_tot % total);
Print (2, String ("Maximum %7d %7d %7d %7d %7d %7d %7d %7d %7d") %
ab_pk_max % ab_op_max % ab_max % ba_pk_max % ba_op_max % ba_max % pk_max % op_max % maximum);
ab_pmt = ab_pk_pmt + ab_op_pmt;
ba_pmt = ba_pk_pmt + ba_op_pmt;
pk_pmt = ab_pk_pmt + ba_pk_pmt;
op_pmt = ab_op_pmt + ba_op_pmt;
pmt = pk_pmt + op_pmt;
ab_pk_pmt = (ab_pk_pmt + 50) / 100;
ab_op_pmt = (ab_op_pmt + 50) / 100;
ab_pmt = (ab_pmt + 50) / 100;
ba_pk_pmt = (ba_pk_pmt + 50) / 100;
ba_op_pmt = (ba_op_pmt + 50) / 100;
ba_pmt = (ba_pmt + 50) / 100;
pk_pmt = (pk_pmt + 50) / 100;
op_pmt = (op_pmt + 50) / 100;
pmt = (pmt + 50) / 100;
Print (1, String ("Passenger Miles %7d %7d %7d %7d %7d %7d %7d %7d %7d") %
ab_pk_pmt % ab_op_pmt % ab_pmt % ba_pk_pmt % ba_op_pmt % ba_pmt % pk_pmt % op_pmt % pmt);
ab_pht = ab_pk_pht + ab_op_pht;
ba_pht = ba_pk_pht + ba_op_pht;
pk_pht = ab_pk_pht + ba_pk_pht;
op_pht = ab_op_pht + ba_op_pht;
pht = pk_pht + op_pht;
ab_pk_pht = (ab_pk_pht + 3000) / 6000;
ab_op_pht = (ab_op_pht + 3000) / 6000;
ab_pht = (ab_pht + 3000) / 6000;
ba_pk_pht = (ba_pk_pht + 3000) / 6000;
ba_op_pht = (ba_op_pht + 3000) / 6000;
ba_pht = (ba_pht + 3000) / 6000;
pk_pht = (pk_pht + 3000) / 6000;
op_pht = (op_pht + 3000) / 6000;
pht = (pht + 3000) / 6000;
Print (1, String ("Passenger Hours %7d %7d %7d %7d %7d %7d %7d %7d %7d") %
ab_pk_pht % ab_op_pht % ab_pht % ba_pk_pht % ba_op_pht % ba_pht % pk_pht % op_pht % pht);
End_Progress ();
Header_Number (0);
}
void LineSum::Line_Rider_Report (int number)
{
int stop, stops, run, runs, period, per, num, time;
int on, off, tot_on, tot_off, tot_ride, stop_id;
bool first, last_stop_flag, stop_flag, line_flag;
Rider_Data *rider_ptr;
Offset_Data *offset_ptr;
typedef struct {
int ride;
int tot_on;
int tot_off;
int tot_ride;
int max_on;
int max_off;
int max_ride;
} Period_Data;
Period_Data *period_data, *period_ptr;
Show_Message ("Creating a Line Ridership Report -- Record");
Set_Progress (100);
//---- initialize the selection sets ----
set_ptr = select_set [number];
if (set_ptr == NULL) return;
Header_Number (LINE_RIDER);
first = true;
num = set_ptr->Num_Periods () + 1;
period_data = new Period_Data [num];
if (period_data == NULL) {
Error ("Insufficient Space for %d Time Periods", num);
}
//---- process each route ----
for (rider_ptr = rider_data.First_Key (); rider_ptr; rider_ptr = rider_data.Next_Key ()) {
Show_Progress ();
if (!set_ptr->Select_Modes (rider_ptr->Mode ())) continue;
if (!set_ptr->Select_Routes (rider_ptr->Route ())) continue;
stops = rider_ptr->Stops ();
runs = rider_ptr->Runs ();
memset (period_data, '\0', num * sizeof (Period_Data));
line_flag = false;
last_stop_flag = stop_flag = true;
for (stop=1; stop <= stops; stop++) {
stop_id = rider_ptr->Stop (stop);
if (offset_flag && set_ptr->Subarea_Flag ()) {
offset_ptr = stop_offset.Get (stop_id);
if (offset_ptr == NULL) continue;
stop_flag = set_ptr->In_Subarea (offset_ptr->X (), offset_ptr->Y ());
}
if (stop_flag) {
if (!line_flag) {
if (first) {
New_Page ();
first = false;
} else {
Break_Check (MIN ((stops - stop + 8), 15));
}
Print (1, "Line: %s %d %s", Transit_Code ((Transit_Type) rider_ptr->Mode ()),
rider_ptr->Route (), rider_ptr->Name ());
Print (1);
line_flag = true;
}
Print (1, "%8d", stop_id);
}
tot_on = tot_off = tot_ride = 0;
for (per=1; per < num; per++) {
on = off = 0;
period_ptr = period_data + per;
for (run=1; run <= runs; run++) {
switch (set_ptr->Time_Method ()) {
case RUN_START:
time = rider_ptr->Time (run, 1);
break;
case RUN_END:
time = rider_ptr->Time (run, stops);
break;
case RUN_MID:
time = (rider_ptr->Time (run, 1) + rider_ptr->Time (run, stops)) / 2;
break;
case SCHED_START:
time = rider_ptr->Schedule (run, 1);
break;
case SCHED_END:
time = rider_ptr->Schedule (run, stops);
break;
case SCHED_MID:
time = (rider_ptr->Schedule (run, 1) + rider_ptr->Schedule (run, stops)) / 2;
break;
}
period = set_ptr->Time_Period (Resolve (time));
if (period < per) continue;
if (period > per) break;
on += rider_ptr->Board (run, stop);
off += rider_ptr->Alight (run, stop);
}
if (stop_flag && !last_stop_flag) {
period_ptr->tot_ride += period_ptr->ride;
}
period_ptr->ride += on - off;
if (stop_flag) {
Print (0, " %7d%7d%7d", on, off, period_ptr->ride);
tot_on += on;
tot_off += off;
tot_ride += period_ptr->ride;
period_ptr->tot_on += on;
period_ptr->tot_off += off;
period_ptr->tot_ride += on;
if (on > period_ptr->max_on) period_ptr->max_on = on;
if (off > period_ptr->max_off) period_ptr->max_off = off;
if (period_ptr->ride > period_ptr->max_ride) period_ptr->max_ride = period_ptr->ride;
}
}
if (stop_flag && num > 2) {
Print (0, " %7d%7d%7d", tot_on, tot_off, tot_ride);
period_ptr = period_data;
period_ptr->tot_on += tot_on;
period_ptr->tot_off += tot_off;
period_ptr->tot_ride += tot_ride;
if (tot_on > period_ptr->max_on) period_ptr->max_on = tot_on;
if (tot_off > period_ptr->max_off) period_ptr->max_off = tot_off;
if (tot_ride > period_ptr->max_ride) period_ptr->max_ride = tot_ride;
}
last_stop_flag = stop_flag;
}
if (line_flag) {
Print (2, " Total");
for (per=1; per <= num; per++) {
if (per == num) {
if (num > 2) {
per = 0;
} else {
break;
}
}
period_ptr = period_data + per;
Print (0, " %7d%7d%7d", period_ptr->tot_on, period_ptr->tot_off, period_ptr->tot_ride);
if (per == 0) break;
}
Print (1, " Maximum");
for (per=1; per <= num; per++) {
if (per == num) {
if (num > 2) {
per = 0;
} else {
break;
}
}
period_ptr = period_data + per;
Print (0, " %7d%7d%7d", period_ptr->max_on, period_ptr->max_off, period_ptr->max_ride);
if (per == 0) break;
}
Print (1);
}
}
End_Progress ();
Header_Number (0);
if (period_data != NULL) {
delete [] period_data;
}
}
void LineSum::Stop_Report (Stop_Report_Data &report)
{
int i, stop, mode, dir, arrive, on, off, depart, max_arrive, max_on, max_off, max_depart;
int pk_on, pk_off, op_on, op_off, pk_xfer, op_xfer;
String name;
Range_Array_Itr range_itr;
Leg_Data *leg_ptr;
Line_Map_Itr map_itr;
Access_Map_Itr access_itr;
Str_Itr str_itr;
Str_Map_Itr name_itr;
Sort_Key sort_key;
Stop_Data stop_rec, *stop_ptr, max_rec, tot_rec;
Stop_Map stop_map;
Stop_Map_Itr stop_itr;
Stop_Map_Stat stop_stat;
memset (&stop_rec, '\0', sizeof (stop_rec));
memset (&max_rec, '\0', sizeof (max_rec));
memset (&tot_rec, '\0', sizeof (tot_rec));
max_arrive = max_depart = max_off = max_on = pk_on = pk_off = op_on = op_off = pk_xfer = op_xfer = 0;
Show_Message (String ("Creating Stop Report #%d -- Stops") % report.number);
Set_Progress ();
//---- report header ----
New_Page ();
Print (2, "Title: ") << report.title;
Print (1, "Stops:");
for (i=0, range_itr = report.stops.begin (); range_itr != report.stops.end (); range_itr++, i++) {
if (!(i % 10)) {
if (i) {
Print (1, " ") << range_itr->Low ();
} else {
Print (0, " ") << range_itr->Low ();
}
} else {
Print (0, ", ") << range_itr->Low ();
}
if (range_itr->High () > range_itr->Low ()) {
Print (0, "..") << range_itr->High ();
} else {
name_itr = stop_names.find (range_itr->Low ());
if (name_itr != stop_names.end ()) {
Print (0, String (" (%s)") % name_itr->second);
}
}
}
if (!report.all_modes) {
Print (1, "Modes:");
for (i=0, range_itr = report.modes.begin (); range_itr != report.modes.end (); range_itr++, i++) {
if (!(i % 10)) {
if (i) {
Print (1, " ") << range_itr->Low ();
} else {
Print (0, " ") << range_itr->Low ();
}
} else {
Print (0, ", ") << range_itr->Low ();
}
if (range_itr->High () > range_itr->Low ()) {
Print (0, "..") << range_itr->High ();
}
}
}
if (!report.all_lines) {
Print (1, "Lines:");
for (i=0, str_itr = report.lines.begin (); str_itr != report.lines.end (); str_itr++, i++) {
if (!(i % 10)) {
if (i) {
Print (1, " ") << *str_itr;
} else {
Print (0, " ") << *str_itr;
}
} else {
Print (0, ", ") << *str_itr;
}
}
}
Header_Number (STOP_REPORT);
Stop_Header ();
//---- gather peak ridership ----
for (map_itr = peak_map.begin (); map_itr != peak_map.end (); map_itr++) {
mode = map_itr->first.mode;
if (!report.all_modes && !report.modes.In_Range (mode)) continue;
name = map_itr->first.name;
if (!report.all_lines) {
for (str_itr = report.lines.begin (); str_itr != report.lines.end (); str_itr++) {
if (name.In_Range (*str_itr)) break;
}
if (str_itr == report.lines.end ()) continue;
}
dir = 0;
leg_ptr = &map_itr->second;
stop = abs (leg_ptr->b);
if (report.stops.In_Range (stop)) {
dir = 1;
} else {
stop = abs (leg_ptr->a);
if (report.stops.In_Range (stop)) {
dir = 2;
}
}
if (dir == 0) continue;
Show_Progress ();
sort_key.mode = (short) mode;
sort_key.leg = 0;
sort_key.name = name;
stop_stat = stop_map.insert (Stop_Map_Data (sort_key, stop_rec));
stop_ptr = &stop_stat.first->second;
if (dir == 1) {
stop_ptr->pk.arrive += leg_ptr->ab.ride;
stop_ptr->pk.depart += leg_ptr->ba.ride;
stop_ptr->pk.off += leg_ptr->ab.off;
stop_ptr->pk.on += leg_ptr->ba.on;
} else {
stop_ptr->pk.arrive += leg_ptr->ba.ride;
stop_ptr->pk.depart += leg_ptr->ab.ride;
stop_ptr->pk.off += leg_ptr->ba.off;
stop_ptr->pk.on += leg_ptr->ab.on;
}
}
//---- gather peak access data ----
for (access_itr = access_map.begin (); access_itr != access_map.end (); access_itr++) {
mode = access_itr->first.mode;
if (!report.all_modes && !report.modes.In_Range (mode)) continue;
stop = access_itr->first.stop;
if (!report.stops.In_Range (stop)) continue;
Show_Progress ();
on = access_itr->second.pk_on;
off = access_itr->second.pk_off;
stop = access_itr->first.node;
if (report.stops.In_Range (stop)) {
on /= 2;
off /= 2;
}
pk_on += on;
pk_off += off;
if (report.transfers.In_Range (mode)) {
pk_xfer += (on + off) / 2;
}
name ("%d") % mode;
sort_key.mode = (short) mode;
sort_key.leg = 0;
sort_key.name = name;
stop_stat = stop_map.insert (Stop_Map_Data (sort_key, stop_rec));
stop_ptr = &stop_stat.first->second;
stop_ptr->pk.arrive += on;
stop_ptr->pk.depart += off;
}
//---- gather offpeak ridership ----
for (map_itr = offpeak_map.begin (); map_itr != offpeak_map.end (); map_itr++) {
mode = map_itr->first.mode;
if (!report.all_modes && !report.modes.In_Range (mode)) continue;
name = map_itr->first.name;
if (!report.all_lines) {
for (str_itr = report.lines.begin (); str_itr != report.lines.end (); str_itr++) {
if (name.In_Range (*str_itr)) break;
}
if (str_itr == report.lines.end ()) continue;
}
dir = 0;
leg_ptr = &map_itr->second;
stop = abs (leg_ptr->b);
if (report.stops.In_Range (stop)) {
dir = 1;
} else {
stop = abs (leg_ptr->a);
if (report.stops.In_Range (stop)) {
dir = 2;
}
}
if (dir == 0) continue;
Show_Progress ();
sort_key.mode = (short) mode;
sort_key.leg = 0;
sort_key.name = name;
stop_stat = stop_map.insert (Stop_Map_Data (sort_key, stop_rec));
stop_ptr = &stop_stat.first->second;
if (dir == 1) {
stop_ptr->op.arrive += leg_ptr->ab.ride;
stop_ptr->op.depart += leg_ptr->ba.ride;
stop_ptr->op.off += leg_ptr->ab.off;
stop_ptr->op.on += leg_ptr->ba.on;
} else {
stop_ptr->op.arrive += leg_ptr->ba.ride;
stop_ptr->op.depart += leg_ptr->ab.ride;
stop_ptr->op.off += leg_ptr->ba.off;
stop_ptr->op.on += leg_ptr->ab.on;
}
}
//---- gather offpeak access data ----
for (access_itr = access_map.begin (); access_itr != access_map.end (); access_itr++) {
mode = access_itr->first.mode;
if (!report.all_modes && !report.modes.In_Range (mode)) continue;
stop = access_itr->first.stop;
if (!report.stops.In_Range (stop)) continue;
Show_Progress ();
on = access_itr->second.op_on;
off = access_itr->second.op_off;
stop = access_itr->first.node;
if (report.stops.In_Range (stop)) {
on /= 2;
off /= 2;
}
op_on += on;
op_off += off;
if (report.transfers.In_Range (mode)) {
op_xfer += (on + off) / 2;
}
name ("%d") % mode;
sort_key.mode = (short) mode;
sort_key.leg = 0;
sort_key.name = name;
stop_stat = stop_map.insert (Stop_Map_Data (sort_key, stop_rec));
stop_ptr = &stop_stat.first->second;
stop_ptr->op.arrive += on;
stop_ptr->op.depart += off;
}
End_Progress ();
//---- exit if no data ----
if (stop_map.size () == 0) {
Warning ("No Stops to Report");
return;
}
//---- print the report ----
for (stop_itr = stop_map.begin (); stop_itr != stop_map.end (); stop_itr++) {
mode = stop_itr->first.mode;
name = stop_itr->first.name;
stop_ptr = &stop_itr->second;
arrive = stop_ptr->pk.arrive + stop_ptr->op.arrive;
depart = stop_ptr->pk.depart + stop_ptr->op.depart;
off = stop_ptr->pk.off + stop_ptr->op.off;
on = stop_ptr->pk.on + stop_ptr->op.on;
Print (1, String ("%3d %-12.12s") % mode % name);
Print (0, String (" %8d%8d%8d%8d %8d%8d%8d%8d %8d%8d%8d%8d") %
stop_ptr->pk.arrive % stop_ptr->pk.off % stop_ptr->pk.on % stop_ptr->pk.depart %
stop_ptr->op.arrive % stop_ptr->op.off % stop_ptr->op.on % stop_ptr->op.depart %
arrive % off % on % depart);
tot_rec.pk.arrive += stop_ptr->pk.arrive;
tot_rec.pk.depart += stop_ptr->pk.depart;
tot_rec.pk.off += stop_ptr->pk.off;
tot_rec.pk.on += stop_ptr->pk.on;
tot_rec.op.arrive += stop_ptr->op.arrive;
tot_rec.op.depart += stop_ptr->op.depart;
tot_rec.op.off += stop_ptr->op.off;
tot_rec.op.on += stop_ptr->op.on;
if (stop_ptr->pk.arrive > max_rec.pk.arrive) max_rec.pk.arrive = stop_ptr->pk.arrive;
if (stop_ptr->pk.depart > max_rec.pk.depart) max_rec.pk.depart = stop_ptr->pk.depart;
if (stop_ptr->pk.off > max_rec.pk.off) max_rec.pk.off = stop_ptr->pk.off;
if (stop_ptr->pk.on > max_rec.pk.on) max_rec.pk.on = stop_ptr->pk.on;
if (stop_ptr->op.arrive > max_rec.op.arrive) max_rec.op.arrive = stop_ptr->op.arrive;
if (stop_ptr->op.depart > max_rec.op.depart) max_rec.op.depart = stop_ptr->op.depart;
if (stop_ptr->op.off > max_rec.op.off) max_rec.op.off = stop_ptr->op.off;
if (stop_ptr->op.on > max_rec.op.on) max_rec.op.on = stop_ptr->op.on;
if (arrive > max_arrive) max_arrive = arrive;
if (depart > max_depart) max_depart = depart;
if (off > max_off) max_off = off;
if (on > max_on) max_on = on;
}
//---- print total ----
arrive = tot_rec.pk.arrive + tot_rec.op.arrive;
depart = tot_rec.pk.depart + tot_rec.op.depart;
off = tot_rec.pk.off + tot_rec.op.off;
on = tot_rec.pk.on + tot_rec.op.on;
Print (2, String ("Total %-4d %8d%8d%8d%8d %8d%8d%8d%8d %8d%8d%8d%8d") % stop_map.size () %
tot_rec.pk.arrive % tot_rec.pk.off % tot_rec.pk.on % tot_rec.pk.depart %
tot_rec.op.arrive % tot_rec.op.off % tot_rec.op.on % tot_rec.op.depart %
arrive % off % on % depart);
if (report.transfers.size () > 0) {
pk_xfer += (tot_rec.pk.on - pk_on + tot_rec.pk.off - pk_off) / 2;
op_xfer += (tot_rec.op.on - op_on + tot_rec.op.off - op_off) / 2;
Print (1, String ("Transfers %8d %8d %8d") %
pk_xfer % op_xfer % (pk_xfer + op_xfer));
}
Print (1, String ("Maximum %8d%8d%8d%8d %8d%8d%8d%8d %8d%8d%8d%8d") %
max_rec.pk.arrive % max_rec.pk.off % max_rec.pk.on % max_rec.pk.depart %
max_rec.op.arrive % max_rec.op.off % max_rec.op.on % max_rec.op.depart %
max_arrive % max_off % max_on % max_depart);
Header_Number (0);
}
