void LinkSum::Program_Control (void)
{
int i, field, ngroup, num;
bool binary;
String key, token;
Location_File *location_file;
Db_Field *fld;
Doubles dbl;
Doubles_Itr itr;
//---- set the equivalence flags ----
Zone_Equiv_Flag (Check_Control_Key (NEW_GROUP_TRAVEL_FILE));
group_select = Set_Control_Flag (SELECT_BY_LINK_GROUP);
Link_Equiv_Flag (group_select || Report_Flag (LINK_GROUP) || Report_Flag (TRAVEL_TIME) ||
Report_Flag (GROUP_REPORT) || Report_Flag (GROUP_SUMMARY) || Check_Control_Key (NEW_GROUP_SUMMARY_FILE));
//---- open network files ----
Data_Service::Program_Control ();
Read_Select_Keys ();
turn_flag = System_File_Flag (TURN_DELAY);
Print (2, String ("%s Control Keys:") % Program ());
//---- open the compare performance file ----
key = Get_Control_String (COMPARE_PERFORMANCE_FILE);
if (!key.empty ()) {
compare_file.File_Type ("Compare Performance File");
Print (1);
if (Check_Control_Key (COMPARE_PERFORMANCE_FORMAT)) {
compare_file.Dbase_Format (Get_Control_String (COMPARE_PERFORMANCE_FORMAT));
}
compare_file.Open (Project_Filename (key));
compare_flag = true;
}
num_inc = sum_periods.Num_Periods ();
if (num_inc < 1) num_inc = 1;
cap_factor = (double) sum_periods.Range_Length () / (Dtime (1, HOURS) * num_inc);
if (cap_factor <= 0.0) cap_factor = 1.0;
//---- open the compare link map file ----
key = Get_Control_String (COMPARE_LINK_MAP_FILE);
if (!key.empty ()) {
link_map_file.File_Type ("Compare Link Map File");
Print (1);
if (Check_Control_Key (COMPARE_LINK_MAP_FORMAT)) {
link_map_file.Dbase_Format (Get_Control_String (COMPARE_LINK_MAP_FORMAT));
}
link_map_file.Open (Project_Filename (key));
link_map_flag = true;
}
//---- get minimum volume ----
minimum_volume = Get_Control_Double (MINIMUM_LINK_VOLUME);
//---- person-based statistics ----
person_flag = Get_Control_Flag (PERSON_BASED_STATISTICS);
//---- get the select by link group flag ----
group_select = Get_Control_Flag (SELECT_BY_LINK_GROUP);
if (group_select || select_subareas || select_polygon || select_facilities) select_flag = true;
//---- turning movement data ----
if (turn_flag) {
//---- open the compare turn delays file ----
key = Get_Control_String (COMPARE_TURN_DELAY_FILE);
if (!key.empty ()) {
turn_compare_file.File_Type ("Compare Turn Delay File");
Print (1);
if (Check_Control_Key (COMPARE_TURN_DELAY_FORMAT)) {
turn_compare_file.Dbase_Format (Get_Control_String (COMPARE_TURN_DELAY_FORMAT));
}
turn_compare_file.Open (Project_Filename (key));
turn_compare_flag = true;
}
//---- select turn nodes----
key = exe->Get_Control_Text (TURN_NODE_RANGE);
if (!key.empty () && !key.Equals ("ALL")) {
if (!turn_range.Add_Ranges (key)) {
exe->Error ("Adding Turn Node Ranges");
}
}
}
//---- create link activity file ----
key = Get_Control_String (NEW_LINK_ACTIVITY_FILE);
if (!key.empty ()) {
if (!System_File_Flag (LOCATION)) {
Error ("A Location File is needed for the Link Activity File");
}
location_file = System_Location_File ();
binary = (location_file->Record_Format () == BINARY);
Print (1);
activity_file.File_Type ("New Link Activity File");
if (Check_Control_Key (NEW_LINK_ACTIVITY_FORMAT)) {
activity_file.Dbase_Format (Get_Control_String (NEW_LINK_ACTIVITY_FORMAT));
}
activity_file.Create (Project_Filename (key));
//---- copy location field name ----
key = Get_Control_Text (COPY_LOCATION_FIELDS);
if (key.empty ()) {
Error ("Location Field Names are Required for Link Activity File");
}
link_db.File_Type ("Link Location Database");
//---- set required fields ----
link_db.Add_Field ("LINK", DB_INTEGER, 10);
activity_file.Add_Field ("LINK", DB_INTEGER, 10);
//---- copy selected fields ----
while (!key.Split (token)) {
field = location_file->Field_Number (token);
if (field < 0) {
Error (String ("Field %s was Not Found in the Location File") % token);
}
field_list.push_back (field);
fld = location_file->Field (field);
link_db.Add_Field (fld->Name (), fld->Type (), fld->Size (), fld->Units (), binary);
activity_file.Add_Field (fld->Name (), fld->Type (), fld->Size (), fld->Units (), binary);
}
activity_file.Write_Header ();
activity_flag = true;
}
//---- create zone travel file ----
key = Get_Control_String (NEW_ZONE_TRAVEL_FILE);
if (!key.empty ()) {
if (!System_File_Flag (LOCATION)) {
Error ("A Location File is needed for the Zone Travel File");
}
Print (1);
zone_file.File_Type ("New Zone Travel File");
if (Check_Control_Key (NEW_ZONE_TRAVEL_FORMAT)) {
zone_file.Dbase_Format (Get_Control_String (NEW_ZONE_TRAVEL_FORMAT));
}
zone_file.Create (Project_Filename (key));
zone_flag = true;
}
//---- create zone group travel file ----
key = Get_Control_String (NEW_GROUP_TRAVEL_FILE);
if (!key.empty ()) {
if (!System_File_Flag (LOCATION)) {
Error ("A Location File is needed for the Group Travel File");
}
Print (1);
group_file.File_Type ("New Group Travel File");
if (Check_Control_Key (NEW_GROUP_TRAVEL_FORMAT)) {
group_file.Dbase_Format (Get_Control_String (NEW_GROUP_TRAVEL_FORMAT));
}
group_file.Create (Project_Filename (key));
group_flag = true;
}
if (!activity_flag && !zone_flag && !group_flag) {
System_File_False (LOCATION);
}
//---- get the number of direction groups ----
ngroup = Highest_Control_Group (NEW_LINK_DIRECTION_FILE, 0);
if (ngroup > 0) {
Dir_Group group, *group_ptr;
//---- process each group ----
for (i=1; i <= ngroup; i++) {
key = Get_Control_String (NEW_LINK_DIRECTION_FILE, i);
if (key.empty ()) continue;
Print (1);
dir_group.push_back (group);
group_ptr = &dir_group.back ();
group_ptr->group = i;
group_ptr->file = new Link_Direction_File ();
group_ptr->file->File_Type (String ("New Link Direction File #%d") % i);
if (Check_Control_Key (NEW_LINK_DIRECTION_FORMAT, i)) {
group_ptr->file->Dbase_Format (Get_Control_String (NEW_LINK_DIRECTION_FORMAT, i));
}
group_ptr->file->Lane_Use_Flows (Lane_Use_Flows ());
group_ptr->file->Create (Project_Filename (key));
//---- get the field name ----
key = Get_Control_Text (NEW_LINK_DIRECTION_FIELD, i);
if (key.empty ()) {
Error (String ("New Link Direction Field #%d is Missing") % i);
}
group_ptr->field = Performance_Code (key);
group_ptr->index = Get_Control_Flag (NEW_LINK_DIRECTION_INDEX, i);
group_ptr->flip = Get_Control_Flag (NEW_LINK_DIRECTION_FLIP, i);
if (group_ptr->flip && !compare_flag) {
Warning ("Link Direction Flipping requires Comparison Data");
group_ptr->flip = false;
}
Set_Link_Dir (group_ptr);
}
}
//---- get the number of groups ----
ngroup = Highest_Control_Group (NEW_LINK_DATA_FILE, 0);
if (ngroup > 0) {
Data_Group group, *group_ptr;
//---- process each group ----
for (i=1; i <= ngroup; i++) {
key = Get_Control_String (NEW_LINK_DATA_FILE, i);
if (key.empty ()) continue;
Print (1);
data_group.push_back (group);
group_ptr = &data_group.back ();
group_ptr->group = i;
group_ptr->file = new Link_Data_File ();
group_ptr->file->File_Type (String ("New Link Data File #%d") % i);
if (Check_Control_Key (NEW_LINK_DATA_FORMAT, i)) {
group_ptr->file->Dbase_Format (Get_Control_String (NEW_LINK_DATA_FORMAT, i));
}
group_ptr->file->Lane_Use_Flows (Lane_Use_Flows ());
group_ptr->file->Create (Project_Filename (key));
//---- get the field name ----
key = Get_Control_Text (NEW_LINK_DATA_FIELD, i);
if (key.empty ()) {
Error (String ("New Link Data Field #%d is Missing") % i);
}
group_ptr->field = Performance_Code (key);
Set_Link_Data (group_ptr);
}
}
//---- data summary file ----
key = Get_Control_String (NEW_DATA_SUMMARY_FILE);
if (!key.empty ()) {
Print (1);
summary_file.File_Type ("New Data Summary File");
if (Check_Control_Key (NEW_DATA_SUMMARY_FORMAT)) {
summary_file.Dbase_Format (Get_Control_String (NEW_DATA_SUMMARY_FORMAT));
}
summary_file.Add_Field ("MEASURE", DB_STRING, 40);
summary_file.Add_Field ("VALUE", DB_DOUBLE, 12.2);
if (compare_flag) summary_file.Add_Field ("COMPARE", DB_DOUBLE, 12.2);
summary_file.Create (Project_Filename (key));
summary_flag = true;
//---- data summary periods ----
if (!Control_Key_Empty (NEW_DATA_SUMMARY_PERIODS)) {
periods_flag = data_periods.Add_Ranges (Get_Control_Text (NEW_DATA_SUMMARY_PERIODS));
}
//---- data summary ratios ----
if (Check_Control_Key (NEW_DATA_SUMMARY_RATIOS)) {
Double_List list;
Dbl_Itr itr;
Get_Control_List (NEW_DATA_SUMMARY_RATIOS, list);
for (i=0, itr = list.begin (); itr != list.end (); itr++, i++) {
if (i > 0 && *itr >= 1.0) {
data_ratios.push_back (Round (*itr * 100.0));
ratios_flag = true;
}
}
}
}
//---- group summary file ----
key = Get_Control_String (NEW_GROUP_SUMMARY_FILE);
if (!key.empty ()) {
Print (1);
group_sum_file.File_Type ("New Group Summary File");
if (Check_Control_Key (NEW_GROUP_SUMMARY_FORMAT)) {
group_sum_file.Dbase_Format (Get_Control_String (NEW_GROUP_SUMMARY_FORMAT));
}
group_sum_file.Add_Field ("MEASURE", DB_STRING, 40);
group_sum_file.Add_Field ("VALUE", DB_DOUBLE, 12.2);
if (compare_flag) group_sum_file.Add_Field ("COMPARE", DB_DOUBLE, 12.2);
group_sum_file.Create (Project_Filename (key));
group_sum_flag = true;
}
//---- read report types ----
List_Reports ();
if (!compare_flag && (Report_Flag (TIME_CHANGE) || Report_Flag (VOLUME_CHANGE) ||
Report_Flag (TOP_TIME_CHANGE) || Report_Flag (TOP_VOL_CHANGE) || Report_Flag (RELATIVE_GAP))) {
Error ("A Compare Performance File is Required for Change Reports");
}
//---- process support data ----
if (Link_Equiv_Flag ()) {
link_equiv.Read (Report_Flag (LINK_EQUIV));
}
if (group_flag) {
zone_equiv.Read (Report_Flag (ZONE_EQUIV));
}
//---- allocate work space ----
if (periods_flag || ratios_flag) {
num = (periods_flag) ? (int) data_periods.size () : 1;
num += (ratios_flag) ? (int) data_ratios.size () : 1;
if (num_inc + 1 > num) {
num = num_inc + 1;
}
} else {
num = num_inc + 1;
}
sum_bin.assign (num, dbl);
for (itr = sum_bin.begin (); itr != sum_bin.end (); itr++) {
itr->assign (NUM_SUM_BINS, 0.0);
}
}
void PlanSum::Program_Control (void)
{
String key;
bool link_flag, report_flag;
link_flag = report_flag = false;
if (!Set_Control_Flag (UPDATE_FLOW_RATES) && !Set_Control_Flag (UPDATE_TRAVEL_TIMES)) {
System_File_False (NEW_LINK_DELAY);
}
//---- initialize the MPI thread range ----
MPI_Setup ();
//---- set equivalence flags ---
if (Report_Flag (LINK_GROUP) || Report_Flag (RIDER_GROUP)) {
Link_Equiv_Flag (true);
link_flag = true;
}
if (skim_flag || trip_flag) {
Zone_Equiv_Flag (true);
zone_flag = true;
}
Stop_Equiv_Flag (Report_Flag (STOP_GROUP));
//---- create the network files ----
Data_Service::Program_Control ();
Read_Select_Keys ();
Read_Flow_Time_Keys ();
plan_file = (Plan_File *) System_File_Handle (PLAN);
if (!plan_file->Part_Flag ()) Num_Threads (1);
select_flag = System_File_Flag (SELECTION);
new_delay_flag = System_File_Flag (NEW_LINK_DELAY);
if (System_File_Flag (LINK_DELAY)) {
link_flag = true;
Link_Delay_File *file = (Link_Delay_File *) System_File_Handle (LINK_DELAY);
turn_flag = file->Turn_Flag ();
}
if (new_delay_flag) {
link_flag = true;
Link_Delay_File *file = (Link_Delay_File *) System_File_Handle (NEW_LINK_DELAY);
turn_flag = file->Turn_Flag ();
} else {
turn_flag = System_File_Flag (CONNECTION);
}
Print (2, String ("%s Control Keys:") % Program ());
//---- new trip time file ----
key = Get_Control_String (NEW_TRIP_TIME_FILE);
if (!key.empty ()) {
time_file.File_Type ("New Trip Time File");
time_file.File_ID ("Time");
if (Master ()) {
time_file.Create (Project_Filename (key));
}
time_flag = true;
}
//---- new link volume file ----
key = Get_Control_String (NEW_LINK_VOLUME_FILE);
if (!key.empty ()) {
volume_file.File_Type ("New Link Volume File");
volume_file.File_ID ("Volume");
if (Master ()) {
volume_file.Create (Project_Filename (key));
volume_file.Num_Decimals (1);
volume_file.Data_Units (Performance_Units_Map (FLOW_DATA));
volume_file.Copy_Periods (sum_periods);
volume_file.Create_Fields ();
volume_file.Write_Header ();
}
volume_flag = new_delay_flag = link_flag = true;
}
//---- read report types ----
List_Reports ();
if (Report_Flag (TOP_100) || Report_Flag (VC_RATIO) || Report_Flag (LINK_GROUP)) {
new_delay_flag = link_flag = report_flag = true;
cap_factor = (double) sum_periods.Range_Length () / (Dtime (1, HOURS) * sum_periods.Num_Periods ());
}
if (link_flag && (!System_File_Flag (LINK) || !System_File_Flag (NODE))) {
Error ("Link and Node Files are Required for Link-Based Output");
}
if (System_File_Flag (LANE_USE) && !System_File_Flag (LINK)) {
Error ("A Link File is Required for Lane-Use Processing");
}
travel_flag = Report_Flag (SUM_TRAVEL);
//---- ridership summary ----
passenger_flag = Report_Flag (SUM_PASSENGERS);
transfer_flag = (Report_Flag (SUM_STOPS) || Report_Flag (STOP_GROUP));
rider_flag = (System_File_Flag (NEW_RIDERSHIP) || Report_Flag (SUM_RIDERS) || Report_Flag (RIDER_GROUP));
xfer_flag = Report_Flag (SUM_TRANSFERS);
xfer_detail = Report_Flag (XFER_DETAILS);
if (passenger_flag || transfer_flag || rider_flag || xfer_flag || xfer_detail) {
if (!System_File_Flag (TRANSIT_STOP) || !System_File_Flag (TRANSIT_ROUTE) ||
!System_File_Flag (TRANSIT_SCHEDULE)) {
Error ("Transit Network Files are Required for Ridership Output");
}
if ((passenger_flag || rider_flag) && !System_File_Flag (TRANSIT_DRIVER)) {
Error ("A Transit Driver File is needed for Passengers Summaries");
}
} else {
System_File_False (TRANSIT_STOP);
System_File_False (TRANSIT_ROUTE);
System_File_False (TRANSIT_SCHEDULE);
System_File_False (TRANSIT_DRIVER);
}
//---- process support data ----
if (Link_Equiv_Flag ()) {
link_equiv.Read (Report_Flag (LINK_EQUIV));
}
if (Zone_Equiv_Flag ()) {
zone_equiv.Read (Report_Flag (ZONE_EQUIV));
}
if (Stop_Equiv_Flag ()) {
stop_equiv.Read (Report_Flag (STOP_EQUIV));
}
//---- allocate work space ----
if (time_flag || Report_Flag (TRIP_TIME)) {
time_flag = true;
int periods = sum_periods.Num_Periods ();
start_time.assign (periods, 0);
mid_time.assign (periods, 0);
end_time.assign (periods, 0);
}
//---- transfer arrays ----
if (xfer_flag || xfer_detail) {
Integers rail;
rail.assign (10, 0);
total_on_array.assign (10, rail);
if (xfer_detail) {
int num = sum_periods.Num_Periods ();
if (num < 1) num = 1;
walk_on_array.assign (num, total_on_array);
drive_on_array.assign (num, total_on_array);
}
}
//---- initialize the trip summary data ----
if (travel_flag) {
trip_sum_data.Copy_Periods (sum_periods);
}
//---- initialize the passenger summary data ----
if (passenger_flag) {
pass_sum_data.Copy_Periods (sum_periods);
}
}
void NewFormat::Program_Control (void)
{
bool type_flag, flat_flag, time_flag;
String key;
//---- open the support files ----
Data_Service::Program_Control ();
if (Check_Control_Key (VERSION4_PLAN_FILE) && Check_Control_Key (TRIP_SORT_TYPE)) {
Warning ("Plan Sorting is Limited to Version 5 Plan files");
Show_Message (1);
}
Print (2, String ("%s Control Keys:") % Program ());
//---- copy existing fields ----
copy_flag = Get_Control_Flag (COPY_EXISTING_FIELDS);
if (copy_flag) {
if (System_File_Flag (LOCATION) && System_File_Flag (NEW_LOCATION)) {
Location_File *file = (Location_File *) System_File_Handle (LOCATION);
new_loc_file = (Location_File *) System_File_Handle (NEW_LOCATION);
new_loc_file->Add_User_Fields (file);
}
if (System_File_Flag (ZONE) && System_File_Flag (NEW_ZONE)) {
Zone_File *file = (Zone_File *) System_File_Handle (ZONE);
new_zone_file = (Zone_File *) System_File_Handle (NEW_ZONE);
new_zone_file->Add_User_Fields (file);
}
}
//---- copy existing configuration ----
if (System_File_Flag (LINK_DELAY) && System_File_Flag (NEW_LINK_DELAY)) {
Link_Delay_File *file = (Link_Delay_File *) System_File_Header (LINK_DELAY);
if (file->Turn_Flag ()) {
file = (Link_Delay_File *) System_File_Header (NEW_LINK_DELAY);
file->Clear_Fields ();
file->Turn_Flag (true);
file->Set_Nesting (true);
file->Create_Fields ();
file->Write_Header ();
}
}
if (System_File_Flag (PERFORMANCE) && System_File_Flag (NEW_PERFORMANCE)) {
Performance_File *file = (Performance_File *) System_File_Header (PERFORMANCE);
if (file->Turn_Flag ()) {
file = (Performance_File *) System_File_Header (NEW_PERFORMANCE);
file->Clear_Fields ();
file->Turn_Flag (true);
file->Set_Nesting (true);
file->Create_Fields ();
file->Write_Header ();
}
}
//---- flatten output flag ----
flat_flag = Get_Control_Flag (FLATTEN_OUTPUT_FLAG);
if (flat_flag) {
if (System_File_Flag (NEW_SHAPE)) {
System_File_Header (NEW_SHAPE)->Flatten_File ();
}
if (System_File_Flag (NEW_PARKING)) {
System_File_Header (NEW_PARKING)->Flatten_File ();
}
if (System_File_Flag (NEW_SIGNAL)) {
System_File_Header (NEW_SIGNAL)->Flatten_File ();
}
if (System_File_Flag (NEW_TIMING_PLAN)) {
System_File_Header (NEW_TIMING_PLAN)->Flatten_File ();
}
if (System_File_Flag (NEW_PHASING_PLAN)) {
System_File_Header (NEW_PHASING_PLAN)->Flatten_File ();
}
if (System_File_Flag (NEW_TRANSIT_ROUTE)) {
System_File_Header (NEW_TRANSIT_ROUTE)->Flatten_File ();
}
if (System_File_Flag (NEW_TRANSIT_SCHEDULE)) {
System_File_Header (NEW_TRANSIT_SCHEDULE)->Flatten_File ();
}
if (System_File_Flag (NEW_TRANSIT_DRIVER)) {
System_File_Header (NEW_TRANSIT_DRIVER)->Flatten_File ();
}
if (System_File_Flag (NEW_ROUTE_NODES)) {
System_File_Header (NEW_ROUTE_NODES)->Flatten_File ();
}
if (System_File_Flag (NEW_HOUSEHOLD)) {
System_File_Header (NEW_HOUSEHOLD)->Flatten_File ();
}
if (System_File_Flag (NEW_LINK_DELAY)) {
System_File_Header (NEW_LINK_DELAY)->Flatten_File ();
}
if (System_File_Flag (NEW_PERFORMANCE)) {
System_File_Header (NEW_PERFORMANCE)->Flatten_File ();
}
if (System_File_Flag (NEW_PLAN)) {
System_File_Header (NEW_PLAN)->Flatten_File ();
}
}
//---- toll file ----
key = Get_Control_String (TOLL_FILE);
if (!key.empty ()) {
toll_file.Open (Project_Filename (key));
toll_flag = true;
}
//---- activity file ----
key = Get_Control_String (ACTIVITY_FILE);
if (!key.empty ()) {
activity_file.Open (Project_Filename (key));
activity_flag = true;
if (!System_File_Flag (NEW_TRIP)) {
Error ("A New Trip file is required to convert an Activity File");
}
if (!System_File_Flag (VEHICLE)) {
Error ("A Vehicle file is required to convert an Activity File");
}
}
//---- person file ----
key = Get_Control_String (PERSON_FILE);
if (!key.empty ()) {
person_file.Open (Project_Filename (key));
person_flag = true;
}
//---- snapshot file ----
key = Get_Control_String (SNAPSHOT_FILE);
if (!key.empty ()) {
Print (1);
snap_file.Open (Project_Filename (key));
snap_flag = true;
}
//---- new snapshot file ----
key = Get_Control_String (NEW_SNAPSHOT_FILE);
if (!key.empty ()) {
new_snap_file.Compress_Flag (Set_Control_Flag (NEW_SNAPSHOT_COMPRESSION));
if (new_snap_file.Compress_Flag ()) {
new_snap_file.Dbase_Format (BINARY);
} else {
if (Check_Control_Key (NEW_SNAPSHOT_FORMAT)) {
new_snap_file.Dbase_Format (Get_Control_String (NEW_SNAPSHOT_FORMAT));
}
new_snap_file.Location_Flag (snap_file.Location_Flag ());
new_snap_file.Cell_Flag (snap_file.Cell_Flag ());
new_snap_file.Status_Flag (snap_file.Status_Flag ());
}
new_snap_file.Create (Project_Filename (key));
Get_Control_Flag (NEW_SNAPSHOT_COMPRESSION);
} else if (snap_flag) {
Error ("A New Snapshot File is required for Output");
}
//---- version 4 time format ----
time_units = Units_Code (Get_Control_Text (VERSION4_TIME_FORMAT));
time_flag = Check_Control_Key (VERSION4_TIME_FORMAT);
if (time_flag) {
int num;
Field_Ptr fld_ptr;
if (System_File_Flag (TRIP)) {
Trip_File *file = (Trip_File *) System_File_Base (TRIP);
if (file->Version () <= 40) {
num = file->Optional_Field (START_FIELD_NAMES);
if (num >= 0) {
fld_ptr = file->Field (num);
fld_ptr->Units (time_units);
}
num = file->Optional_Field (END_FIELD_NAMES);
if (num >= 0) {
fld_ptr = file->Field (num);
fld_ptr->Units (time_units);
}
num = file->Optional_Field (DURATION_FIELD_NAMES);
if (num >= 0) {
fld_ptr = file->Field (num);
fld_ptr->Units (time_units);
}
}
}
if (activity_flag) {
num = activity_file.Optional_Field ("START_MIN", "START", "START_TIME", "STARTTIME");
if (num >= 0) {
fld_ptr = activity_file.Field (num);
fld_ptr->Units (time_units);
}
num = activity_file.Optional_Field ("START_MAX", "START", "START_TIME", "STARTTIME");
if (num >= 0) {
fld_ptr = activity_file.Field (num);
fld_ptr->Units (time_units);
}
num = activity_file.Optional_Field ("END_MIN", "END", "END_TIME", "ENDTIME");
if (num >= 0) {
fld_ptr = activity_file.Field (num);
fld_ptr->Units (time_units);
}
num = activity_file.Optional_Field ("END_MAX", "END", "END_TIME", "ENDTIME");
if (num >= 0) {
fld_ptr = activity_file.Field (num);
fld_ptr->Units (time_units);
}
num = activity_file.Optional_Field ("TIME_MIN", "DURATION");
if (num >= 0) {
fld_ptr = activity_file.Field (num);
fld_ptr->Units (time_units);
}
num = activity_file.Optional_Field ("TIME_MAX", "DURATION");
if (num >= 0) {
fld_ptr = activity_file.Field (num);
fld_ptr->Units (time_units);
}
}
}
//---- plan file ----
if (Check_Control_Key (VERSION4_PLAN_FILE)) {
if (System_File_Flag (PLAN)) {
Error ("A plan file and Version 4 plan file must be processed separateley");
}
if (!System_File_Flag (NEW_PLAN)) {
Error ("A new plan file is required to convert a Version 4 plan file");
}
Print (1);
plan_flag = true;
old_plan.File_Type ("Version4 Plan File");
//---- get the list type ----
key = Get_Control_String (NODE_LIST_PATHS);
if (!key.empty ()) {
type_flag = key.Bool ();
} else {
type_flag = true;
}
old_plan.Node_Based_Flag (type_flag);
//---- get the traveler scale ----
key = Get_Control_String (TRAVELER_SCALING_FACTOR);
if (!key.empty ()) {
scale = key.Integer ();
if (scale < 2 || scale > 100) {
Control_Key_Error (TRAVELER_SCALING_FACTOR, "(2..100)");
}
old_plan.Traveler_Scale (scale);
}
//---- get the file format ----
if (Check_Control_Key (VERSION4_PLAN_FORMAT)) {
old_plan.File_Format (Get_Control_String (VERSION4_PLAN_FORMAT));
}
//---- open the file and print the parameters ----
if (!old_plan.Open (Project_Filename (Get_Control_String (VERSION4_PLAN_FILE)))) {
File_Error ("Opening Version4 Plan File", old_plan.Filename ());
}
Get_Control_Text (VERSION4_PLAN_FORMAT);
type_flag = old_plan.Node_Based_Flag ();
if (type_flag) {
Print (1, "Plan File contains Node List Paths");
if (!System_File_Flag (NODE) || !System_File_Flag (LINK) || !System_File_Flag (PARKING)) {
Error ("A Node, Link and Parking Files are Required for Node-Based Plan Files");
}
AB_Map_Flag (true);
} else {
Print (1, "Plan File contains Link List Paths");
}
Get_Control_Integer (TRAVELER_SCALING_FACTOR);
} else if (snap_flag && snap_file.Version () <= 40) {
//---- get the traveler scale ----
scale= Get_Control_Integer (TRAVELER_SCALING_FACTOR);
if (scale < 2 || scale > 100) {
Control_Key_Error (TRAVELER_SCALING_FACTOR, "(2..100)");
}
}
//---- Version 4 Route Header and Node files ----
if (Check_Control_Key (VERSION4_ROUTE_HEADER)) {
if (!System_File_Flag (NEW_ROUTE_NODES)) {
Error ("A New Route Nodes File is Required");
}
int i, num;
String field;
Field_Ptr fld_ptr;
if (!time_flag) time_units = MINUTES;
Print (1);
route_flag = true;
Route_Nodes_File *file = (Route_Nodes_File *) System_File_Base (NEW_ROUTE_NODES);
key = Get_Control_String (VERSION4_ROUTE_HEADER);
route_header.File_Type ("Version4 Route Header");
route_header.File_ID ("Header");
route_header.Open (Project_Filename (key));
for (i=1; i <= 24; i++) {
field ("HEADWAY_%d") % i;
num = route_header.Optional_Field (field.c_str ());
if (num < 0) break;
fld_ptr = route_header.Field (num);
fld_ptr->Units (time_units);
field ("OFFSET_%d") % i;
num = route_header.Optional_Field (field.c_str ());
if (num >= 0) {
fld_ptr = route_header.Field (num);
fld_ptr->Units (time_units);
}
field ("TTIME_%d") % i;
num = route_header.Optional_Field (field.c_str ());
if (num >= 0) {
fld_ptr = route_header.Field (num);
fld_ptr->Units (time_units);
}
}
route_periods = i - 1;
if (route_periods != file->Num_Periods ()) {
file->Num_Periods (route_periods);
file->Clear_Fields ();
file->Create_Fields ();
file->Write_Header ();
}
key = Get_Control_String (VERSION4_ROUTE_NODES);
if (key.empty ()) {
Error ("A Version4 Route Nodes file is Required");
}
route_nodes.File_Type ("Version4 Route Nodes");
route_nodes.File_ID ("Nodes");
route_nodes.Open (Project_Filename (key));
}
}
