PlanPrep::PlanPrep (void) : Data_Service (), Select_Service ()
{
Program ("PlanPrep");
Version (9);
Title ("Travel Plan Processing Utility");
System_File_Type required_files [] = {
PLAN, END_FILE
};
System_File_Type optional_files [] = {
SELECTION, NEW_PLAN, END_FILE
};
int data_service_keys [] = {
TRIP_SORT_TYPE, PLAN_SORT_TYPE, 0
};
int select_service_keys [] = {
SELECT_HOUSEHOLDS, SELECT_MODES, SELECT_PURPOSES, SELECT_START_TIMES, SELECT_END_TIMES,
SELECT_ORIGINS, SELECT_DESTINATIONS, SELECT_TRAVELER_TYPES, SELECT_LINKS, SELECT_NODES,
SELECT_SUBAREA_POLYGON, SELECTION_PERCENTAGE, DELETION_FILE, DELETION_FORMAT,
DELETE_HOUSEHOLDS, DELETE_MODES, DELETE_TRAVELER_TYPES, 0
};
Control_Key keys [] = { //--- code, key, level, status, type, default, range, help ----
{ MERGE_PLAN_FILE, "MERGE_PLAN_FILE", LEVEL0, OPT_KEY, IN_KEY, "", PARTITION_RANGE, NO_HELP },
{ MERGE_PLAN_FORMAT, "MERGE_PLAN_FORMAT", LEVEL0, OPT_KEY, TEXT_KEY, "TAB_DELIMITED", FORMAT_RANGE, FORMAT_HELP },
{ MAXIMUM_SORT_SIZE, "MAXIMUM_SORT_SIZE", LEVEL0, OPT_KEY, INT_KEY, "0", "0, >=100000 trips", NO_HELP },
END_CONTROL
};
const char *reports [] = {
//"FIRST_REPORT",
//"SECOND_REPORT",
""
};
Required_System_Files (required_files);
Optional_System_Files (optional_files);
Data_Service_Keys (data_service_keys);
Select_Service_Keys (select_service_keys);
Key_List (keys);
Report_List (reports);
Enable_Partitions (true);
#ifdef BOOST_THREADS
Enable_Threads (true);
#endif
#ifdef MPI_EXE
Enable_MPI (true);
#endif
plan_processing = 0;
sort_size = 0;
select_flag = merge_flag = combine_flag = output_flag = new_plan_flag = false;
System_Read_False (PLAN);
System_Data_Reserve (PLAN, 0);
}
Relocate::Relocate (void) : Data_Service ()
{
Program ("Relocate");
Version (0);
Title ("Update Activity Locations");
System_File_Type required_files [] = {
NODE, LINK, LOCATION, PARKING, END_FILE
};
System_File_Type optional_files [] = {
SHAPE, ACCESS_LINK, TRIP, VEHICLE, PLAN, NEW_TRIP, NEW_VEHICLE, NEW_PLAN, NEW_SELECTION, END_FILE
};
Control_Key keys [] = { //--- code, key, level, status, type, default, range, help ----
{ OLD_NODE_FILE, "OLD_NODE_FILE", LEVEL0, REQ_KEY, IN_KEY, "", FILE_RANGE, NO_HELP },
{ OLD_NODE_FORMAT, "OLD_NODE_FORMAT", LEVEL0, OPT_KEY, TEXT_KEY, "TAB_DELIMITED", FORMAT_RANGE, FORMAT_HELP },
{ OLD_SHAPE_FILE, "OLD_SHAPE_FILE", LEVEL0, OPT_KEY, IN_KEY, "", FILE_RANGE, NO_HELP },
{ OLD_SHAPE_FORMAT, "OLD_SHAPE_FORMAT", LEVEL0, OPT_KEY, TEXT_KEY, "TAB_DELIMITED", FORMAT_RANGE, FORMAT_HELP },
{ OLD_LINK_FILE, "OLD_LINK_FILE", LEVEL0, REQ_KEY, IN_KEY, "", FILE_RANGE, NO_HELP },
{ OLD_LINK_FORMAT, "OLD_LINK_FORMAT", LEVEL0, OPT_KEY, TEXT_KEY, "TAB_DELIMITED", FORMAT_RANGE, FORMAT_HELP },
{ OLD_LOCATION_FILE, "OLD_LOCATION_FILE", LEVEL0, REQ_KEY, IN_KEY, "", FILE_RANGE, NO_HELP },
{ OLD_LOCATION_FORMAT, "OLD_LOCATION_FORMAT", LEVEL0, OPT_KEY, TEXT_KEY, "TAB_DELIMITED", FORMAT_RANGE, FORMAT_HELP },
{ OLD_PARKING_FILE, "OLD_PARKING_FILE", LEVEL0, REQ_KEY, IN_KEY, "", FILE_RANGE, NO_HELP },
{ OLD_PARKING_FORMAT, "OLD_PARKING_FORMAT", LEVEL0, OPT_KEY, TEXT_KEY, "TAB_DELIMITED", FORMAT_RANGE, FORMAT_HELP },
{ OLD_ACCESS_FILE, "OLD_ACCESS_FILE", LEVEL0, OPT_KEY, IN_KEY, "", FILE_RANGE, NO_HELP },
{ OLD_ACCESS_FORMAT, "OLD_ACCESSE_FORMAT", LEVEL0, OPT_KEY, TEXT_KEY, "TAB_DELIMITED", FORMAT_RANGE, FORMAT_HELP },
{ NEW_LOCATION_MAP_FILE, "NEW_LOCATION_MAP_FILE", LEVEL0, OPT_KEY, OUT_KEY, "", FILE_RANGE, NO_HELP },
{ NEW_PARKING_MAP_FILE, "NEW_PARKING_MAP_FILE", LEVEL0, OPT_KEY, OUT_KEY, "", FILE_RANGE, NO_HELP },
END_CONTROL
};
Required_System_Files (required_files);
Optional_System_Files (optional_files);
Key_List (keys);
Enable_Partitions (true);
Location_XY_Flag (true);
trip_flag = plan_flag = vehicle_flag = select_flag = false;
loc_map_flag = park_map_flag = shape_flag = access_flag = false;
System_Read_False (PLAN);
System_Data_Reserve (PLAN, 0);
System_Read_False (TRIP);
System_Data_Reserve (TRIP, 0);
System_Read_False (VEHICLE);
System_Data_Reserve (VEHICLE, 0);
}
ExportPlans::ExportPlans (void) : Data_Service (), Select_Service ()
{
Program ("ExportPlans");
Version (7);
Title ("Export Plan Data in Various Formats");
System_File_Type required_files [] = {
PLAN, END_FILE
};
System_File_Type optional_files [] = {
LINK, NODE, LOCATION, VEHICLE_TYPE, VEHICLE, END_FILE
};
int data_service_keys [] = {
SUMMARY_TIME_RANGES, SUMMARY_TIME_INCREMENT, 0
};
int select_service_keys [] = {
SELECT_MODES, SELECT_NODES, SELECT_SUBAREA_POLYGON, SELECT_VEHICLE_TYPES, 0
};
Control_Key exportplans_keys [] = { //--- code, key, level, status, type, default, range, help ----
{ NEW_VISSIM_XML_FILE, "NEW_VISSIM_XML_FILE", LEVEL0, OPT_KEY, OUT_KEY, "", FILE_RANGE, NO_HELP },
{ LOCATION_ZONE_MAP_FILE, "LOCATION_ZONE_MAP_FILE", LEVEL0, OPT_KEY, IN_KEY, "", FILE_RANGE, NO_HELP },
{ SUBZONE_WEIGHT_FILE, "SUBZONE_WEIGHT_FILE", LEVEL0, OPT_KEY, IN_KEY, "", FILE_RANGE, NO_HELP },
{ NEW_ZONE_LOCATION_FILE, "NEW_ZONE_LOCATION_FILE", LEVEL0, OPT_KEY, OUT_KEY, "", FILE_RANGE, NO_HELP },
END_CONTROL
};
const char *reports [] = {
""
};
Required_System_Files (required_files);
Optional_System_Files (optional_files);
Data_Service_Keys (data_service_keys);
Select_Service_Keys (select_service_keys);
Key_List (exportplans_keys);
Report_List (reports);
Enable_Partitions (true);
Location_XY_Flag (true);
vissim_flag = select_flag = map_flag = zone_loc_flag = subzone_flag = false;
System_Read_False (PLAN);
System_Data_Reserve (PLAN, 0);
}
ProblemSelect::ProblemSelect (void) : Data_Service (), Select_Service ()
{
Program ("ProblemSelect");
Version (0);
Title ("Travel Problem Selection Utility");
System_File_Type required_files [] = {
NODE, LINK, LOCATION, PROBLEM, NEW_SELECTION, END_FILE
};
System_File_Type optional_files [] = {
SELECTION, END_FILE
};
int select_service_keys [] = {
SELECT_HOUSEHOLDS, SELECT_MODES, SELECT_PURPOSES, SELECT_START_TIMES, SELECT_END_TIMES,
SELECT_ORIGINS, SELECT_DESTINATIONS, SELECT_TRAVELER_TYPES, SELECT_FACILITY_TYPES,
SELECT_ORIGIN_ZONES, SELECT_DESTINATION_ZONES, SELECT_PROBLEM_TYPES,
SELECTION_PERCENTAGE, MAXIMUM_PERCENT_SELECTED, 0
};
Control_Key keys [] = { //--- code, key, level, status, type, default, range, help ----
//{ SELECT_TIME_RATIOS, "SELECT_TIME_RATIOS", LEVEL0, OPT_KEY, FLOAT_KEY, "0.0", "0.0, >1.0", NO_HELP },
END_CONTROL
};
const char *reports [] = {
//"FIRST_REPORT",
//"SECOND_REPORT",
""
};
Required_System_Files (required_files);
Optional_System_Files (optional_files);
Select_Service_Keys (select_service_keys);
Key_List (keys);
Report_List (reports);
Enable_Partitions (true);
max_problem = num_problem = 0;
}
void Demand_Service::Program_Control (void)
{
int max_errors;
char *str_ptr, *format_ptr;
Format_Type default_format, file_format, demand_format;
Access_Type access;
//---- open network files ----
Network_Service::Program_Control ();
demand_format = default_format = Demand_Format ();
File_Data *file = demand_file;
//---- get the default demand file format ----
format_ptr = Get_Control_String (DEMAND_FILE_FORMAT);
if (format_ptr != NULL) {
demand_format = Format_Code (format_ptr);
if (demand_format != default_format) {
Print (2, "Demand File Format = %s", format_ptr);
}
} else {
demand_format = default_format;
}
Demand_Format (demand_format);
//---- open the files ----
for (int i=0; i < END_DEMAND; i++, file++) {
if (file->flag || file->option) {
//---- initialize overlaid data classes ----
if (i == LINK_DELAY || i == NEW_LINK_DELAY) {
if (dir_array == NULL) {
dir_array = (Dir_Array *) new TTime_Array ();
}
if (connect_array == NULL) {
connect_array = (Connect_Array *) new Connect_Time_Array ();
}
} else if (i == PERFORMANCE || i == NEW_PERFORMANCE) {
if (dir_array == NULL) {
dir_array = (Dir_Array *) new Performance_Array ();
}
if (connect_array == NULL) {
connect_array = (Connect_Array *) new Connect_Time_Array ();
}
} else if (i == RIDERSHIP || i == NEW_RIDERSHIP) {
if (line_array == NULL) {
line_array = (Line_Array *) new Rider_Array ();
}
}
//---- read the key ----
str_ptr = Get_Control_String (file->key);
if (str_ptr == NULL) {
if (file->flag) goto control_error;
} else {
Print (1);
file->flag = true;
format_ptr = Get_Control_String (file->format);
if (format_ptr != NULL) {
file_format = Format_Code (format_ptr);
} else {
file_format = demand_format;
}
access = file->access;
switch (i) {
case HOUSEHOLD:
case NEW_HOUSEHOLD:
file->file = new Household_File (Project_Filename (str_ptr), access, file_format);
break;
case POPULATION:
case NEW_POPULATION:
file->file = new Population_File (Project_Filename (str_ptr), access, file_format);
break;
case LINK_DELAY:
case PERFORMANCE:
file->file = new Delay_File (Project_Filename (str_ptr), access, file_format);
if (((Db_Base *) file->file)->Dbase_Format () == VERSION3) {
if (i == LINK_DELAY) {
ttime_data.Period_Size (((Delay_File *) file->file)->Increment ());
connect_time.Period_Size (ttime_data.Period_Size ());
} else {
performance_data.Period_Size (((Delay_File *) file->file)->Increment ());
connect_time.Period_Size (performance_data.Period_Size ());
}
}
//---- max link delay errors ----
str_ptr = Get_Control_String (MAX_LINK_DELAY_ERRORS);
if (str_ptr != NULL) {
Get_Integer (str_ptr, &max_errors);
if (max_delay_errors < 0) {
Error ("Maximum Link Delay Errors %d is Out of Range", max_errors);
}
Print (1, "Maximum Number of Link Delay Errors = %d", max_errors);
Max_Delay_Errors (max_errors);
}
break;
case NEW_LINK_DELAY:
case NEW_PERFORMANCE:
file->file = new Delay_File (Project_Filename (str_ptr), access, file_format, Time_Increment ());
break;
case RIDERSHIP:
case NEW_RIDERSHIP:
file->file = new Ridership_File (Project_Filename (str_ptr), access, file_format);
break;
case VEHICLE_TYPE:
case NEW_VEHICLE_TYPE:
file->file = new Veh_Type_File (Project_Filename (str_ptr), access, file_format);
break;
case VEHICLE:
case NEW_VEHICLE:
file->file = new Vehicle_File (Project_Filename (str_ptr), access, file_format);
//---- sort vehicles ----
if (i == VEHICLE) {
if (Get_Control_String (SORT_VEHICLES) != NULL) {
sort_flag = Get_Control_Flag (SORT_VEHICLES);
}
if (sort_flag) {
Print (1, "Vehicle File will be Sorted by Vehicle ID");
} else {
Print (1, "Vehicle File is Sorted by Vehicle ID");
}
}
break;
case ACTIVITY:
case NEW_ACTIVITY:
str_ptr = Project_Filename (str_ptr);
if (Enable_Partitions ()) {
Activity_File * act_file = new Activity_File (access, file_format);
file->file = act_file;
if (Partition ()) {
act_file->Filename (str_ptr, Partition_Number ());
} else {
act_file->Filename (str_ptr);
}
Print_Filename (1, act_file->File_Type (), act_file->Groupname ());
if (!act_file->Open (0)) {
File_Error (act_file->File_Type (), act_file->Filename ());
}
} else {
file->file = new Activity_File (str_ptr, access, file_format);
}
break;
case TRIP:
case NEW_TRIP:
str_ptr = Project_Filename (str_ptr);
if (Enable_Partitions ()) {
Trip_File * trip_file = new Trip_File (access, file_format);
file->file = trip_file;
if (Partition ()) {
trip_file->Filename (str_ptr, Partition_Number ());
} else {
trip_file->Filename (str_ptr);
}
Print_Filename (1, trip_file->File_Type (), trip_file->Groupname ());
if (!trip_file->Open (0)) {
File_Error (trip_file->File_Type (), trip_file->Filename ());
}
} else {
file->file = new Trip_File (str_ptr, access, file_format);
}
break;
case BOUNDARY_SPEED:
case NEW_BOUNDARY_SPEED:
file->file = new Boundary_File (Project_Filename (str_ptr), access, file_format);
break;
}
}
}
}
Demand_Format (default_format);
control_flag = true;
return;
control_error:
Error ("Missing Control Key = %s", Current_Key ());
}
PlanCompare::PlanCompare (void) : Data_Service (), Select_Service ()
{
Program ("PlanCompare");
Version (3);
Title ("Travel Plan Comparison Utility");
System_File_Type required_files [] = {
PLAN, END_FILE
};
System_File_Type optional_files [] = {
SELECTION, NEW_SELECTION, NEW_PLAN, END_FILE
};
int data_service_keys [] = {
DAILY_WRAP_FLAG, SUMMARY_TIME_RANGES, SUMMARY_TIME_INCREMENT, PERIOD_CONTROL_POINT, 0
};
int select_service_keys [] = {
SELECT_HOUSEHOLDS, SELECT_MODES, SELECT_PURPOSES, SELECT_START_TIMES, SELECT_END_TIMES,
SELECT_ORIGINS, SELECT_DESTINATIONS, SELECT_VEHICLE_TYPES, SELECT_TRAVELER_TYPES,
SELECT_LINKS, SELECT_NODES, SELECT_SUBAREAS, SELECTION_POLYGON,
PERCENT_TIME_DIFFERENCE, MINIMUM_TIME_DIFFERENCE, MAXIMUM_TIME_DIFFERENCE,
PERCENT_COST_DIFFERENCE, MINIMUM_COST_DIFFERENCE, MAXIMUM_COST_DIFFERENCE,
PERCENT_PATH_DIFFERENCE, MINIMUM_PATH_DIFFERENCE, MAXIMUM_PATH_DIFFERENCE,
SELECTION_PERCENTAGE, MAXIMUM_PERCENT_SELECTED,
DELETION_FILE, DELETION_FORMAT, DELETE_HOUSEHOLDS, DELETE_MODES, DELETE_TRAVELER_TYPES, 0
};
Control_Key keys [] = { //--- code, key, level, status, type, default, range, help ----
{ COMPARE_PLAN_FILE, "COMPARE_PLAN_FILE", LEVEL0, REQ_KEY, IN_KEY, "", PARTITION_RANGE, NO_HELP },
{ COMPARE_PLAN_FORMAT, "COMPARE_PLAN_FORMAT", LEVEL0, OPT_KEY, TEXT_KEY, "TAB_DELIMITED", FORMAT_RANGE, FORMAT_HELP },
{ COMPARE_GENERALIZED_COSTS, "COMPARE_GENERALIZED_COSTS", LEVEL0, OPT_KEY, BOOL_KEY, "FALSE", BOOL_RANGE, NO_HELP },
{ SELECTION_METHOD, "SELECTION_METHOD", LEVEL0, OPT_KEY, TEXT_KEY, "RANDOM", SELECT_METHOD_RANGE, NO_HELP },
{ MERGE_PLAN_FILES, "MERGE_PLAN_FILES", LEVEL0, OPT_KEY, BOOL_KEY, "FALSE", BOOL_RANGE, NO_HELP },
{ TIME_DISTRIBUTION_MINIMUM, "TIME_DISTRIBUTION_MINIMUM", LEVEL0, OPT_KEY, TIME_KEY, "-60 minutes", "-360..0", NO_HELP },
{ TIME_DISTRIBUTION_COUNT, "TIME_DISTRIBUTION_COUNT", LEVEL0, OPT_KEY, INT_KEY, "151", "50..500", NO_HELP },
{ TIME_DISTRIBUTION_INCREMENT, "TIME_DISTRIBUTION_INCREMENT", LEVEL0, OPT_KEY, TIME_KEY, "1 minute", "1..60 minutes", NO_HELP },
{ COST_DISTRIBUTION_MINIMUM, "COST_DISTRIBUTION_MINIMUM", LEVEL0, OPT_KEY, INT_KEY, "-360 impedance", "-360..0 impedance", NO_HELP },
{ COST_DISTRIBUTION_COUNT, "COST_DISTRIBUTION_COUNT", LEVEL0, OPT_KEY, INT_KEY, "151", "50..500", NO_HELP },
{ COST_DISTRIBUTION_INCREMENT, "COST_DISTRIBUTION_INCREMENT", LEVEL0, OPT_KEY, INT_KEY, "5 impedance", "1..500", NO_HELP },
{ NEW_TIME_DISTRIBUTION_FILE, "NEW_TIME_DISTRIBUTION_FILE", LEVEL0, OPT_KEY, OUT_KEY, "", FILE_RANGE, NO_HELP },
{ NEW_COST_DISTRIBUTION_FILE, "NEW_COST_DISTRIBUTION_FILE", LEVEL0, OPT_KEY, OUT_KEY, "", FILE_RANGE, NO_HELP },
{ NEW_TRIP_TIME_GAP_FILE, "NEW_TRIP_TIME_GAP_FILE", LEVEL0, OPT_KEY, OUT_KEY, "", FILE_RANGE, NO_HELP },
{ NEW_TRIP_COST_GAP_FILE, "NEW_TRIP_COST_GAP_FILE", LEVEL0, OPT_KEY, OUT_KEY, "", FILE_RANGE, NO_HELP },
{ NEW_TRIP_MATCH_FILE, "NEW_TRIP_MATCH_FILE", LEVEL0, OPT_KEY, OUT_KEY, "", PARTITION_RANGE, NO_HELP },
{ NEW_TRIP_MATCH_FORMAT, "NEW_TRIP_MATCH_FORMAT", LEVEL0, OPT_KEY, TEXT_KEY, "TAB_DELIMITED", FORMAT_RANGE, FORMAT_HELP },
END_CONTROL
};
const char *reports [] = {
"TOTAL_TIME_DISTRIBUTION",
"PERIOD_TIME_DISTRIBUTIONS",
"TOTAL_TIME_SUMMARY",
"PERIOD_TIME_SUMMARY",
"TOTAL_COST_DISTRIBUTION",
"PERIOD_COST_DISTRIBUTIONS",
"TOTAL_COST_SUMMARY",
"PERIOD_COST_SUMMARY",
"TRIP_TIME_GAP_REPORT",
"TRIP_COST_GAP_REPORT",
""
};
Required_System_Files (required_files);
Optional_System_Files (optional_files);
Data_Service_Keys (data_service_keys);
Select_Service_Keys (select_service_keys);
Key_List (keys);
Report_List (reports);
Enable_Partitions (true);
#ifdef THREADS
Enable_Threads (true);
#endif
#ifdef MPI_EXE
Enable_MPI (true);
#endif
select_flag = cost_flag = time_sum_flag = cost_sum_flag = time_gap_flag = cost_gap_flag = merge_flag = false;
select_parts = time_sort = match_flag = false;
method = RANDOM_METHOD;
num_trips = num_select = 0;
cost_diff.Cost_Flag (true);
cost_gap.Cost_Flag (true);
System_Read_False (PLAN);
System_Data_Reserve (PLAN, 0);
}
Router::Router (void) : Demand_Service (), Problem_Service ()
{
Program ("Router");
Version ("4.0.71");
Title ("Network Path Builder");
Network_File required_network [] = {
NODE, LINK, LANE_CONNECTIVITY, PARKING, ACTIVITY_LOCATION, PROCESS_LINK, END_NETWORK
};
Network_File optional_network [] = {
DIRECTORY, LANE_USE, TOLL, TURN_PROHIBITION,
TRANSIT_STOP, TRANSIT_FARE, TRANSIT_ROUTE, TRANSIT_SCHEDULE,
END_NETWORK
};
Demand_File optional_demand [] = {
HOUSEHOLD, TRIP, ACTIVITY, LINK_DELAY, VEHICLE, VEHICLE_TYPE, END_DEMAND
};
char *keys [] = {
HOUSEHOLD_LIST,
HOUSEHOLD_RECORD_FILE,
PARKING_PENALTY_FILE,
TRANSIT_PENALTY_FILE,
TIME_OF_DAY_FORMAT,
PLAN_FILE,
PLAN_FORMAT,
NEW_PLAN_FILE,
NEW_PLAN_FORMAT,
NODE_LIST_PATHS,
ROUTE_SELECTED_MODES,
ROUTE_SELECTED_PURPOSES,
ROUTE_WITH_SPECIFIED_MODE,
ROUTE_FROM_SPECIFIED_LOCATIONS,
ROUTE_TO_SPECIFIED_LOCATIONS,
ROUTE_AT_SPECIFIED_TIMES,
ROUTE_BY_TIME_INCREMENT,
UPDATE_PLAN_RECORDS,
PRINT_UPDATE_WARNINGS,
IGNORE_VEHICLE_ID,
LIMIT_PARKING_ACCESS,
WALK_PATH_DETAILS,
ADJUST_ACTIVITY_SCHEDULE,
IGNORE_ACTIVITY_DURATIONS,
IGNORE_TIME_CONSTRAINTS,
END_TIME_CONSTRAINT,
IGNORE_ROUTING_PROBLEMS,
INTERPOLATE_LINK_DELAYS,
PERCENT_RANDOM_IMPEDANCE,
RANDOM_NUMBER_SEED,
HOUSEHOLD_TYPE_SCRIPT,
WALK_SPEED,
BICYCLE_SPEED,
WALK_TIME_VALUE,
BICYCLE_TIME_VALUE,
FIRST_WAIT_VALUE,
TRANSFER_WAIT_VALUE,
VEHICLE_TIME_VALUE,
DISTANCE_VALUE,
COST_VALUE,
LEFT_TURN_PENALTY,
RIGHT_TURN_PENALTY,
U_TURN_PENALTY,
TRANSFER_PENALTY,
STOP_WAITING_PENALTY,
STATION_WAITING_PENALTY,
BUS_BIAS_FACTOR,
BUS_BIAS_CONSTANT,
RAIL_BIAS_FACTOR,
RAIL_BIAS_CONSTANT,
MAX_WALK_DISTANCE,
MAX_BICYCLE_DISTANCE,
MAX_WAIT_TIME,
MIN_WAIT_TIME,
MAX_NUMBER_OF_TRANSFERS,
MAX_NUMBER_OF_PATHS,
MAX_PARK_RIDE_PERCENTAGE,
MAX_KISS_RIDE_PERCENTAGE,
KISS_RIDE_TIME_FACTOR,
KISS_RIDE_STOP_TYPES,
MAX_KISS_RIDE_DROPOFF_WALK,
MAX_LEGS_PER_PATH,
ADD_WAIT_TO_TRANSIT_LEG,
FARE_CLASS_DISTRIBUTION,
PARKING_HOURS_BY_PURPOSE,
LOCAL_ACCESS_DISTANCE,
LOCAL_FACILITY_TYPE,
MAX_CIRCUITY_RATIO,
MIN_CIRCUITY_DISTANCE,
MAX_CIRCUITY_DISTANCE,
MAX_LINK_DELAY_ERRORS,
LINK_DELAY_UPDATE_RATE,
LINK_DELAY_VOL_FACTOR,
LINK_DELAY_START_TIME,
LINK_DELAY_END_TIME,
EQUATION_PARAMETERS_x,
NEW_PROBLEM_FILE,
NEW_PROBLEM_FORMAT,
MAX_ROUTING_PROBLEMS,
ARCVIEW_PROBLEM_DUMP,
PROBLEM_DUMP_TYPE,
PERCENT_PROBLEMS_DUMPED,
NEW_PATH_ATTRIBUTE_FILE,
NULL
};
char *reports [] = {
"HOUSEHOLD_TYPE_SCRIPT",
"HOUSEHOLD_TYPE_STACK",
"FARE_DATA_REPORT",
NULL
};
Required_Network_Files (required_network);
Optional_Network_Files (optional_network);
Optional_Demand_Files (optional_demand);
Key_List (keys);
Report_List (reports);
Enable_Partitions (true);
Check_Data (true);
Renumber (true);
Max_Problems (100000);
nhh_list = nhh_proc = nrecord = nprocess = ntrips = num_trips = update_rate = nupdates = 0;
random_imped = max_tod = new_mode = nmagic = ntransit = nroute = tot_trips = 0;
last_traveler = last_trip = last_time = last_xfer = last_wait = last_acc = 0;
nlegs = nlegs_transit = nlegs_auto = 0;
vol_factor = 1;
limit_access = node_flag = true;
purpose_flag = ignore_veh_flag = reset_veh_flag = stop_imp_flag = skim_flag = warn_flag = false;
walk_net = bike_net = drive_net = loc_net = transit_net = fare_flag = wait_leg_flag = false;
hhlist_flag = hhold_flag = hhrec_flag = trip_flag = ignore_time = update_flag = tod_flag = false;
random_flag = walk_flag = bike_flag = walk_detail = walk_active = local_flag = false;
save_plans = problem_flag = ignore_errors = delay_flag = zero_flag = old_plan_flag = false;
mode_flag = park_ride_flag = distance_flag = wait_flag = toll_flag = turn_flag = false;
time_flag = dist_flag = length_flag = wait_time_flag = use_flag = dump_flag = veh_flag = false;
activity_flag = select_od = select_org = select_des = select_time = park_imp_flag = false;
rail_bias_flag = bus_bias_flag = park_hours_flag = fare_class_flag = sel_dump_flag = false;
attribute_flag = interpolate_flag = adjust_flag = duration_flag = false;
first_ptr = last_ptr = NULL;
walk_speed = 1.0;
bike_speed = 4.0;
value_walk = 20;
value_bike = 15;
value_wait = 20;
value_xfer = 20;
value_time = 10;
value_distance = 0;
value_cost = 0;
value_roll = 3; //---- 1/8 resolution ----
value_round = (1 << (value_roll-1));
offset_roll = 11; //---- 1/2048 resolution ----
offset_round = (1 << (offset_roll-1));
time_period = 900; //---- 15 minutes ----
max_walk = 2000;
max_bike = 10000;
max_wait = 60;
min_wait = 0;
max_transfers = 3;
max_paths = 4;
max_parkride = 50;
max_kissride = 35;
kissride_factor = 250;
kissride_walk = 100;
rail_bias = 100;
rail_constant = 0;
bus_bias = 100;
bus_constant = 0;
park_hours = 0;
xfer_imped = 0;
stop_imped = 0;
station_imped = 0;
left_imped = 0;
right_imped = 0;
uturn_imped = 0;
traveler_class = CASH;
local_type = EXTERNAL;
local_distance = 2000;
end_time = 0; //---- 0 minutes ----
leg_check = 1000;
min_distance = 2000;
max_distance = 20000;
max_ratio = 0;
dump_type = 0;
percent_dump = Round (100);
memset (&attribute_data, '\0', sizeof (attribute_data));
default_vehicle.ID (1);
default_vehicle.Type (CAR);
default_vehicle.Sub_Type (0);
default_vehicle.Passengers (0);
default_vehicle.Household (1);
default_vehicle.Location (1);
}
PlanCompare::PlanCompare (void) : Demand_Service ()
{
Program ("PlanCompare");
Version ("4.0.50");
Title ("Compare Two Plan Files");
Network_File optional_network [] = {
DIRECTORY, ACTIVITY_LOCATION, END_NETWORK
};
char *keys [] = {
INPUT_PLAN_FILE,
INPUT_PLAN_FORMAT,
INPUT_TRIP_FILE,
COMPARE_PLAN_FILE,
COMPARE_PLAN_FORMAT,
COMPARE_LOCATION_FILE,
COMPARE_TRIP_FILE,
OUTPUT_PLAN_FILE,
OUTPUT_PLAN_FORMAT,
NODE_LIST_PATHS,
HOUSEHOLD_LIST,
SELECT_TRAVELERS,
SELECT_TRIP_MODES,
IGNORE_LOCATION_DIFFERENCES,
INDEX_BY_COMPARE_LOCATION,
ONLY_COMPARE_DRIVE_LEGS,
COMPARE_GENERALIZED_COSTS,
PERCENT_TIME_DIFFERENCE,
MINIMUM_TIME_DIFFERENCE,
MAXIMUM_TIME_DIFFERENCE,
PERCENT_PATH_DIFFERENCE,
MINIMUM_PATH_DIFFERENCE,
MAXIMUM_PATH_DIFFERENCE,
SELECTION_PERCENTAGE,
MAXIMUM_PERCENT_SELECTED,
SELECT_BY_PERCENT_DIFFERENCE,
SELECT_BY_RELATIVE_GAP,
SELECT_TIME_PERIODS,
RANDOM_NUMBER_SEED,
TIME_OF_DAY_FORMAT,
SUMMARY_TIME_PERIODS,
SUMMARY_TIME_INCREMENT,
PERIOD_CONTROL_POINT,
HIGHEST_MATCH_DIFFERENCE,
LOWEST_MATCH_DIFFERENCE,
NEW_DISTRIBUTION_FILE,
NEW_COST_DISTRIBUTION_FILE,
NEW_MODE_DISTRIBUTION_FILE,
NEW_MODE_DISTRIBUTION_DATA_FILE,
NEW_DIFFERENCE_FILE,
NEW_START_DIFFERENCE_FILE,
NEW_END_DIFFERENCE_FILE,
NEW_TRIP_TIME_FILE,
NEW_TRAVELER_MATCH_FILE,
NEW_INCOMPLETE_TRIP_FILE,
NEW_PERIOD_DIFFERENCE_FILE,
NULL
};
char *reports [] = {
"PERCENT_PATH_CHANGE",
"PERCENT_TRAVEL_TIME_CHANGE",
"PERCENT_GENERALIZED_COST_CHANGE",
"DUMP_PATH_CHANGES_GREATER_THAN_*",
"DUMP_TRAVEL_TIME_CHANGES_GREATER_THAN_*",
"DUMP_COST_CHANGES_GREATER_THAN_*",
"TOTAL_DIFFERENCE_DISTRIBUTION",
"TIME_DIFFERENCE_DISTRIBUTIONS",
"TIME_PERIOD_SUMMARY",
"GENERALIZED_COST_DISTRIBUTION",
"COST_DIFFERENCE_DISTRIBUTIONS",
"COST_PERIOD_SUMMARY",
"TRIP_GAP_REPORT",
NULL
};
Optional_Network_Files (optional_network);
Key_List (keys);
Report_List (reports);
Enable_Partitions (true);
num_matched = num_complete = num_drive = num_compared = num_equal = in_only = compare_only = num_bad = period_point = 0;
output_flag = select_flag = diff_flag = hhlist_flag = distrib_flag = time_flag = false;
path_diff_flag = diff_file_flag = period_flag = trip_flag = ignore_flag = drive_flag = false;
cost_flag = cost_data_flag = cost_distrib_flag = gap_flag = traveler_flag = gap_data_flag = false;
start_flag = end_flag = loc_flag = match_out_flag = incomplete_flag = compare_loc_flag = false;
mode_flag = mode_file_flag = drive_access_flag = mode_data_flag = period_diff_flag = false;
select_trips.Initialize (sizeof (Select_Trips), 2);
travel_diff.Initialize (sizeof (Travel_Diff), 3);
start_diff.Initialize (sizeof (Location_Diff), 2);
end_diff.Initialize (sizeof (Location_Diff), 2);
period_diff.Initialize (sizeof (Period_Diff), 10);
nsel = nout = 0;
tot_select = 0.0;
tot_diff = 0.0;
abs_diff = 0.0;
tot_base = 0.0;
sig_diff = 0.0;
sig_tot = 0.0;
min_diff = 0;
max_diff = 0;
max_time = 60;
min_time = 1;
min_path = 0;
max_path = 100000;
path_diff = 0.0;
percent = 100.0;
max_percent = 100.0;
percent_diff = 10.0;
high_diff = MAX_INTEGER;
low_diff = -MAX_INTEGER;
time_diff.Report_Numbers (TOTAL_DISTRIB, TTIME_DISTRIB, PERIOD_SUM);
cost_diff.Report_Numbers (TCOST_DISTRIB, COST_DISTRIB, COST_SUM);
cost_diff.Generalized_Cost (true);
change_text [PATH_CHANGE] = "Path";
change_text [TIME_CHANGE] = "Travel Time";
change_text [COST_CHANGE] = "Generalized Cost";
}
PlanSum::PlanSum (void) : Demand_Service ()
{
Program ("PlanSum");
Version ("4.0.59");
Title ("Summarize Plan File Demand");
Network_File optional_network [] = {
DIRECTORY, LINK, NODE, LANE_USE, PARKING, ACTIVITY_LOCATION, PROCESS_LINK,
LANE_CONNECTIVITY, TRANSIT_STOP, TRANSIT_ROUTE, TRANSIT_SCHEDULE,
TRANSIT_DRIVER, END_NETWORK
};
Demand_File optional_demand [] = {
LINK_DELAY, VEHICLE_TYPE, NEW_LINK_DELAY, NEW_RIDERSHIP, END_DEMAND
};
char *keys [] = {
PLAN_FILE,
PLAN_FORMAT,
NODE_LIST_PATHS,
HOUSEHOLD_LIST,
HOUSEHOLD_PERSON_COUNT,
SUMMARY_TIME_PERIODS,
SUMMARY_TIME_INCREMENT,
NEW_PLAN_FILE,
NEW_LINK_VOLUME_FILE,
NEW_LINK_VOLUME_FORMAT,
KEEP_INPUT_TRAVEL_TIMES,
EQUATION_PARAMETERS_x,
LINK_EQUIVALENCE_FILE,
NEW_TRIP_TIME_FILE,
NEW_ZONE_SKIM_FILE,
NEW_ZONE_SKIM_FORMAT,
SKIM_MODE_SELECTION,
SKIM_TOTAL_TIME,
SKIM_TRIP_LENGTH,
SKIM_TIME_CONTROL_POINT,
NEAREST_NEIGHBOR_FACTOR,
NEW_TRIP_TABLE_FILE,
NEW_TRIP_TABLE_FORMAT,
TRIP_MODE_SELECTION,
ZONE_EQUIVALENCE_FILE,
NEW_TURN_MOVEMENT_FILE,
NEW_TURN_MOVEMENT_FORMAT,
TURN_NODE_RANGE,
STOP_EQUIVALENCE_FILE,
OUTPUT_ALL_TRANSIT_STOPS,
NULL
};
char *reports [] = {
"TOP_100_V/C_RATIOS",
"ALL_V/C_RATIOS_GREATER_THAN_*",
"LINK_GROUP_V/C_RATIOS_*",
"PRINT_LINK_EQUIVALENCIES",
"PRINT_ZONE_EQUIVALENCIES",
"PRINT_STOP_EQUIVALENCIES",
"TRANSIT_RIDERSHIP_SUMMARY",
"TRANSIT_STOP_SUMMARY",
"TRANSIT_TRANSFER_SUMMARY",
"TRANSIT_TRANSFER_DETAILS",
"TRANSIT_STOP_GROUP_SUMMARY",
"TRANSIT_PASSENGER_SUMMARY",
"TRANSIT_LINK_GROUP_SUMMARY",
"TRIP_TIME_REPORT",
"TRAVEL_SUMMARY_REPORT",
NULL
};
Optional_Network_Files (optional_network);
Optional_Demand_Files (optional_demand);
Key_List (keys);
Report_List (reports);
Enable_Partitions (true);
AB_Key_Flag (true);
volume_flag = time_flag = skim_flag = trip_flag = zone_flag = transit_flag = passenger_flag = false;
delay_in = delay_out = turn_flag = turn_delay = hhlist_flag = travel_flag = update_flag = false;
time_skim_flag = xfer_flag = xfer_detail = neighbor_flag = length_flag = count_flag = stops_flag = false;
type_flag = vc_flag = true;
layer = 1;
increment = 900;
num_inc = 96;
cap_factor = 0.25;
neighbor_factor = 0.5;
skim_point = 2;
movement_data = NULL;
node_range = NULL;
boardings = NULL;
max_rail = 0;
xfer_label [0] = '\0';
stop_array = (Stop_Array *) new Transfer_Array ();
}
TripPrep::TripPrep (void) : Demand_Service ()
{
Program ("TripPrep");
Version ("4.0.10");
Title ("Prepare Trip and Activity Files");
Network_File optional_network [] = {
DIRECTORY, ACTIVITY_LOCATION, PROCESS_LINK, END_NETWORK
};
Demand_File optional_demand [] = {
TRIP, ACTIVITY, VEHICLE, NEW_TRIP, NEW_ACTIVITY, NEW_VEHICLE, END_DEMAND
};
char *keys [] = {
HOUSEHOLD_LIST,
MERGE_TRIP_FILE,
MERGE_TRIP_FORMAT,
MERGE_ACTIVITY_FILE,
MERGE_ACTIVITY_FORMAT,
MERGE_VEHICLE_FILE,
MERGE_VEHICLE_FORMAT,
TIME_OF_DAY_FORMAT,
SELECT_HOUSEHOLDS,
SELECT_TIME_PERIODS,
SELECT_TRIP_MODES,
SELECT_TRIP_PURPOSES,
SELECT_ORIGIN_ZONES,
SELECT_DESTINATION_ZONES,
SELECT_ORIGIN_POLYGON,
SELECT_DESTINATION_POLYGON,
SELECT_PROBABILITY_FILE,
SELECT_PROBABILITY_FORMAT,
ZONE_EQUIVALENCE_FILE,
TIME_PERIOD_EQUIVALENCE,
SELECTION_PERCENTAGE,
RANDOM_NUMBER_SEED,
START_TIME_SHIFT,
DATA_PROCESSING_SCRIPT,
OUTPUT_ALL_RECORDS,
CREATE_INDEPENDENT_TRIPS,
NEW_HOUSEHOLD_LIST,
STARTING_HOUSEHOLD_ID,
STARTING_VEHICLE_ID,
ZONE_TARGET_FILE,
TARGET_HOUSEHOLD_RANGE,
MOVE_ORIGIN_FILE,
MOVE_DESTINATION_FILE,
CONVERT_ACTIVITIES_TO_TRIPS,
NULL
};
char *reports [] = {
"PRINT_ZONE_EQUIVALENCIES",
"TIME_PERIOD_EQUIVALENCE",
"DATA_PROCESSING_SCRIPT",
"DATA_PROCESSING_STACK",
NULL
};
Optional_Network_Files (optional_network);
Optional_Demand_Files (optional_demand);
Key_List (keys);
Report_List (reports);
Enable_Partitions (true);
trip_flag = activity_flag = purpose_flag = prob_flag = shift_flag = false;
hhlist_flag = output_flag = vehicle_flag = all_flag = false;
split_flag = zone_equiv_flag = synod_flag = script_flag = false;
select_org_flag = select_des_flag = org_zone_flag = des_zone_flag = false;
location_flag = factor_flag = create_flag = newhh_flag = convert_flag = false;
merge_trip_flag = merge_act_flag = merge_veh_flag = move_org_flag = move_des_flag = false;
nzone = 0;
first_veh = veh_count = NULL;
next_veh = NULL;
synod = NULL;
org_target = des_target = org_total = des_total = NULL;
probability = 1.0;
shift_size = 0;
total_in = total_out = total_used = total_hhold = 0;
hhold_id = veh_id = 1;
move_org_map.Initialize (2 * sizeof (int), 10);
move_des_map.Initialize (2 * sizeof (int), 10);
move_veh_map.Initialize (2 * sizeof (int), 10);
}
SubareaPlans::SubareaPlans (void) : Demand_Service ()
{
Program ("SubareaPlans");
Version ("4.0.33");
Title ("Subarea Plan and Vehicle Files");
Network_File required_network [] = {
NODE, LINK, ACTIVITY_LOCATION, PARKING, PROCESS_LINK, END_NETWORK
};
Network_File optional_network [] = {
DIRECTORY, LANE_CONNECTIVITY, NEW_DIRECTORY,
NEW_ACTIVITY_LOCATION, NEW_PARKING, NEW_PROCESS_LINK,
TRANSIT_STOP, TRANSIT_ROUTE, TRANSIT_SCHEDULE, TRANSIT_DRIVER,
NEW_TRANSIT_STOP, NEW_TRANSIT_ROUTE, NEW_TRANSIT_SCHEDULE, NEW_TRANSIT_DRIVER,
END_NETWORK
};
Demand_File required_demand [] = {
VEHICLE, NEW_VEHICLE, END_DEMAND
};
Demand_File optional_demand [] = {
LINK_DELAY, NEW_BOUNDARY_SPEED, END_DEMAND
};
char *keys [] = {
PLAN_FILE,
PLAN_FORMAT,
NODE_LIST_PATHS,
SUBAREA_BOUNDARY_POLYGON,
EXTERNAL_OFFSET_LENGTH,
NEW_PLAN_FILE,
NEW_PLAN_FORMAT,
NEW_HOUSEHOLD_LIST,
RETIME_EARLY_ARRIVALS,
ZONE_EQUIVALENCE_FILE,
TIME_PERIOD_EQUIVALENCE,
SELECT_TIME_PERIODS,
NULL
};
char *reports [] = {
"TRIP_SUMMARY_REPORT",
"PRINT_ZONE_EQUIVALENCIES",
"TIME_PERIOD_EQUIVALENCE",
NULL
};
Required_Network_Files (required_network);
Optional_Network_Files (optional_network);
Required_Demand_Files (required_demand);
Optional_Demand_Files (optional_demand);
Key_List (keys);
Report_List (reports);
Enable_Partitions (true);
AB_Key_Flag (true);
trips = NULL;
type_flag = true;
transit_flag = output_flag = range_flag = false;
delay_flag = location_flag = parking_flag = access_flag = extend_flag = early_flag = false;
trip_flag = zone_flag = time_flag = turn_flag = hhlist_flag = boundary_flag = false;
nlink = nshort = nlocation = nparking = naccess = num_adjust = total_adjust = 0;
max_location = max_parking = max_access = max_vehicle = max_zone = 0;
num_in_in = num_out_in = num_in_out = num_out_out = 0;
leg_in_in = leg_out_in = leg_in_out = leg_out_out = 0;
max_stop = max_route = 0;
new_stop = new_route = 0;
nstop = nroute = nschedule = ndriver = 0;
current_traveler = current_trip = current_leg = boarding_stop = last_location = last_time = 0;
external_offset = Round (15); //---- 15 meters ----
boundary.Data_Size (sizeof (Boundary));
Compress_Vehicles (false);
}
