void ConvertTrips::Zone_Sum_Report (void)
{
int z, zone, org_in_tot, des_in_tot, org_out_tot, des_out_tot;
Int_Map_Itr map_itr;
//---- print the report ----
Header_Number (ZONE_TRIP_ENDS);
if (!Break_Check ((int) zone_map.size () + 7)) {
Print (1);
Zone_Sum_Header ();
}
org_in_tot = des_in_tot = org_out_tot = des_out_tot = 0;
for (map_itr = zone_map.begin (); map_itr != zone_map.end (); map_itr++) {
zone = map_itr->first;
z = map_itr->second;
org_in_tot += org_in [z];
des_in_tot += des_in [z];
org_out_tot += org_out [z];
des_out_tot += des_out [z];
Print (1, String ("%6d %8d %8d %8d %8d %8d %8d") % zone % org_in [z] % des_in [z] %
org_out [z] % des_out [z] % (org_out [z] - org_in [z]) % (des_out [z] - des_in [z]));
}
Print (2, String (" Total %8d %8d %8d %8d %8d %8d") % org_in_tot % des_in_tot %
org_out_tot % des_out_tot % (org_out_tot - org_in_tot) % (des_out_tot - des_in_tot));
Header_Number (0);
}
void ModeChoice::Value_Summary (int segment)
{
int i, j;
double value, trips;
Doubles *mode_ptr;
header_value = segment;
Header_Number (MODE_VALUES);
if (!Break_Check (num_modes + 5)) {
Print (1);
Value_Header ();
}
//---- process each mode ----
for (i=0; i < num_modes; i++) {
mode_ptr = &value_sum [segment] [i];
trips = mode_ptr->at (const_field);
if (trips <= 0) continue;
Print (1, String ("%-20s") % mode_names [i]);
for (j=0; j < const_field; j++) {
value = mode_ptr->at (j) / trips;
Print (0, String (" %7.2lf") % value);
}
Print (0, String (" %8.0lf") % trips);
}
Header_Number (0);
}
void EventSum::Page_Header (void)
{
switch (Header_Number ()) {
case TOP_100_TTIME: //---- top 100 travel time differences ----
Top_100_TTime_Header ();
break;
case TOTAL_DISTRIB: //---- total difference distribution ----
case TTIME_DISTRIB: //---- time difference distributions ----
case PERIOD_SUM: //---- time period summary ----
time_diff.Report_Header (Header_Number ());
break;
case TOP_100_LINK:
Top_100_Link_Header ();
break;
case TOP_100_PERIOD: //---- top 100 period events ----
Top_100_Period_Header ();
break;
case LINK_EVENT: //---- link event report -----
Link_Event_Header ();
break;
case GROUP_EVENT: //---- group event report ----
Group_Event_Header ();
break;
case TRAVELER_SUM: //---- traveler summary report ----
Traveler_Sum_Header ();
break;
case EVENT_SUM: //---- event summary report ----
Event_Sum_Header ();
break;
default:
break;
}
}
void ActivityPattern::Read_Scripts (void)
{
Print (1);
//---- read the household type script ----
if (hhold_type_flag) {
Write (1, "Compiling Household Type Script");
if (Report_Flag (HOUSEHOLD_SCRIPT)) {
Header_Number (HOUSEHOLD_SCRIPT);
if (!Break_Check (10)) {
Print (1);
Page_Header ();
}
}
hhold_type.Set_Files (1, Demand_Db_Base (HOUSEHOLD));
if (!hhold_type.Compile (&hhold_type_file, Report_Flag (HOUSEHOLD_SCRIPT))) {
Error ("Compiling Household Type Script");
}
if (Report_Flag (HOUSEHOLD_STACK)) {
Header_Number (HOUSEHOLD_STACK);
hhold_type.Print_Commands (false);
}
}
//---- read the survey type script ----
if (survey_type_flag) {
Write (1, "Compiling Survey Type Script");
if (Report_Flag (SURVEY_SCRIPT)) {
Header_Number (SURVEY_SCRIPT);
if (!Break_Check (10)) {
Print (1);
Page_Header ();
}
}
survey_type.Set_Files (1, &survey_hh_file);
if (!survey_type.Compile (&survey_type_file, Report_Flag (SURVEY_SCRIPT))) {
Error ("Compiling Survey Type Script");
}
if (Report_Flag (SURVEY_STACK)) {
Header_Number (SURVEY_STACK);
survey_type.Print_Commands (false);
}
}
Header_Number (0);
Show_Message (1);
}
void PlanSum::Trip_Time (void)
{
int i, start_total, mid_total, end_total;
double start, mid, end;
Show_Message ("Trip Time Report");
//---- get the total number of trips ----
start_total = mid_total = end_total = 0;
for (i=1; i <= num_inc; i++) {
start_total += start_time [i];
mid_total += mid_time [i];
end_total += end_time [i];
}
if (start_total == 0 && mid_total == 0 && end_total == 0) {
Write (2, "Trip Time Data is Zero");
return;
}
if (start_total == 0) {
start = 1.0;
} else {
start = start_total;
}
if (mid_total == 0) {
mid = 1.0;
} else {
mid = mid_total;
}
if (end_total == 0) {
end = 1.0;
} else {
end = end_total;
}
//---- print the report ----
Header_Number (TRIP_TIME);
if (!Break_Check (num_inc + 7)) {
Print (1);
Trip_Time_Header ();
}
for (i=1; i <= num_inc; i++) {
Print (1, "%-12.12s %10d %6.2lf %10d %6.2lf %10d %6.2lf",
time_periods.Range_Format (i),
start_time [i], 100.0 * start_time [i] / start,
mid_time [i], 100.0 * mid_time [i] / mid_total,
end_time [i], 100.0 * end_time [i] / end_total);
}
Print (2, "Total %10d 100.00 %10d 100.00 %10d 100.00", start_total, mid_total, end_total);
Header_Number (0);
}
void TripSum::Trip_Diurnal_Report (void)
{
int p, start_total, mid_total, end_total, num_periods;
double start, mid, end;
//---- get the total number of trips ----
num_periods = sum_periods.Num_Periods ();
start_total = mid_total = end_total = 0;
for (p=0; p < num_periods; p++) {
start_total += start_time [p];
mid_total += mid_time [p];
end_total += end_time [p];
}
if (start_total == 0 && mid_total == 0 && end_total == 0) {
Write (2, "Time Distribution Data is Zero");
return;
}
if (start_total == 0) {
start = 1.0;
} else {
start = start_total;
}
if (mid_total == 0) {
mid = 1.0;
} else {
mid = mid_total;
}
if (end_total == 0) {
end = 1.0;
} else {
end = end_total;
}
//---- print the report ----
Header_Number (TRIP_DIURNAL);
if (!Break_Check (num_periods + 7)) {
Print (1);
Trip_Time_Header ();
}
for (p=0; p < num_periods; p++) {
Print (1, String ("%-12.12s %10d %6.2lf %10d %6.2lf %10d %6.2lf") %
sum_periods.Range_Format (p) %
start_time [p] % (100.0 * start_time [p] / start) %
mid_time [p] % (100.0 * mid_time [p] / mid) %
end_time [p] % (100.0 * end_time [p] / end));
}
Print (2, String ("Total %10d 100.00 %10d 100.00 %10d 100.00") % start_total % mid_total % end_total);
Header_Number (0);
}
void ModeChoice::Mode_Summary (int segment)
{
int i;
double total, percent;
String text;
Doubles *mode_ptr;
Dbl_Itr tab_itr;
header_value = segment;
Header_Number (MODE_SUMMARY);
if (!Break_Check (num_modes + 8)) {
Print (1);
Mode_Header ();
}
//---- get the total number of trips ----
total = market_seg [segment] [num_modes] [num_tables];
if (total == 0.0) return;
//---- process each mode ----
for (i=0; i <= num_modes; i++) {
if (i == num_modes) {
Print (1);
text = "Total";
} else {
text = mode_names [i];
}
Print (1, String ("%-20s") % text);
mode_ptr = &market_seg [segment] [i];
for (tab_itr = mode_ptr->begin (); tab_itr != mode_ptr->end (); tab_itr++) {
Print (0, String (" %10.1lf") % *tab_itr);
}
percent = mode_ptr->at (num_tables) * 100.0 / total;
Print (0, String (" %6.2lf%%") % percent % FINISH);
}
//---- table percents ----
text = "Percent";
Print (1, String ("%-20s") % text);
mode_ptr = &market_seg [segment] [num_modes];
for (tab_itr = mode_ptr->begin (); tab_itr != mode_ptr->end (); tab_itr++) {
percent = *tab_itr * 100.0 / total;
Print (0, String (" %6.2lf%%") % percent % FINISH);
}
Header_Number (0);
}
void ConvertTrips::Page_Header (void)
{
switch (Header_Number ()) {
case GROUP_SCRIPT: //---- Tour Group Script ----
Print (1, "Tour Group Script");
Print (1);
break;
case GROUP_STACK: //---- Tour Group Stack ----
Print (1, "Tour Group Stack");
Print (1);
break;
case DIURNAL_SCRIPT: //---- Time Distribution Script ----
Print (1, "Time Distribution Script #") << group_number;
Print (1);
break;
case DIURNAL_STACK: //---- Time Distribution Stack ----
Print (1, "Time Distribution Stack #") << group_number;
Print (1);
break;
case TRAVELER_SCRIPT: //---- Traveler Type Script ----
Print (1, "Traveler Type Script #") << group_number;
Print (1);
break;
case TRAVELER_STACK: //---- Traveler Type Stack ----
Print (1, "Traveler Type Stack #") << group_number;
Print (1);
break;
case ZONE_TRIP_ENDS: //---- Zone Trip Ends ----
Zone_Sum_Header ();
break;
default:
break;
}
}
void Converge_Service::Trip_Gap_Report (int report)
{
int i;
double gap, max, diff, total, std_dev, rmse, num;
Gap_Sum_Itr gap_itr;
Header_Number (report);
if (!Break_Check ((int) trip_gap_array.size () + 7)) {
Print (1);
Trip_Gap_Header ();
}
for (i=1, gap_itr = trip_gap_array.begin (); gap_itr != trip_gap_array.end (); gap_itr++, i++) {
if (gap_itr->count == 0) continue;
num = gap_itr->count;
total = gap_itr->current;
diff = gap_itr->abs_diff;
max = gap_itr->max_gap;
if (total > 0.0) {
gap = diff / total;
rmse = 100.0 * sqrt (gap_itr->diff_sq / num) * num / total;
if (num > 1) {
std_dev = (gap_itr->diff_sq - diff * diff / num) / (num - 1.0);
std_dev = (std_dev > 0.0) ? sqrt (std_dev) : 0.0;
std_dev = std_dev * num / total;
} else {
std_dev = 0.0;
}
total /= 100;
diff /= 100;
} else {
gap = 1.0;
std_dev = rmse = 0.0;
}
//---- print the data record ----
Print (1, String ("%6d %13.6lf %13.6lf %13.6lf %9.1lf %13.0lf %13.0lf") %
i % gap % std_dev % max % rmse % diff % total);
}
Header_Number (0);
}
void IntControl::Page_Header (void)
{
switch (Header_Number ()) {
case TIMING_UPDATE: //---- Signal Timing Update ----
Update_Header ();
break;
default:
break;
}
}
void NewLandUse::Page_Header (void)
{
switch (Header_Number ()) {
case GROUP_REPORT:
Group_Header ();
break;
default:
break;
}
}
void GISNet::Execute (void)
{
//---- read the conversion script ----
if (convert_flag) {
if (Report_Flag (SCRIPT_REPORT)) {
Header_Number (SCRIPT_REPORT);
if (!Break_Check (10)) {
Print (1);
Page_Header ();
}
}
convert.Set_Files (2, &gis_file, Network_Db_Base (NEW_LINK));
if (!convert.Compile (&script_file, Report_Flag (SCRIPT_REPORT))) {
Error ("Compiling Conversion Script");
}
if (Report_Flag (STACK_REPORT)) {
Header_Number (STACK_REPORT);
convert.Print_Commands (false);
}
Header_Number (0);
}
//---- gis node file ----
if (node_flag) {
Read_Node ();
}
//---- gis link file ----
Read_Link ();
//---- end the program ----
Exit_Stat (DONE);
}
void Relocate::Location_Map_Report (void)
{
Location_Itr loc_itr;
Location_Data *loc_ptr;
Int_Map_Itr map_itr;
Header_Number (LOCATION_MAP);
if (!Break_Check ((int) location_map.size () + 8)) {
Print (1);
Location_Map_Header ();
}
for (loc_itr = location_array.begin (); loc_itr != location_array.end (); loc_itr++) {
if (loc_itr->Zone () == 2) {
if (loc_itr->Offset () == -1) continue;
Print (1, String ("%10d %10d %s") % 0 % loc_itr->Location () % "Unused Target Location");
} else if (loc_itr->Zone () == 0) {
Print (1, String ("%10d %10d %s") % loc_itr->Location () % 0 % "Location Not Mapped");
} else {
map_itr = target_loc_map.find (loc_itr->Location ());
if (map_itr != target_loc_map.end ()) {
loc_ptr = &location_array [map_itr->second];
loc_ptr->Offset (-1);
if (loc_itr->Zone () == 1) {
Print (1, String ("%10d %10d %s") % loc_itr->Location () % loc_ptr->Location () % "Location on the Same Link");
} else {
Print (1, String ("%10d %10d %s") % loc_itr->Location () % loc_ptr->Location () % "Location Near By");
}
}
}
}
Header_Number (0);
}
void ActivityPattern::Read_Survey (void)
{
//---- read the survey household weights ----
if (weight_flag) {
Survey_Weights ();
}
//---- read the survey household data ----
Survey_Households ();
//---- survey type summary report ----
if (Report_Flag (SURVEY_TYPE)) {
Header_Number (SURVEY_TYPE);
if (!Break_Check (type_data.Num_Records () + 4)) {
Print (1);
Page_Header ();
}
Type_Data *type_ptr;
for (type_ptr = type_data.First_Key (); type_ptr; type_ptr = type_data.Next_Key ()) {
Print (1, "%4d %8d %15.6lf %14.6lf",
type_ptr->Type (), type_ptr->Num_Survey (), type_ptr->Cum_Weight (),
type_ptr->Cum_Weight () / ((type_ptr->Num_Survey () > 0) ? type_ptr->Num_Survey () : 1));
}
Header_Number (0);
}
//---- read the survey popoulation data ----
Survey_Population ();
//---- read the survey activity data ----
Survey_Activity ();
}
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 EventSum::Traveler_Sum_Report (void)
{
int i;
Show_Message ("Traveler Summary Report");
//---- print the report ----
Header_Number (TRAVELER_SUM);
if (!Break_Check (num_inc + 7)) {
Print (1);
Traveler_Sum_Header ();
}
for (i=1; i <= time_periods.Num_Ranges (); i++) {
Print (1, "%-12.12s %10d %6.2lf %10d %6.2lf %10d %6.2lf",
time_periods.Range_Format (i));
}
Print (2, "Total %10d 100.00 %10d 100.00 %10d 100.00");
Header_Number (0);
}
void TPPlusNet::Page_Header (void)
{
switch (Header_Number ()) {
case SCRIPT_REPORT: //---- Conversion Script ----
Print (1, "Conversion Script");
Print (1);
break;
case STACK_REPORT: //---- Conversion Stack ----
Print (1, "Conversion Stack");
Print (1);
break;
default:
break;
}
}
void ConvertTours::Page_Header (void)
{
switch (Header_Number ()) {
case SCRIPT_REPORT: //---- Conversion Script ----
Print (1, "Tour Group Script");
Print (1);
break;
case STACK_REPORT: //---- Conversion Stack ----
Print (1, "Tour Group Stack");
Print (1);
break;
default:
break;
}
}
void PlanPrep::Page_Header (void)
{
switch (Header_Number ()) {
case PATH_CHANGE:
Path_Change_Header ();
break;
case TIME_CHANGE:
Time_Change_Header ();
break;
case FIX_PLAN:
Fix_Plan_Header ();
break;
default:
break;
}
}
void PlanSum::Page_Header (void)
{
switch (Header_Number ()) {
case TOP_100: //---- Top 100 V/C Ratio Report ----
Top_100_Header ();
break;
case VC_RATIO: //---- All V/C Ratios Greater Than x.xx ---
VC_Ratio_Header ();
break;
case LINK_GROUP: //---- Link Group Report -----
Link_Group_Header ();
break;
case SUM_RIDERS: //---- Transit Ridership Report ----
Transit_Header ();
break;
case SUM_STOPS: //---- Transit Stop Report ----
Stop_Header ();
break;
case SUM_TRANSFERS: //---- Transit Transfer Report ----
case XFER_DETAILS: //---- Transit Transfer Details ----
Transfer_Header ();
break;
case STOP_GROUP: //---- Transit Stop Group Report ----
Stop_Group_Header ();
break;
case SUM_PASSENGERS: //---- Transit Passenger Summary ----
Passenger_Header ();
break;
case RIDER_GROUP: //---- Transit Link Group Summary ----
Rider_Header ();
break;
case TRIP_TIME: //---- Trip Time Report ----
Trip_Time_Header ();
break;
case SUM_TRAVEL: //---- Travel Summary Report ----
Travel_Header ();
break;
default:
break;
}
}
void CheckSurvey::Page_Header (void)
{
switch (Header_Number ()) {
case SURVEY_SCRIPT: //---- Survey Type Script ----
Print (1, "Survey Type Script");
Print (1);
break;
case SURVEY_STACK: //---- Survey Type Stack ----
Print (1, "Survey Type Stack");
Print (1);
break;
case SURVEY_TYPE: //---- Survey Type Summary ----
Print (1, "Survey Type Summary");
Print (2, "Type Households Cumulative Weight Average Weight");
Print (1);
break;
case TRIP_LENGTH: //---- Trip Length Summary ----
trip_length.Header ();
break;
case TOUR_LENGTH: //---- Tour Length Summary ----
tour_length.Header ();
break;
case TRIP_PURPOSE: //---- Trip Purpose Summary ----
trip_purpose.Header ();
break;
case TOUR_PURPOSE: //---- Tour Purpose Summary ----
tour_purpose.Header ();
break;
case MODE_LENGTH: //---- Mode Length Summary ----
mode_length.Header ();
break;
case MODE_PURPOSE: //---- Mode Purpose Summary ----
mode_purpose.Header ();
break;
default:
break;
}
}
void LinkSum::Perf_Detail_Report (void)
{
int i, j, k, k1, lanes, max_lanes, tod_list, index, flow_index;
double base_time, loaded_time, length, len, base, diff, value, percent, flow, factor;
Dtime low, high, tod;
bool connect_flag;
String units, vmt, lane_mi;
Link_Itr link_itr;
Dir_Data *dir_ptr;
Link_Perf_Period_Itr period_itr;
Link_Perf_Array *period_ptr;
Link_Perf_Data perf_data;
Flow_Time_Period_Itr turn_itr;
Flow_Time_Array *compare_ptr;
Flow_Time_Data *turn_ptr;
Lane_Use_Period *use_ptr;
Connect_Data *connect_ptr;
Doubles_Itr itr;
Show_Message ("Creating the Network Performance Details Report -- Record");
Set_Progress ();
//---- clear the summary bins -----
for (j=0, itr = sum_bin.begin (); itr != sum_bin.end (); itr++, j++) {
itr->assign (NUM_SUM_BINS, 0.0);
}
connect_flag = System_Data_Flag (CONNECTION) && (turn_perf_array.size () > 0) && (compare_turn_array.size () > 0);
//---- process each link ----
for (link_itr = link_array.begin (); link_itr != link_array.end (); link_itr++) {
Show_Progress ();
if (select_flag && link_itr->Use () == 0) continue;
length = UnRound (link_itr->Length ());
len = 0;
for (i=0; i < 2; i++) {
if (i) {
if (link_itr->Use () == -1) continue;
index = link_itr->BA_Dir ();
} else {
if (link_itr->Use () == -2) continue;
index = link_itr->AB_Dir ();
}
if (index < 0) continue;
dir_ptr = &dir_array [index];
flow_index = dir_ptr->Flow_Index ();
base_time = dir_ptr->Time0 ();
if (base_time <= 0.0) continue;
tod_list = dir_ptr->First_Lane_Use ();
max_lanes = dir_ptr->Lanes ();
if (max_lanes < 1) max_lanes = 1;
lanes = max_lanes;
if (len == 0) {
len = length;
} else {
len = 0;
}
//---- process each time period ----
for (j=0, period_itr = link_perf_array.begin (); period_itr != link_perf_array.end (); period_itr++, j++) {
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;
}
}
perf_data = period_itr->Total_Link_Perf (index, flow_index);
loaded_time = perf_data.Time ();
flow = perf_data.Flow ();
sum_bin [j] [LINKS] += 1;
sum_bin [j] [LENGTH] += len;
sum_bin [j] [LANES] += lanes * length;
sum_bin [j] [VMT] += flow * length;
sum_bin [j] [VHT] += flow * loaded_time;
sum_bin [j] [VHD] += flow * (loaded_time - base_time);
sum_bin [j] [TIME_RATIO] += (double) loaded_time / base_time;
sum_bin [j] [DENSITY] += perf_data.Density ();
sum_bin [j] [MAX_DEN] = MAX (sum_bin [j] [MAX_DEN], perf_data.Max_Density ());
sum_bin [j] [QUEUE] += perf_data.Queue ();
sum_bin [j] [MAX_QUEUE] = MAX (sum_bin [j] [MAX_QUEUE], perf_data.Max_Queue ());
sum_bin [j] [FAILURE] += perf_data.Failure ();
if (Ratio_Flag ()) {
sum_bin [j] [CONG_VMT] += perf_data.Ratio_VMT ();
sum_bin [j] [CONG_VHT] += perf_data.Ratio_VHT ();
sum_bin [j] [CONG_TIME] += perf_data.Ratio_Count ();
sum_bin [j] [COUNT] += perf_data.Occupancy ();
}
if (compare_flag) {
period_ptr = &compare_link_array [j];
perf_data = period_ptr->Total_Link_Perf (index, flow_index);
loaded_time = perf_data.Time ();
flow = perf_data.Flow ();
sum_bin [j] [VMT+PREV] += flow * length;
sum_bin [j] [VHT+PREV] += flow * loaded_time;
sum_bin [j] [VHD+PREV] += flow * (loaded_time - base_time);
sum_bin [j] [TIME_RATIO+PREV] += (double) loaded_time / base_time;
sum_bin [j] [DENSITY+PREV] += perf_data.Density ();
sum_bin [j] [MAX_DEN+PREV] = MAX (sum_bin [j] [MAX_DEN+PREV], perf_data.Max_Density ());
sum_bin [j] [QUEUE+PREV] += perf_data.Queue ();
sum_bin [j] [MAX_QUEUE+PREV] = MAX (sum_bin [j] [MAX_QUEUE+PREV], perf_data.Max_Queue ());
sum_bin [j] [FAILURE+PREV] += perf_data.Failure ();
if (Ratio_Flag ()) {
sum_bin [j] [CONG_VMT+PREV] += perf_data.Ratio_VMT ();
sum_bin [j] [CONG_VHT+PREV] += perf_data.Ratio_VHT ();
sum_bin [j] [CONG_TIME+PREV] += perf_data.Ratio_Count ();
sum_bin [j] [COUNT+PREV] += perf_data.Occupancy ();
}
}
}
//---- get the turning movements ----
if (connect_flag) {
for (k=dir_ptr->First_Connect (); k >= 0; k = connect_ptr->Next_Index ()) {
connect_ptr = &connect_array [k];
if (connect_ptr->Type () != LEFT && connect_ptr->Type () != RIGHT &&
connect_ptr->Type () != UTURN) continue;
for (j=0, turn_itr = turn_perf_array.begin (); turn_itr != turn_perf_array.end (); turn_itr++, j++) {
turn_ptr = &turn_itr->at (k);
sum_bin [j] [TURNS] += turn_ptr->Flow ();
if (compare_flag) {
compare_ptr = &compare_turn_array [j];
turn_ptr = &compare_ptr->at (k);
sum_bin [j] [TURNS+PREV] += turn_ptr->Flow ();
}
}
}
}
}
}
End_Progress ();
//---- print the report ----
Header_Number (PERF_DETAIL);
if (!Break_Check (num_inc * 16)) {
Print (1);
Perf_Detail_Header ();
}
if (Metric_Flag ()) {
factor = 1.0 / 1000.0;
units = "Kilometers";
vmt = "VKT";
lane_mi = "km";
} else {
factor = 1.0 / MILETOFEET;
units = "Miles";
vmt = "VMT";
lane_mi = "mi";
}
tod.Hours (1);
for (i=0; i <= num_inc; i++) {
len = sum_bin [i] [LINKS];
if (len == 0.0) continue;
if (i < num_inc) {
for (k = 0; k <= COUNT; k++) {
k1 = k + PREV;
if (k < VMT) {
sum_bin [num_inc] [k] = MAX (sum_bin [i] [k], sum_bin [num_inc] [k]);
if (compare_flag) {
sum_bin [num_inc] [k1] = MAX (sum_bin [i] [k1], sum_bin [num_inc] [k1]);
}
} else {
sum_bin [num_inc] [k] += sum_bin [i] [k];
if (compare_flag) {
sum_bin [num_inc] [k1] += sum_bin [i] [k1];
}
}
}
}
if (i < num_inc && sum_bin [i] [VHT] == 0.0 && (!compare_flag || sum_bin [i] [VHT+PREV] == 0.0)) continue;
if (i) {
if (!Break_Check ((Ratio_Flag () ? 19 : 16))) {
Print (1);
}
}
Print (1, String ("Time Period%22c") % BLANK);
if (i == num_inc) {
Print (0, " Total");
len *= num_inc;
} else {
Print (0, String ("%12.12s") % sum_periods.Range_Format (i));
}
Print (1, String ("Number of Links %13.2lf") % sum_bin [i] [LINKS]);
Print (1, String ("Number of Roadway %-10.10s %13.2lf") % units % (sum_bin [i] [LENGTH] * factor));
Print (1, String ("Number of Lane %-10.10s %13.2lf") % units % (sum_bin [i] [LANES] * factor));
Print (1, String ("Vehicle %-20.20s %13.2lf") % (units + " of Travel") % (sum_bin [i] [VMT] * factor));
if (compare_flag) {
base = sum_bin [i] [VMT+PREV] * factor;
diff = sum_bin [i] [VMT] * factor - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
Print (1, String ("Vehicle Hours of Travel %13.2lf") % (sum_bin [i] [VHT] / tod));
if (compare_flag) {
base = sum_bin [i] [VHT+PREV] / tod;
diff = sum_bin [i] [VHT] / tod - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
Print (1, String ("Vehicle Hours of Delay %13.2lf") % (sum_bin [i] [VHD] / tod));
if (compare_flag) {
base = sum_bin [i] [VHD+PREV] / tod;
diff = sum_bin [i] [VHD] / tod - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
Print (1, String ("Number of Queued Vehicles %13.2lf") % UnRound (sum_bin [i] [QUEUE]));
if (compare_flag) {
base = sum_bin [i] [QUEUE+PREV];
diff = sum_bin [i] [QUEUE] - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
Print (1, String ("Maximum Queued Vehicles %13.2lf") % sum_bin [i] [MAX_QUEUE]);
if (compare_flag) {
base = sum_bin [i] [MAX_QUEUE+PREV];
diff = sum_bin [i] [MAX_QUEUE] - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
Print (1, String ("Number of Cycle Failures %13.2lf") % sum_bin [i] [FAILURE]);
if (compare_flag) {
base = sum_bin [i] [FAILURE+PREV];
diff = sum_bin [i] [FAILURE] - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
Print (1, String ("Number of Turning Movements %13.2lf") % sum_bin [i] [TURNS]);
if (compare_flag) {
base = sum_bin [i] [TURNS+PREV];
diff = sum_bin [i] [TURNS] - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
Print (1, String ("Average Link Time Ratio %13.2lf") % (sum_bin [i] [TIME_RATIO] / len));
if (compare_flag) {
base = sum_bin [i] [TIME_RATIO+PREV] / len;
diff = sum_bin [i] [TIME_RATIO] / len - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
Print (1, String ("Average Link Density (/ln-%s) %13.2lf") % lane_mi % UnRound (sum_bin [i] [DENSITY] / len));
if (compare_flag) {
base = UnRound (sum_bin [i] [DENSITY+PREV] / len);
diff = UnRound (sum_bin [i] [DENSITY] / len) - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
Print (1, String ("Maximum Link Density (/ln-%s) %13.2lf") % lane_mi % UnRound (sum_bin [i] [MAX_DEN]));
if (compare_flag) {
base = UnRound (sum_bin [i] [MAX_DEN+PREV]);
diff = UnRound (sum_bin [i] [MAX_DEN]) - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
length = sum_bin [i] [VMT] * factor;
loaded_time = sum_bin [i] [VHT] / tod;
if (loaded_time == 0.0) {
loaded_time = length;
} else {
loaded_time = length / loaded_time;
}
Print (1, String ("Average %-19.19s %13.2lf") % (units + " per Hour") % loaded_time);
if (compare_flag) {
length = sum_bin [i] [VMT+PREV] * factor;
base = sum_bin [i] [VHT+PREV] / tod;
if (base == 0.0) {
base = length;
} else {
base = length / base;
}
diff = loaded_time - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
if (Ratio_Flag ()) {
value = sum_bin [i] [VMT];
if (value == 0.0) value = 1.0;
percent = 100.0 * sum_bin [i] [CONG_VMT] / value;
Print (1, String ("Percent %s Congested %13.2lf") % vmt % percent);
if (compare_flag) {
value = sum_bin [i] [VMT+PREV];
if (value == 0.0) value = 1.0;
base = 100.0 * sum_bin [i] [CONG_VMT+PREV] / value;
diff = percent - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
value = sum_bin [i] [VHT];
if (value == 0.0) value = 1.0;
percent = 100.0 * sum_bin [i] [CONG_VHT] / value;
Print (1, String ("Percent VHT Congested %13.2lf") % percent);
if (compare_flag) {
value = sum_bin [i] [VHT+PREV];
if (value == 0.0) value = 1.0;
base = 100.0 * sum_bin [i] [CONG_VHT+PREV] / value;
diff = percent - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
value = sum_bin [i] [COUNT];
if (value == 0.0) value = 1.0;
percent = 100.0 * sum_bin [i] [CONG_TIME] / value;
Print (1, String ("Percent Time Congested %13.2lf") % percent);
if (compare_flag) {
value = sum_bin [i] [COUNT+PREV];
if (value == 0.0) value = 1.0;
base = 100.0 * sum_bin [i] [CONG_TIME+PREV] / value;
diff = percent - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
}
}
Header_Number (0);
}
void RiderSum::Line_Rider_Report (void)
{
int riders, board, alight, run, runs, num, length, tot_len, period, num_periods;
int max_riders, max_board, max_alight, max_runs, total, capacity, max_cap;
double factor, max_fac, sum_time, tot_time, time, capfac, max_capfac;
double vmt, vht, pmt, pht;
Dtime low, high;
Int_Map_Itr map_itr;
Line_Data *line_ptr;
Stop_Data *stop_ptr;
Line_Stop_Itr stop_itr, next_itr;
Line_Run_Itr run_itr;
Veh_Type_Data *veh_type_ptr, *run_type_ptr;
Show_Message ("Line Rider Profile -- Record");
Set_Progress ();
//---- print the report ----
Header_Number (LINE_RIDERS);
num_periods = sum_periods.Num_Periods ();
if (num_periods == 0) num_periods = 1;
num = (int) (line_map.size () * stop_map.size ());
if (!Break_Check (num + 5)) {
Print (1);
Line_Rider_Header ();
}
//---- process each route ----
for (map_itr = line_map.begin (); map_itr != line_map.end (); map_itr++) {
Show_Progress ();
if (select_routes && !route_range.In_Range (map_itr->first)) continue;
line_ptr = &line_array [map_itr->second];
if (select_modes && !select_mode [line_ptr->Mode ()]) continue;
//---- check the link criteria ----
if (!Link_Selection (line_ptr)) continue;
//---- set the run flags ----
if (!Run_Selection (line_ptr)) continue;
//---- save the route ridership data ----
veh_type_ptr = &veh_type_array [line_ptr->Type ()];
for (period = 0; period < num_periods; period++) {
if (period_flag [period] == 0) continue;
if (!Break_Check ((int) line_ptr->size () + 15)) {
Print (1);
Line_Rider_Header ();
}
veh_type_ptr = &veh_type_array [line_ptr->Type ()];
Print (1, " Route Mode Type Time Period Name");
Print (2, String ("%8d %10.10s %4d %12.12s") % line_ptr->Route () %
Transit_Code ((Transit_Type) line_ptr->Mode ()) % veh_type_ptr->Type () %
sum_periods.Range_Format (period));
if (!line_ptr->Name ().empty ()) {
Print (0, String (" %s") % line_ptr->Name ());
}
if (Notes_Name_Flag ()) {
if (!line_ptr->Notes ().empty ()) {
Print (0, String (" -- %s") % line_ptr->Notes ());
}
}
Print (2, " Stop Length TTime Alight Board Riders Runs LoadFac Capacity CapFac");
Print (1);
time = tot_time = 0.0;
max_alight = max_board = max_riders = max_runs = total = length = tot_len = max_cap = 0;
max_fac = vmt = vht = pmt = pht = max_capfac = 0.0;
sum_periods.Period_Range (period, low, high);
for (stop_itr = line_ptr->begin (); stop_itr != line_ptr->end (); stop_itr++) {
riders = board = alight = runs = capacity = 0;
stop_ptr = &stop_array [stop_itr->Stop ()];
next_itr = stop_itr + 1;
if (next_itr != line_ptr->end ()) {
length = next_itr->Length () - stop_itr->Length ();
} else {
length = 0;
}
sum_time = 0.0;
num = 0;
for (run=0, run_itr = stop_itr->begin (); run_itr != stop_itr->end (); run_itr++, run++) {
if (run_flag [run] == 0) continue;
if (run_period [run] != period) continue;
board += run_itr->Board ();
alight += run_itr->Alight ();
riders += run_itr->Load ();
runs++;
if (line_ptr->run_types.size () > 0) {
run_type_ptr = &veh_type_array [line_ptr->Run_Type (run)];
capacity += run_type_ptr->Capacity ();
} else {
capacity += veh_type_ptr->Capacity ();
}
if (next_itr != line_ptr->end ()) {
time = next_itr->at (run).Schedule ().Seconds () - run_itr->Schedule ().Seconds ();
vmt += length;
vht += time;
pmt += length * run_itr->Load ();
pht += time * run_itr->Load ();
sum_time += time;
num++;
}
}
if (runs == 0) continue;
if (capacity == 0) capacity = runs;
factor = (double) riders / runs;
capfac = DTOI (riders * 10.0 / capacity) / 10.0;
if (next_itr == line_ptr->end ()) runs = 0;
if (num > 0) {
time = sum_time / num;
} else {
time = 0;
}
Print (1, String ("%8d %7.0lf %7.0lf %8d %8d %8d %5d %8.1lf %6d %8.1lf") % stop_ptr->Stop () %
UnRound (length) % time % alight % board % riders % runs % factor % capacity % capfac);
if (Notes_Name_Flag ()) {
if (!stop_ptr->Name ().empty ()) {
Print (0, String (" %s") % stop_ptr->Name ());
}
if (!stop_ptr->Notes ().empty ()) {
Print (0, " -- ") << stop_ptr->Notes ();
}
}
if (alight > max_alight) max_alight = alight;
if (board > max_board) max_board = board;
if (riders > max_riders) max_riders = riders;
if (runs > max_runs) max_runs = runs;
if (factor > max_fac) max_fac = factor;
if (capacity > max_cap) max_cap = capacity;
if (capfac > max_capfac) max_capfac = capfac;
tot_len += length;
tot_time += time;
total += board;
}
if (max_runs == 0) continue;
Print (2, String (" Maximum %8ld %8ld %8ld %5ld %8.1lf %6lf %8.1lf") %
max_alight % max_board % max_riders % max_runs % max_fac % max_cap % max_capfac);
Print (2, "Total Boardings = ") << total;
if (total == 0 || tot_time == 0) continue;
factor = UnRound (tot_len);
vmt = UnRound (vmt) / 5280.0;
vht = vht / 3600.0;
pmt = UnRound (pmt) / 5280.0;
pht = pht / 3600.0;
Print (1, String ("Route Length = %.1lf miles, %.1lf minutes Average Speed = %.1lf mph") %
External_Units (factor, MILES) % (tot_time / 60.0) % External_Units ((factor / tot_time), MPH));
Print (1, String ("Vehicle Miles = %.1lf Vehicle Hours = %.1lf") % vmt % vht);
Print (1, String ("Passenger Miles = %.1lf Passenger Hours = %.1lf") % pmt % pht);
Print (1, String ("Passengers per Vehicle Mile = %.1lf Passengers per Vehicle Hour = %.1lf") %
(pmt / vht) % (pht / vht));
vmt = pmt / total;
vht = pht * 60.0 / total;
Print (1, String ("Average Trip Length = %.1lf miles, %.1lf minutes") % vmt % vht);
}
}
End_Progress ();
Header_Number (0);
}
void PlanSum::Rider_Group (void)
{
int i, j, num, dir, length, link, previous_period, period, dir_index, periods;
String label;
bool flag;
Int_Set *group;
Int_Set_Itr link_itr;
Line_Itr line_itr;
Line_Stop_Itr stop_itr;
Line_Run_Itr run_itr;
Driver_Array *driver_ptr;
Driver_Itr driver_itr;
Link_Data *link_ptr;
Dir_Data *dir_ptr;
Group_Data group_data, *group_ptr;
Group_Array group_array;
Group_Itr group_itr;
memset (&group_data, '\0', sizeof (group_data));
periods = sum_periods.Num_Periods ();
if (periods < 1) periods= 1;
Show_Message ("Writing Transit Link Groups -- Record");
Set_Progress ();
//---- find each link group ----
num = link_equiv.Num_Groups ();
Header_Number (RIDER_GROUP);
if (!Break_Check (num + 7)) {
Print (1);
Rider_Header ();
}
num = link_equiv.Max_Group ();
for (i=1; i <= num; i++) {
group = link_equiv.Group_List (i);
if (group == 0) continue;
group_array.assign (periods, group_data);
label = link_equiv.Group_Label (i);
flag = false;
memset (&group_data, '\0', sizeof (group_data));
//---- write data for each line ----
for (line_itr = line_array.begin (); line_itr != line_array.end (); line_itr++) {
Show_Progress ();
driver_ptr = &line_itr->driver_array;
//---- process each link in the link group ----
for (link_itr = group->begin (); link_itr != group->end (); link_itr++) {
link = *link_itr;
if (link < 0) {
link = -link;
dir = 1;
} else {
dir = 0;
}
link_ptr = &link_array [link];
dir_index = (dir == 0) ? link_ptr->AB_Dir () : link_ptr->BA_Dir ();
//---- search for the link on the route ----
length = 0;
for (driver_itr = driver_ptr->begin (); driver_itr != driver_ptr->end (); driver_itr++) {
dir_ptr = &dir_array [*driver_itr];
link_ptr = &link_array [dir_ptr->Link ()];
if (*driver_itr == dir_index) {
length += link_ptr->Length () / 2;
break;
}
length += link_ptr->Length ();
}
for (stop_itr = line_itr->begin (); stop_itr != line_itr->end (); stop_itr++) {
if (stop_itr->Length () > length) {
if (stop_itr > line_itr->begin ()) {
stop_itr--;
previous_period = -1;
for (run_itr = stop_itr->begin (); run_itr != stop_itr->end (); run_itr++) {
period = sum_periods.Period (run_itr->Schedule ());
if (period < 0) continue;
group_ptr = &group_array [period];
if (period != previous_period) {
previous_period = period;
group_ptr->lines++;
}
group_ptr->runs++;
group_ptr->riders += run_itr->Load ();
}
}
flag = true;
break;
}
}
}
}
if (!flag) continue;
//---- print the link group data ----
flag = true;
for (j=0, group_itr = group_array.begin (); group_itr != group_array.end (); group_itr++, j++) {
if (group_itr->lines == 0) continue;
if (flag) {
Print (1, String ("%3d %-40.40s") % i % label);
flag = false;
} else {
Print (1, String ("%44c") % BLANK);
}
Print (0, String ("%5d %6d %12.12s %7d") %
group_itr->lines % group_itr->runs %
sum_periods.Range_Format (j) % group_itr->riders);
}
if (j > 1) Print (1);
}
End_Progress ();
Header_Number (0);
}
void Validate::Facility_Stats (void)
{
int i, n;
String label;
Group_Data *data;
Group_Map_Itr map_itr;
Statistics stats;
Link_Itr link_itr;
Str_Map_Itr str_itr;
for (link_itr = link_array.begin (); link_itr != link_array.end (); link_itr++) {
if (link_itr->AB_Dir () >= 0) {
Sum_Group (link_itr->Type (), &(*link_itr), link_itr->AB_Dir ());
}
if (link_itr->BA_Dir () >= 0) {
Sum_Group (link_itr->Type (), &(*link_itr), link_itr->BA_Dir ());
}
}
//---- print the page header ----
Header_Number (FACILITY_TYPE);
if (!Break_Check ((int) group_data.size () + 9)) {
Print (1);
Facility_Header ();
}
//---- print each functional class ----
for (map_itr = group_data.begin (); map_itr != group_data.end (); map_itr++) {
data = &map_itr->second;
n = data->number;
if (n == 0) continue;
Calc_Stats (data, stats);
i = data->index;
str_itr = facility_type.find (i);
if (str_itr == facility_type.end ()) {
label = Facility_Code ((Facility_Type) i);
} else {
label = str_itr->second;
}
Page_Check (1);
Print (0, String (stats_format) % label % n % data->volume % data->count %
(data->volume - data->count) % stats.per_diff % stats.avg_error % stats.per_error %
stats.std_dev % stats.rmse % stats.r_sq % stats.avg_vc % data->max_vc);
}
//---- calculate the total statistics ----
n = total.number;
if (n > 0) {
Calc_Stats (&total, stats);
Page_Check (3);
Print (0, "\n");
Print (0, String (stats_format) % "TOTAL" % n % total.volume % total.count %
(total.volume - total.count) % stats.per_diff % stats.avg_error % stats.per_error %
stats.std_dev % stats.rmse % stats.r_sq % stats.avg_vc % total.max_vc);
Print (0, "\n");
}
Header_Number (0);
}
void LocationData::Set_Files (void)
{
int i, nfld, key;
bool binary;
Db_Field *fld;
Db_Base *file;
Db_Sort_Array *data;
Data_Itr data_itr;
Polygon_Itr poly_itr;
//---- create the program data structure ----
data_rec.push_back (input_file);
data_rec.push_back (output_file);
//---- convert each data file to binary ----
for (data_itr = data_group.begin (); data_itr != data_group.end (); data_itr++) {
file = data_itr->file;
data = data_itr->data_db;
data_rec.push_back ((Db_Base *) data);
data->File_ID (file->File_ID ());
data->File_Type (file->File_Type ());
nfld = file->Num_Fields ();
key = data_itr->join_field;
binary = (file->Record_Format () == BINARY);
fld = file->Field (key);
data->Add_Field (fld->Name (), DB_INTEGER, 10);
data->Add_Field ("AL_COUNT", DB_INTEGER, 10);
for (i=0; i < nfld; i++) {
if (i == key) continue;
fld = file->Field (i);
if (fld != 0) {
data->Add_Field (fld->Name (), fld->Type (), fld->Size (), fld->Units (), binary);
}
}
}
//---- read the arcview boundary file ----
for (poly_itr = polygons.begin (); poly_itr != polygons.end (); poly_itr++) {
file = poly_itr->file;
data = poly_itr->data_db;
data_rec.push_back ((Db_Base *) data);
data->File_ID (file->File_ID ());
data->File_Type (file->File_Type ());
nfld = file->Num_Fields ();
binary = (file->Record_Format () == BINARY);
data->Add_Field ("INDEX", DB_INTEGER, 10);
for (i=0; i < nfld; i++) {
fld = file->Field (i);
if (fld != 0) {
data->Add_Field (fld->Name (), fld->Type (), fld->Size (), fld->Units (), binary);
}
}
}
Write (1, "Compiling Conversion Script");
if (Report_Flag (PRINT_SCRIPT)) {
Header_Number (PRINT_SCRIPT);
if (!Break_Check (10)) {
Print (1);
Page_Header ();
}
}
program.Initialize (data_rec, random.Seed () + 1);
if (!program.Compile (program_file, Report_Flag (PRINT_SCRIPT))) {
Error ("Compiling Conversion Script");
}
if (Report_Flag (PRINT_STACK)) {
Header_Number (PRINT_STACK);
program.Print_Commands (false);
}
Header_Number (0);
}
void TPPlusNet::Execute (void)
{
//---- read the conversion script ----
if (convert_flag) {
int num;
Db_Base *files [3];
if (Report_Flag (SCRIPT_REPORT)) {
Header_Number (SCRIPT_REPORT);
if (!Break_Check (10)) {
Print (1);
Page_Header ();
}
}
if (link_shape_flag) {
files [0] = &link_shape_file;
} else {
files [0] = &link_file;
}
files [1] = Network_Db_Base (NEW_LINK);
if (detail_flag) {
files [2] = &detail_file;
num = 3;
} else {
num = 2;
}
convert.Set_Files (num, files);
if (!convert.Compile (&script_file, Report_Flag (SCRIPT_REPORT))) {
Error ("Compiling Conversion Script");
}
if (Report_Flag (STACK_REPORT)) {
Header_Number (STACK_REPORT);
convert.Print_Commands (false);
}
Header_Number (0);
}
//---- setup network data ----
Network_Service::Execute ();
//---- read the speed capacity file ----
if (spdcap_flag) {
Read_SpdCap ();
}
//---- read the node file ----
Read_Node ();
//---- read the link file ----
Read_Link ();
//---- write the link file ----
Write_Link ();
//---- end the program ----
Exit_Stat (DONE);
}
void RiderSum::Line_Sum_Report (void)
{
int riders, max_load, board, alight, run, runs;
Int_Map_Itr map_itr;
Line_Data *line_ptr;
Line_Stop_Itr stop_itr;
Line_Run_Itr run_itr;
Show_Message ("Line Summary Report -- Record");
Set_Progress ();
//---- print the report ----
Header_Number (LINE_SUM);
if (!Break_Check ((int) line_map.size () + 5)) {
Print (1);
Line_Sum_Header ();
}
//---- get the route data ----
for (map_itr = line_map.begin (); map_itr != line_map.end (); map_itr++) {
Show_Progress ();
if (select_routes && !route_range.In_Range (map_itr->first)) continue;
line_ptr = &line_array [map_itr->second];
if (select_modes && !select_mode [line_ptr->Mode ()]) continue;
//---- check the link criteria ----
if (!Link_Selection (line_ptr)) continue;
//---- set the run flags ----
if (!Run_Selection (line_ptr)) continue;
//---- save the route ridership data ----
riders = board = alight = max_load = runs = 0;
for (stop_itr = line_ptr->begin (); stop_itr != line_ptr->end (); stop_itr++) {
for (run=0, run_itr = stop_itr->begin (); run_itr != stop_itr->end (); run_itr++, run++) {
if (run_flag [run] == 0) continue;
if (run_period [run] < 0) continue;
if (select_time_of_day && !time_range.In_Range (run_itr->Schedule ())) continue;
if (run_itr->Board () > board) board = run_itr->Board ();
if (run_itr->Alight () > alight) alight = run_itr->Alight ();
if (run_itr->Load () > max_load) max_load = run_itr->Load ();
riders += run_itr->Board ();
if (run_flag [run] == 1) {
runs++;
run_flag [run] = 2;
}
}
}
if (riders == 0) continue;
Print (1, String ("%8d %10.10s %5d %5d %8d %8d %8d %8d") % line_ptr->Route () %
Transit_Code ((Transit_Type) line_ptr->Mode ()) % line_ptr->size () % runs %
riders % max_load % board % alight);
if (!line_ptr->Name ().empty ()) {
Print (0, String (" %s") % line_ptr->Name ());
}
if (Notes_Name_Flag ()) {
if (!line_ptr->Notes ().empty ()) {
Print (0, String (" %s") % line_ptr->Notes ());
}
}
}
End_Progress ();
Header_Number (0);
}
void RiderSum::Group_Rider_Report (void)
{
int n, run, runs, num, length, tot_len, period, num_periods, routes, index, stop, to, link;
int max_riders, max_board, max_alight, max_runs, total;
double factor, max_fac, sum_time, tot_time, time;
double vmt, vht, pmt, pht;
Dtime low, high;
String label;
bool flag;
Int_Set *group;
Int_Set_Itr itr;
Int_Map_Itr map_itr, to_itr;
Line_Data *line_ptr;
Stop_Data *stop_ptr;
Line_Stop_Itr stop_itr, next_itr;
Line_Run_Itr run_itr;
Int_Map stop_index;
Int2_Map link_index;
Int2_Map_Itr map2_itr;
Int2_Key int2_key;
Int2_Map_Stat map2_stat;
Int_Map_Stat map_stat;
Stop_Group_Data data, *data_ptr, *link_ptr;
Stop_Group_Itr data_itr;
Show_Message ("Line Group Profile -- Record");
Set_Progress ();
//---- print the report ----
Header_Number (GROUP_RIDERS);
num_periods = sum_periods.Num_Periods ();
if (num_periods == 0) num_periods = 1;
num = (int) (line_map.size () * stop_map.size ());
if (!Break_Check (num + 5)) {
Print (1);
Group_Rider_Header ();
}
routes = 0;
memset (&data, '\0', sizeof (data));
for (n = line_equiv.First_Group (); n > 0; n = line_equiv.Next_Group ()) {
group = line_equiv.Group_List (n);
if (group == 0) continue;
label = line_equiv.Group_Label (n);
//---- process each time period ----
for (period = 0; period < num_periods; period++) {
//---- initialize stop data ----
stop_index.clear ();
link_index.clear ();
stop_group_array.clear ();
routes = 0;
vmt = vht = pmt = pht = 0.0;
//---- process each line in the line group ----
for (itr = group->begin (); itr != group->end (); itr++) {
map_itr = line_map.find (*itr);
if (map_itr == line_map.end ()) continue;
Show_Progress ();
line_ptr = &line_array [map_itr->second];
//---- set the run flags ----
if (!Run_Selection (line_ptr)) continue;
if (period_flag [period] == 0) continue;
time = 0.0;
total = length = 0;
flag = false;
sum_periods.Period_Range (period, low, high);
for (stop_itr = line_ptr->begin (); stop_itr != line_ptr->end (); stop_itr++) {
stop_ptr = &stop_array [stop_itr->Stop ()];
stop = stop_ptr->Stop ();
map_itr = stop_index.find (stop);
next_itr = stop_itr + 1;
if (next_itr != line_ptr->end ()) {
stop_ptr = &stop_array [next_itr->Stop ()];
to = stop_ptr->Stop ();
} else {
to = 0;
}
//---- create the link ----
int2_key = Int2_Key (stop, to);
map2_itr = link_index.find (int2_key);
if (map2_itr == link_index.end ()) {
if (to == 0 && map_itr != stop_index.end ()) {
link = map_itr->second;
} else {
link = (int) stop_group_array.size ();
link_index.insert (Int2_Map_Data (int2_key, link));
data.stop = stop;
data.to = to;
stop_group_array.push_back (data);
//---- check for a merge ----
if (to != 0) {
to_itr = stop_index.find (to);
if (to_itr != stop_index.end ()) {
index = (int) stop_group_array.size ();
int2_key = Int2_Key (to, 0);
map2_stat = link_index.insert (Int2_Map_Data (int2_key, index));
if (map2_stat.second) {
data.stop = to;
data.to = 0;
stop_group_array.push_back (data);
}
}
}
}
} else {
link = map2_itr->second;
}
link_ptr = &stop_group_array [link];
//---- crete the stop index ----
if (map_itr == stop_index.end ()) {
map_stat = stop_index.insert (Int_Map_Data (stop, link));
index = link;
} else {
index = map_itr->second;
}
data_ptr = &stop_group_array [index];
if (next_itr != line_ptr->end ()) {
length = next_itr->Length () - stop_itr->Length ();
} else {
length = 0;
}
sum_time = 0.0;
num = runs = 0;
for (run=0, run_itr = stop_itr->begin (); run_itr != stop_itr->end (); run_itr++, run++) {
if (run_flag [run] == 0) continue;
if (run_period [run] != period) continue;
data_ptr->board += run_itr->Board ();
data_ptr->alight += run_itr->Alight ();
link_ptr->riders += run_itr->Load ();
runs++;
flag = true;
if (next_itr != line_ptr->end ()) {
link_ptr->runs++;
time = next_itr->at (run).Schedule ().Seconds () - run_itr->Schedule ().Seconds ();
sum_time += time;
num++;
vmt += length;
vht += time;
pmt += length * run_itr->Load ();
pht += time * run_itr->Load ();
}
}
if (runs == 0) continue;
if (link_ptr->length == 0.0) {
link_ptr->length = length;
}
if (num > 0) {
time = sum_time / num;
} else {
time = 0;
}
if (link_ptr->time > 0) {
link_ptr->time = (link_ptr->time + time) / 2.0;
} else {
link_ptr->time = time;
}
}
if (flag) routes++;
}
//---- print the report ----
if (!Break_Check ((int) stop_index.size () + 15)) {
Print (1);
Group_Rider_Header ();
}
Print (1, "Group Time Period Routes Description");
Print (2, String ("%5d %12.12s %6d %s") % n % sum_periods.Range_Format (period) %
routes % label);
Print (2, " Stop Length TTime Alight Board Riders Runs LoadFac");
Print (1);
tot_time = 0.0;
max_alight = max_board = max_riders = max_runs = total = tot_len = 0;
max_fac = 0.0;
for (data_itr = stop_group_array.begin (); data_itr != stop_group_array.end (); data_itr++) {
map_itr = stop_map.find (data_itr->stop);
stop_ptr = &stop_array [map_itr->second];
if (data_itr->runs > 0) {
factor = DTOI (data_itr->riders * 10.0 / data_itr->runs) / 10.0;
} else {
factor = 0.0;
}
Print (1, String ("%8d %7.0lf %7.0lf %8d %8d %8d %5d %8.1lf") % data_itr->stop %
UnRound (data_itr->length) % data_itr->time % data_itr->alight % data_itr->board %
data_itr->riders % data_itr->runs % factor);
if (Notes_Name_Flag ()) {
if (!stop_ptr->Name ().empty ()) {
Print (0, String (" %s") % stop_ptr->Name ());
}
if (!stop_ptr->Notes ().empty ()) {
Print (0, " -- ") << stop_ptr->Notes ();
}
}
if (data_itr->alight > max_alight) max_alight = data_itr->alight;
if (data_itr->board > max_board) max_board = data_itr->board;
if (data_itr->riders > max_riders) max_riders = data_itr->riders;
if (data_itr->runs > max_runs) max_runs = data_itr->runs;
if (factor > max_fac) max_fac = factor;
tot_len += data_itr->length;
tot_time += data_itr->time;
total += data_itr->board;
}
if (max_runs == 0) continue;
Print (2, String (" Maximum %8ld %8ld %8ld %5ld %8.1lf") %
max_alight % max_board % max_riders % max_runs % max_fac);
Print (2, "Total Boardings = ") << total;
if (total == 0 || tot_time == 0) continue;
factor = UnRound (tot_len);
vmt = UnRound (vmt) / 5280.0;
vht = vht / 3600.0;
pmt = UnRound (pmt) / 5280.0;
pht = pht / 3600.0;
Print (1, String ("Route Length = %.1lf miles, %.1lf minutes Average Speed = %.1lf mph") %
External_Units (factor, MILES) % (tot_time / 60.0) % External_Units ((factor / tot_time), MPH));
Print (1, String ("Vehicle Miles = %.1lf Vehicle Hours = %.1lf") % vmt % vht);
Print (1, String ("Passenger Miles = %.1lf Passenger Hours = %.1lf") % pmt % pht);
Print (1, String ("Passengers per Vehicle Mile = %.1lf Passengers per Vehicle Hour = %.1lf") %
(pmt / vht) % (pht / vht));
vmt = pmt / total;
vht = pht * 60.0 / total;
Print (1, String ("Average Trip Length = %.1lf miles, %.1lf minutes") % vmt % vht);
}
}
End_Progress ();
Header_Number (0);
}
void PlanSum::Transfer_Report (int num, int mode)
{
int i, j, total, num_board, board;
bool flag;
Ints_Array *on_ptr;
Ints_Itr on_itr;
Int_Itr int_itr;
Integers bus_total;
if (num == 0) {
on_ptr = &total_on_array;
xfer_label.clear ();
} else if (mode == 0) {
on_ptr = &walk_on_array [num - 1];
xfer_label ("Walk Access %s") % sum_periods.Range_Format (num - 1);
} else {
on_ptr = &drive_on_array [num - 1];
xfer_label ("Drive Access %s") % sum_periods.Range_Format (num - 1);
}
//---- get the dimensions ----
total = max_rail = num_board = 0;
for (i=0, on_itr = on_ptr->begin (); on_itr != on_ptr->end (); on_itr++, i++) {
flag = false;
for (j=0, int_itr = on_itr->begin (); int_itr != on_itr->end (); int_itr++, j++) {
if (*int_itr > 0) {
num_board += *int_itr * (i + j);
if (j > max_rail) max_rail = j;
flag = true;
}
}
if (flag) total++;
}
if (total == 0) return;
if (num == 0) {
Header_Number (SUM_TRANSFERS);
} else {
Header_Number (XFER_DETAILS);
}
if (!Break_Check (total + 10)) {
Print (1);
Transfer_Header ();
}
//---- print each row ----
bus_total.assign (10, 0);
for (i=0, on_itr = on_ptr->begin (); on_itr != on_ptr->end (); on_itr++, i++) {
for (int_itr = on_itr->begin (); int_itr != on_itr->end (); int_itr++) {
if (*int_itr > 0) break;
}
if (int_itr == on_itr->end ()) continue;
Print (1, String ("%3d ") % i);
if (max_rail > 0) {
total = 0;
for (j=0; j <= max_rail; j++) {
board = on_itr->at (j);
Print (0, String (" %7d") % board);
total += board;
bus_total [j] += board;
}
} else {
total = on_itr->at (0);
bus_total [0] += total;
}
Print (0, String (" %7d") % total);
}
//---- bus totals ----
Print (2, "Total ");
if (max_rail > 0) {
total = 0;
for (j=0; j <= max_rail; j++) {
Print (0, String (" %7d") % bus_total [j]);
total += bus_total [j];
}
} else {
total = bus_total [0];
}
Print (0, String (" %7d") % total);
Print (2, String ("Total Boardings = %d, Boardings per Trip = %.2lf") % num_board %
((total > 0) ? (double) num_board / total : 0.0));
Header_Number (0);
}
