void ArcSnapshot::Program_Control (void)
{
int i;
String key, text;
bool z_flag, m_flag;
string method_text [] = { "AT_INCREMENT", "TOTAL", "MAXIMUM", "" };
Set_Range_String (SUMMARY_TIME_INCREMENT, "0.0..1440.0");
//---- open network files ----
Data_Service::Program_Control ();
Read_Select_Keys ();
max_time = Model_End_Time ();
//---- get the projection data ----
project_flag = projection.Read_Control ();
//---- get the z coordinate flag ----
m_flag = projection.M_Flag ();
z_flag = projection.Z_Flag ();
//---- open the snapshot file ----
Print (2, String ("%s Control Keys:") % Program ());
key = Get_Control_String (SNAPSHOT_FILE);
if (!key.empty ()) {
if (Check_Control_Key (SNAPSHOT_FORMAT)) {
snapshot_file.Dbase_Format (Get_Control_String (SNAPSHOT_FORMAT));
}
snapshot_file.Open (Project_Filename (key));
} else {
key = Get_Control_String (OCCUPANCY_FILE);
if (key.empty ()) {
Error ("A Snapshot or Occupancy file is Required");
}
if (Check_Control_Key (OCCUPANCY_FORMAT)) {
occupancy_file.Dbase_Format (Get_Control_String (OCCUPANCY_FORMAT));
}
occupancy_file.Open (Project_Filename (key));
occupancy_flag = true;
}
//---- get the arcview snapshot file ----
key = Get_Control_String (NEW_ARC_SNAPSHOT_FILE);
if (!key.empty ()) {
if (key.Ends_With (".shp")) {
key.Split_Last (text, ".");
}
shapename = Project_Filename (key);
text = shapename + "_time_of_day.shp";
Print_Filename (2, "New Arc Snapshot File", text);
snapshot_flag = true;
}
//---- new snapshot file ----
key = Get_Control_String (NEW_SNAPSHOT_FILE);
if (!key.empty ()) {
Print (1);
if (Check_Control_Key (NEW_SNAPSHOT_FORMAT)) {
new_snapshot_file.Dbase_Format (Get_Control_String (NEW_SNAPSHOT_FORMAT));
}
new_snapshot_file.Location_Flag (true);
new_snapshot_file.Create (Project_Filename (key));
output_flag = true;
if (project_flag) {
project_coord.Set_Projection (projection.Input_Projection (), projection.Output_Projection ());
}
}
//---- new link summary file ----
key = Get_Control_String (NEW_LINK_SUMMARY_FILE);
if (!key.empty ()) {
if (occupancy_flag) {
Error ("New Link Summary File requires a Snapshot File");
}
Print (1);
summary_file.File_Type ("Link Summary File");
if (Check_Control_Key (NEW_LINK_SUMMARY_FORMAT)) {
summary_file.Dbase_Format (Get_Control_String (NEW_LINK_SUMMARY_FORMAT));
}
sum_flag = true;
summary_file.Create (Project_Filename (key));
}
if (!snapshot_flag && !output_flag && !sum_flag) {
Error ("An Arcview Snapshot, New Snapshot, or New Link Summary File is Required");
}
//---- cell size ----
cell_size = Get_Control_Double (CELL_SIZE);
//---- lane width ----
Read_Draw_Keys ();
//---- draw vehicle shapes ----
if (snapshot_flag && !shape_flag) {
circle_flag = Get_Control_Flag (ADD_PASSENGER_CIRCLE_SIZE);
square_flag = Get_Control_Flag (ADD_PASSENGER_SQUARE_SIZE);
}
//---- pad file time labels ----
pad_flag = Get_Control_Flag (PAD_FILE_TIME_LABEL);
//---- get the time processing method ----
key = Get_Control_Text (TIME_PROCESSING_METHOD);
if (!key.empty ()) {
for (i=0; (int) method_text [i].size () > 0; i++) {
if (key.Equals (method_text [i])) {
method = i;
break;
}
}
if ((int) method_text [i].size () == 0) {
Error (String ("Unrecognized Time Processing Method = %s") % key);
}
if (!occupancy_flag && method == TOTAL) {
Error ("Snapshot Files cannot be Totaled");
}
}
//---- initialize the shape file ----
arcview_snapshot.File_Type ("New Arc Snapshot File");
arcview_snapshot.File_Access (CREATE);
arcview_snapshot.Shape_Type ((shape_flag) ? POLYGON : DOT);
arcview_snapshot.Z_Flag (z_flag);
arcview_snapshot.M_Flag (m_flag);
if (occupancy_flag) {
arcview_snapshot.Replicate_Fields (&occupancy_file);
arcview_snapshot.LinkDir_Type ((Direction_Type) occupancy_file.LinkDir_Type ());
link_field = occupancy_file.Link_Field ();
dir_field = occupancy_file.Dir_Field ();
start_field = occupancy_file.Start_Field ();
end_field = occupancy_file.End_Field ();
lane_field = occupancy_file.Lane_Field ();
offset_field = occupancy_file.Offset_Field ();
occ_field = occupancy_file.Occupancy_Field ();
type_field = -1;
} else {
Snapshot_File *file = &snapshot_file;
if (file->Compress_Flag ()) {
dummy_snapshot.Status_Flag ();
dummy_snapshot.Create_Fields ();
file = &dummy_snapshot;
}
arcview_snapshot.Replicate_Fields (file);
arcview_snapshot.LinkDir_Type ((Direction_Type) file->LinkDir_Type ());
link_field = file->Link_Field ();
dir_field = file->Dir_Field ();
lane_field = file->Lane_Field ();
offset_field = file->Offset_Field ();
type_field = file->Type_Field ();
cell_field = file->Cell_Field ();
occ_field = start_field = end_field = -1;
if (circle_flag) {
arcview_snapshot.Add_Field ("RADIUS", DB_DOUBLE, 14.2);
circle_field = arcview_snapshot.Field_Number ("RADIUS");
}
if (square_flag) {
arcview_snapshot.Add_Field ("SQUARE", DB_DOUBLE, 14.2);
square_field = arcview_snapshot.Field_Number ("SQUARE");
}
}
arcview_snapshot.Set_Projection (projection.Input_Projection (), projection.Output_Projection ());
}
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 ZoneData::Program_Control (void)
{
int i, j, num, field;
double size;
bool flag;
String key, name, buf;
Field_Type type;
Data_Group data_rec;
Data_Itr data_itr;
Polygon_Group poly_rec;
Polygon_Itr poly_itr;
Sum_Distance sum_rec;
Sum_Itr sum_itr;
Field_Ptr fld_ptr;
field = 0;
//---- open network files ----
Data_Service::Program_Control ();
input_file = (Zone_File *) System_File_Handle (ZONE);
output_file = (Zone_File *) System_File_Handle (NEW_ZONE);
flag = exe->Notes_Name_Flag ();
exe->Notes_Name_Flag (false);
output_file->Clear_Fields ();
Print (2, String ("%s Control Keys:") % Program ());
//---- copy existing fields ----
copy_flag = Get_Control_Flag (COPY_EXISTING_FIELDS);
if (copy_flag) {
output_file->Replicate_Fields (input_file, false);
} else if (Get_Control_Flag (CLEAR_ALL_FIELDS)) {
output_file->Clear_Fields ();
} else {
output_file->Create_Fields ();
}
exe->Notes_Name_Flag (flag);
if (Check_Control_Key (ZONE_FILE_HEADER)) {
if (Get_Control_Flag (ZONE_FILE_HEADER)) {
output_file->Header_Lines (1);
} else {
output_file->Header_Lines (0);
}
}
//---- get the new zone fields ----
num = Highest_Control_Group (NEW_ZONE_FIELD, 0);
if (num == 0) {
if (!copy_flag) {
Warning ("No New Zone Fields");
}
} else {
Print (1);
for (i=1; i <= num; i++) {
key = Get_Control_Text (NEW_ZONE_FIELD, i);
if (key.empty ()) continue;
key.Split (name, ",");
if (name.empty ()) goto data_error;
field = output_file->Field_Number (name);
if (field >= 0) goto field_error;
key.Split (buf, ",");
if (buf.empty () || buf.Starts_With ("I")) {
type = DB_INTEGER;
} else if (buf.Starts_With ("D") || buf.Starts_With ("R")) {
type = DB_DOUBLE;
} else if (buf.Starts_With ("S") || buf.Starts_With ("C")) {
type = DB_STRING;
} else {
goto data_error;
}
key.Split (buf, ",");
if (buf.empty ()) {
if (type == DB_DOUBLE) {
size = 10.2;
} else {
size = 10.0;
}
} else {
size = buf.Double ();
}
output_file->Add_Field (name, type, size);
}
}
if (exe->Notes_Name_Flag ()) {
if (output_file->Field_Number ("NOTES") < 0) {
output_file->Add_Field ("NOTES", DB_STRING, STRING_FIELD_SIZE);
}
}
output_file->Write_Header ();
//---- check for data files ----
num_data_files = Highest_Control_Group (DATA_FILE, 0);
if (num_data_files > 0) {
data_flag = true;
}
//---- check for polygon files ----
num_polygons = Highest_Control_Group (BOUNDARY_POLYGON_FILE, 0);
if (num_polygons > 0) {
polygon_flag = true;
}
//---- check for sum distances ----
num_sum_distance = Highest_Control_Group (SUM_ATTRIBUTE_DISTANCE, 0);
if (num_sum_distance > 0) {
sum_flag = true;
}
//---- read conversion script ----
key = Get_Control_String (CONVERSION_SCRIPT);
if (key.empty ()) {
if (data_flag || sum_flag || polygon_flag) {
Error ("A Convertion Script is needed for Data Processing");
}
} else {
script_flag = true;
Print (1);
program_file.File_Type ("Conversion Script");
program_file.Open (Project_Filename (key));
Print (1);
}
//---- read data files ----
if (data_flag) {
//---- open each file ----
for (i=1; i <= num_data_files; i++) {
key = Get_Control_String (DATA_FILE, i);
if (key.empty ()) continue;
//---- create a header file and file labels ----
Print (1);
data_group.push_back (data_rec);
data_itr = --data_group.end ();
data_itr->group = i;
data_itr->file = new Db_Header ();
data_itr->data_db = new Db_Sort_Array ();
data_itr->file->File_Type (String ("Data File #%d") % i);
data_itr->file->File_ID (String ("Data%d") % i);
if (Check_Control_Key (DATA_FORMAT, i)) {
data_itr->file->Dbase_Format (Get_Control_String (DATA_FORMAT, i));
}
data_itr->file->Open (Project_Filename (key));
//---- find the data join field ----
key = Get_Control_Text (DATA_JOIN_FIELD, i);
if (key.empty ()) goto control_error;
field = data_itr->file->Field_Number (key);
if (field < 0) {
Error (String ("Data Join Field %s was Not Found") % key);
}
data_itr->join_field = field;
Print (0, ", Number = ") << (field + 1);
//---- find the zone join field ----
key = Get_Control_Text (ZONE_JOIN_FIELD, i);
if (key.empty ()) goto control_error;
field = input_file->Field_Number (key);
if (field < 0) {
Error (String ("Zone Join Field %s was Not Found") % key);
}
data_itr->zone_field = field;
Print (0, ", Number = ") << (field + 1);
}
}
//---- read the projection information ----
if (polygon_flag) {
projection.Read_Control ();
}
//---- read the boundary polygons ----
if (polygon_flag) {
if (!script_flag) {
Error ("Boundary Polygon processing Requires a Conversion Script");
}
//---- open each file ----
for (i=1; i <= num_polygons; i++) {
key = Get_Control_String (BOUNDARY_POLYGON_FILE, i);
if (key.empty ()) continue;
polygons.push_back (poly_rec);
poly_itr = --polygons.end ();
poly_itr->group = i;
poly_itr->file = new Arcview_File ();
poly_itr->data_db = new Db_Sort_Array ();
poly_itr->file->Set_Projection (projection.Input_Projection (), projection.Output_Projection ());
Print (1);
poly_itr->file->File_Type (String ("Boundary Polygon File #%d") % i);
poly_itr->file->File_ID (String ("Polygon%d") % i);
poly_itr->file->Open (Project_Filename (key));
}
}
//---- read sum distances ----
if (sum_flag) {
//---- open each group ----
num = input_file->Num_Fields ();
for (i=1; i <= num_sum_distance; i++) {
if (!Check_Control_Key (SUM_ATTRIBUTE_DISTANCE, i)) continue;
//---- create a header file and file labels ----
Print (1);
sum_group.push_back (sum_rec);
sum_itr = --sum_group.end ();
sum_itr->group = i;
sum_itr->distance = Round (Get_Control_Double (SUM_ATTRIBUTE_DISTANCE, i));
sum_itr->data_db = new Db_Sort_Array ();
field = input_file->Zone_Field ();
fld_ptr = input_file->Field (field);
sum_itr->data_db->File_Type (String ("Sum Attribute Distance #%d") % i);
sum_itr->data_db->File_ID (String ("SumZone%d") % i);
sum_itr->data_db->Add_Field (fld_ptr->Name (), DB_INTEGER, 10);
sum_itr->data_db->Add_Field ("Z_COUNT", DB_INTEGER, 10);
sum_itr->field_map.push_back (field);
sum_itr->field_map.push_back (-1);
for (j=0; j < num; j++) {
if (j == field) continue;
fld_ptr = input_file->Field (j);
if (fld_ptr->Type () == DB_INTEGER || fld_ptr->Type () == DB_DOUBLE) {
sum_itr->field_map.push_back (j);
sum_itr->data_db->Add_Field (fld_ptr->Name (), DB_DOUBLE, sizeof (double), NO_UNITS, true);
}
}
}
}
Show_Message (1);
return;
control_error:
Error (String ("Missing Control Key = %s") % Current_Key ());
data_error:
Error (String ("New Zone Field %d is Improperly Specified") % i);
field_error:
Error (String ("New Zone Field %s already exists as Field %d") % name % field);
}
void LineSum::Program_Control (void)
{
int i, num_files, anode, bnode;
bool arcview_flag, z_flag, m_flag;
String key, format;
Strings ab_strings, node_pairs;
Str_Itr str_itr, ab_itr;
Db_Header *fh = 0;
File_Itr file_itr;
Line_Report_Data line_report_data;
Link_Report_Data link_report_data;
On_Off_Report_Data on_off_report_data;
Access_Report_Data access_report_data;
Stop_Report_Data stop_report_data;
Total_Report_Data total_report_data;
Link_Rider_Data link_rider_data;
Dtime hour;
//---- process the global control keys ----
Execution_Service::Program_Control ();
Metric_Flag (false);
hour.Hours (1.0);
//---- get the projection data ----
projection.Read_Control ();
//---- get the z coordinate flag ----
m_flag = projection.M_Flag ();
z_flag = projection.Z_Flag ();
Print (2, String ("%s Control Keys:") % Program ());
//---- initialize the peak file list ----
num_files = Highest_Control_Group (PEAK_RIDERSHIP_FILE, 0);
if (num_files > 0) {
peak_list.Initialize (num_files);
Print (1);
//---- open each file ----
for (i=1; i <= num_files; i++) {
//---- open the peak ridership file ----
key = Get_Control_String (PEAK_RIDERSHIP_FILE, i);
if (key.empty ()) continue;
fh = peak_list [i-1];
fh->File_Type (String ("Peak Ridership File #%d") % i);
fh->File_ID (String ("Peak%d") % i);
//---- get the file format ----
if (Check_Control_Key (PEAK_RIDERSHIP_FORMAT, i)) {
fh->Dbase_Format (Get_Control_String (PEAK_RIDERSHIP_FORMAT, i));
}
fh->Open (Project_Filename (key));
}
}
//---- initialize the offpeak file list ----
num_files = Highest_Control_Group (OFFPEAK_RIDERSHIP_FILE, 0);
if (num_files > 0) {
offpeak_list.Initialize (num_files);
Print (1);
//---- open each file ----
for (i=1; i <= num_files; i++) {
//---- open the offpeak ridership file ----
key = Get_Control_String (OFFPEAK_RIDERSHIP_FILE, i);
if (key.empty ()) continue;
fh = offpeak_list [i-1];
fh->File_Type (String ("Offpeak Ridership File #%d") % i);
fh->File_ID (String ("Offpeak%d") % i);
//---- get the file format ----
if (Check_Control_Key (OFFPEAK_RIDERSHIP_FORMAT, i)) {
fh->Dbase_Format (Get_Control_String (OFFPEAK_RIDERSHIP_FORMAT, i));
}
fh->Open (Project_Filename (key));
}
}
if (peak_list.size () == 0 && offpeak_list.size () == 0) {
// Error ("No Peak or Offpeak Ridership File Keys were Found");
}
//---- open the new peak ridership file ----
key = Get_Control_String (NEW_PEAK_RIDERSHIP_FILE);
if (!key.empty ()) {
Print (1);
if (peak_list.size () == 0) {
Error ("Input Peak Ridership Files are Required");
}
fh = 0;
for (file_itr = peak_list.begin (); file_itr != peak_list.end (); file_itr++) {
if ((*file_itr)->Is_Open ()) {
fh = *file_itr;
break;
}
}
if (fh == 0) Error ("Peak Input files are Not Open");
new_peak_file.File_Type ("New Peak Ridership File");
new_peak_file.File_ID ("NewPeak");
//---- get the file format ----
if (Check_Control_Key (NEW_PEAK_RIDERSHIP_FORMAT)) {
new_peak_file.Dbase_Format (Get_Control_String (NEW_PEAK_RIDERSHIP_FORMAT));
}
new_peak_file.Header_Lines (fh->Header_Lines ());
new_peak_file.Replicate_Fields (fh);
new_peak_file.Create (Project_Filename (key));
}
//---- open the new offpeak ridership file ----
key = Get_Control_String (NEW_OFFPEAK_RIDERSHIP_FILE);
if (!key.empty ()) {
Print (1);
if (offpeak_list.size () == 0) {
Error ("Input Offpeak Ridership Files are Required");
}
fh = 0;
for (file_itr = offpeak_list.begin (); file_itr != offpeak_list.end (); file_itr++) {
if ((*file_itr)->Is_Open ()) {
fh = *file_itr;
break;
}
}
if (fh == 0) Error ("Offpeak Input files are Not Open");
new_offpeak_file.File_Type ("New Offpeak Ridership File");
new_offpeak_file.File_ID ("NewOffpeak");
//---- get the file format ----
if (Check_Control_Key (NEW_OFFPEAK_RIDERSHIP_FORMAT)) {
new_offpeak_file.Dbase_Format (Get_Control_String (NEW_OFFPEAK_RIDERSHIP_FORMAT));
}
new_offpeak_file.Header_Lines (fh->Header_Lines ());
new_offpeak_file.Replicate_Fields (fh);
new_offpeak_file.Create (Project_Filename (key));
}
//---- open the new total ridership file ----
key = Get_Control_String (NEW_TOTAL_RIDERSHIP_FILE);
if (!key.empty ()) {
Print (1);
if (peak_list.size () == 0 || offpeak_list.size () == 0) {
Error ("Input Peak and Offpeak Ridership Files are Required");
}
fh = 0;
for (file_itr = peak_list.begin (); file_itr != peak_list.end (); file_itr++) {
if ((*file_itr)->Is_Open ()) {
fh = *file_itr;
break;
}
}
if (fh == 0) Error ("Peak Input files are Not Open");
new_total_file.File_Type ("New Total Ridership File");
new_total_file.File_ID ("NewTotal");
//---- get the file format ----
if (Check_Control_Key (NEW_TOTAL_RIDERSHIP_FORMAT)) {
new_total_file.Dbase_Format (Get_Control_String (NEW_TOTAL_RIDERSHIP_FORMAT));
}
new_total_file.Header_Lines (fh->Header_Lines ());
new_total_file.Replicate_Fields (fh);
new_total_file.Create (Project_Filename (key));
}
//---- open the stop name file ----
key = Get_Control_String (STOP_NAME_FILE);
if (!key.empty ()) {
Print (1);
stop_name_file.File_Type ("Stop Name File");
stop_name_file.File_ID ("StopName");
station_flag = true;
//---- get the file format ----
if (Check_Control_Key (STOP_NAME_FORMAT)) {
stop_name_file.Dbase_Format (Get_Control_String (STOP_NAME_FORMAT));
}
stop_name_file.Open (Project_Filename (key));
}
//---- line report data ----
num_files = Highest_Control_Group (LINE_REPORT_LINES);
if (num_files > 0) {
//---- read the line report keys ----
for (i=1; i <= num_files; i++) {
if (!Check_Control_Key (LINE_REPORT_LINES, i)) continue;
Print (1);
//---- report number and title ----
line_report_data.number = i;
line_report_data.title = Get_Control_Text (LINE_REPORT_TITLE, i);
//---- line range ----
key = Get_Control_Text (LINE_REPORT_LINES, i);
if (key.empty ()) continue;
key.Parse (line_report_data.lines);
//---- selected modes ----
key = Get_Control_Text (LINE_REPORT_MODES, i);
line_report_data.modes.clear ();
if (!key.empty () && !key.Equals ("ALL")) {
line_report_data.all_modes = false;
if (!line_report_data.modes.Add_Ranges (key)) {
exe->Error ("Adding Modes Ranges");
}
} else {
line_report_data.all_modes = true;
}
//---- report all nodes ----
line_report_data.node_flag = Get_Control_Flag (LINE_REPORT_ALL_NODES, i);
//---- store the control data ----
line_report_array.push_back (line_report_data);
}
}
//---- link report data ----
num_files = Highest_Control_Group (LINK_REPORT_LINKS);
if (num_files > 0) {
//---- read the link report keys ----
for (i=1; i <= num_files; i++) {
if (!Check_Control_Key (LINK_REPORT_LINKS, i)) continue;
Print (1);
//---- report number and title ----
link_report_data.number = i;
link_report_data.title = Get_Control_Text (LINK_REPORT_TITLE, i);
//---- anode-bnode pairs ----
key = Get_Control_Text (LINK_REPORT_LINKS, i);
if (key.empty ()) continue;
link_report_data.links = key;
key.Parse (node_pairs);
link_report_data.nodes.clear ();
for (str_itr = node_pairs.begin (); str_itr != node_pairs.end (); str_itr++) {
str_itr->Parse (ab_strings, "-");
for (anode=0, ab_itr = ab_strings.begin (); ab_itr != ab_strings.end (); ab_itr++, anode = bnode) {
bnode = ab_itr->Integer ();
if (anode > 0) {
link_report_data.nodes.push_back (anode);
link_report_data.nodes.push_back (bnode);
}
}
}
//---- selected modes ----
key = Get_Control_Text (LINK_REPORT_MODES, i);
link_report_data.modes.clear ();
if (!key.empty () && !key.Equals ("ALL")) {
link_report_data.all_modes = false;
if (!link_report_data.modes.Add_Ranges (key)) {
exe->Error ("Adding Modes Ranges");
}
} else {
link_report_data.all_modes = true;
}
//---- selected lines ----
key = Get_Control_Text (LINK_REPORT_LINES, i);
link_report_data.lines.clear ();
if (!key.empty () && !key.Equals ("ALL")) {
link_report_data.all_lines = false;
key.Parse (link_report_data.lines);
} else {
link_report_data.all_lines = true;
}
//---- oneway/twoway flag ----
link_report_data.dir_flag = Get_Control_Flag (LINK_REPORT_ONEWAY, i);
//---- store the control data ----
link_report_array.push_back (link_report_data);
}
}
//---- on-off report data ----
num_files = Highest_Control_Group (ON_OFF_REPORT_STOPS);
if (num_files > 0) {
on_off_flag = true;
//---- read the boarding report keys ----
for (i=1; i <= num_files; i++) {
if (!Check_Control_Key (ON_OFF_REPORT_STOPS, i)) continue;
Print (1);
//---- report number and title ----
on_off_report_data.number = i;
on_off_report_data.title = Get_Control_Text (ON_OFF_REPORT_TITLE, i);
//---- stop range ----
key = Get_Control_Text (ON_OFF_REPORT_STOPS, i);
if (key.empty ()) continue;
on_off_report_data.stops.clear ();
if (!key.empty () && !key.Equals ("ALL")) {
on_off_report_data.all_stops = false;
if (!on_off_report_data.stops.Add_Ranges (key)) {
exe->Error ("Adding Stop Ranges");
}
} else {
on_off_report_data.all_stops = true;
}
//---- select modes ----
key = Get_Control_Text (ON_OFF_REPORT_MODES, i);
on_off_report_data.modes.clear ();
if (!key.empty () && !key.Equals ("ALL")) {
on_off_report_data.all_modes = false;
if (!on_off_report_data.modes.Add_Ranges (key)) {
exe->Error ("Adding Modes Ranges");
}
} else {
on_off_report_data.all_modes = true;
}
//---- level of detail ----
key = Get_Control_Text (ON_OFF_REPORT_DETAILS, i);
if (!key.empty ()) {
char ch = key [0];
if (ch >= 'a' && ch <= 'z') ch = ch - 'a' + 'A';
if (ch == 'T' || ch == 'Y' || ch == '1') {
on_off_report_data.details = 1;
} else if (ch == 'M' || ch == '2') {
on_off_report_data.details = 2;
} else {
on_off_report_data.details = 0;
}
} else {
on_off_report_data.details = 0;
}
//---- output data file ----
key = Get_Control_String (NEW_ON_OFF_REPORT_FILE, i);
if (!key.empty ()) {
if (Check_Control_Key (NEW_ON_OFF_REPORT_FORMAT, i)) {
format = Get_Control_String (NEW_ON_OFF_REPORT_FORMAT, i);
on_off_report_data.arcview_flag = format.Equals ("ARCVIEW");
} else {
on_off_report_data.arcview_flag = false;
}
Print (1);
if (on_off_report_data.arcview_flag) {
on_off_report_data.file = on_off_report_data.arc_file = new Arcview_File ();
on_off_report_data.arc_file->File_Type (String ("New On-Off Report File #%d") % i);
on_off_report_data.arc_file->Shape_Type (DOT);
on_off_report_data.arc_file->Z_Flag (z_flag);
on_off_report_data.arc_file->M_Flag (m_flag);
on_off_report_data.arc_file->Create (Project_Filename (key));
on_off_report_data.arc_file->Set_Projection (projection.Input_Projection (), projection.Output_Projection ());
xy_flag = true;
} else {
on_off_report_data.file = new Db_Header ();
if (Check_Control_Key (NEW_ON_OFF_REPORT_FORMAT, i)) {
on_off_report_data.file->Dbase_Format (format);
}
on_off_report_data.file->File_Type (String ("New On-Off Report File #%d") % i);
on_off_report_data.file->Create (Project_Filename (key));
}
} else {
on_off_report_data.file = 0;
}
//---- store the control data ----
on_off_report_array.push_back (on_off_report_data);
}
}
//---- access report data ----
num_files = Highest_Control_Group (ACCESS_REPORT_STOPS);
if (num_files > 0) {
access_flag = true;
//---- read the access report keys ----
for (i=1; i <= num_files; i++) {
if (!Check_Control_Key (ACCESS_REPORT_STOPS, i)) continue;
Print (1);
//---- report number and title ----
access_report_data.number = i;
access_report_data.title = Get_Control_Text (ACCESS_REPORT_TITLE, i);
//---- stop range ----
key = Get_Control_Text (ACCESS_REPORT_STOPS, i);
if (key.empty ()) continue;
access_report_data.stops.clear ();
if (!key.empty () && !key.Equals ("ALL")) {
access_report_data.all_stops = false;
if (!access_report_data.stops.Add_Ranges (key)) {
exe->Error ("Adding Stop Ranges");
}
} else {
access_report_data.all_stops = true;
}
//---- select modes ----
key = Get_Control_Text (ACCESS_REPORT_MODES, i);
access_report_data.modes.clear ();
if (!key.empty () && !key.Equals ("ALL")) {
access_report_data.all_modes = false;
if (!access_report_data.modes.Add_Ranges (key)) {
exe->Error ("Adding Modes Ranges");
}
} else {
access_report_data.all_modes = true;
}
//---- level of detail ----
key = Get_Control_Text (ACCESS_REPORT_DETAILS, i);
if (!key.empty ()) {
char ch = key [0];
if (ch >= 'a' && ch <= 'z') ch = ch - 'a' + 'A';
if (ch == 'T' || ch == 'Y' || ch == '1') {
access_report_data.details = 1;
} else if (ch == 'M' || ch == '2') {
access_report_data.details = 2;
} else {
access_report_data.details = 0;
}
} else {
access_report_data.details = 0;
}
//---- output data file ----
key = Get_Control_String (NEW_ACCESS_REPORT_FILE, i);
if (!key.empty ()) {
access_report_data.file = new Db_Header ();
access_report_data.file->File_Type (String ("New Access Report File #%d") % i);
if (Check_Control_Key (NEW_ACCESS_REPORT_FORMAT, i)) {
access_report_data.file->Dbase_Format (Get_Control_String (NEW_ACCESS_REPORT_FORMAT, i));
}
access_report_data.file->Create (Project_Filename (key));
if (Check_Control_Key (NEW_ACCESS_REPORT_FORMAT, i)) {
format = Get_Control_String (NEW_ACCESS_REPORT_FORMAT, i);
access_report_data.arcview_flag = format.Equals ("ARCVIEW");
} else {
access_report_data.arcview_flag = false;
}
Print (1);
if (access_report_data.arcview_flag) {
access_report_data.file = access_report_data.arc_file = new Arcview_File ();
access_report_data.arc_file->File_Type (String ("New Access Report File #%d") % i);
access_report_data.arc_file->Shape_Type (DOT);
access_report_data.arc_file->Z_Flag (z_flag);
access_report_data.arc_file->M_Flag (m_flag);
access_report_data.arc_file->Create (Project_Filename (key));
access_report_data.arc_file->Set_Projection (projection.Input_Projection (), projection.Output_Projection ());
xy_flag = true;
} else {
access_report_data.file = new Db_Header ();
if (Check_Control_Key (NEW_ACCESS_REPORT_FORMAT, i)) {
access_report_data.file->Dbase_Format (format);
}
access_report_data.file->File_Type (String ("New Access Report File #%d") % i);
access_report_data.file->Create (Project_Filename (key));
}
} else {
access_report_data.file = 0;
}
//---- store the control data ----
access_report_array.push_back (access_report_data);
}
}
//---- stop report data ----
num_files = Highest_Control_Group (STOP_REPORT_STOPS);
if (num_files > 0) {
access_flag = true;
//---- read the stop report keys ----
for (i=1; i <= num_files; i++) {
if (!Check_Control_Key (STOP_REPORT_STOPS, i)) continue;
Print (1);
//---- report number and title ----
stop_report_data.number = i;
stop_report_data.title = Get_Control_Text (STOP_REPORT_TITLE, i);
//---- stop range ----
key = Get_Control_Text (STOP_REPORT_STOPS, i);
if (key.empty ()) continue;
stop_report_data.stops.clear ();
if (!stop_report_data.stops.Add_Ranges (key)) {
exe->Error ("Adding Stop Ranges");
}
//---- select modes ----
key = Get_Control_Text (STOP_REPORT_MODES, i);
stop_report_data.modes.clear ();
if (!key.empty () && !key.Equals ("ALL")) {
stop_report_data.all_modes = false;
if (!stop_report_data.modes.Add_Ranges (key)) {
exe->Error ("Adding Modes Ranges");
}
} else {
stop_report_data.all_modes = true;
}
//---- line range ----
key = Get_Control_Text (STOP_REPORT_LINES, i);
stop_report_data.lines.clear ();
if (!key.empty () && !key.Equals ("ALL")) {
stop_report_data.all_lines = false;
key.Parse (stop_report_data.lines);
} else {
stop_report_data.all_lines = true;
}
//---- transfer modes ----
key = Get_Control_Text (STOP_REPORT_TRANSFERS, i);
stop_report_data.transfers.clear ();
if (!key.empty () && !key.Equals ("NONE")) {
if (!stop_report_data.transfers.Add_Ranges (key)) {
exe->Error ("Adding Transfer Mode Ranges");
}
}
//---- store the control data ----
stop_report_array.push_back (stop_report_data);
}
}
//---- total report data ----
num_files = Highest_Control_Group (TOTAL_REPORT_LINES);
if (num_files > 0) {
//---- read the total report keys ----
for (i=1; i <= num_files; i++) {
if (!Check_Control_Key (TOTAL_REPORT_LINES, i)) continue;
Print (1);
//---- report number and title ----
total_report_data.number = i;
total_report_data.title = Get_Control_Text (TOTAL_REPORT_TITLE, i);
//---- line range ----
key = Get_Control_Text (TOTAL_REPORT_LINES, i);
if (key.empty ()) continue;
key.Parse (total_report_data.lines);
//---- selected modes ----
key = Get_Control_Text (TOTAL_REPORT_MODES, i);
total_report_data.modes.clear ();
if (!key.empty () && !key.Equals ("ALL")) {
total_report_data.all_modes = false;
if (!total_report_data.modes.Add_Ranges (key)) {
exe->Error ("Adding Modes Ranges");
}
} else {
total_report_data.all_modes = true;
}
//---- output data file ----
key = Get_Control_String (NEW_TOTAL_REPORT_FILE, i);
if (!key.empty ()) {
total_report_data.file = new Db_Header ();
total_report_data.file->File_Type (String ("New Total Report File #%d") % i);
if (Check_Control_Key (NEW_TOTAL_REPORT_FORMAT, i)) {
total_report_data.file->Dbase_Format (Get_Control_String (NEW_TOTAL_REPORT_FORMAT, i));
}
total_report_data.file->Create (Project_Filename (key));
//---- peak hours ----
total_report_data.peak_hours = (double) Get_Control_Time (TOTAL_REPORT_PEAK_HOURS, i) / hour;
//---- offpeak hours ----
total_report_data.offpeak_hours = (double) Get_Control_Time (TOTAL_REPORT_OFFPEAK_HOURS, i) / hour;
} else {
total_report_data.file = 0;
}
//---- store the control data ----
total_report_array.push_back (total_report_data);
}
}
//---- open the node XY file ----
if (xy_flag) {
key = Get_Control_String (NODE_XY_FILE);
if (key.empty ()) {
Error ("Node XY File is Required for Stop Shapefiles");
}
if (Check_Control_Key (NODE_XY_FORMAT)) {
node_xy_file.Dbase_Format (Get_Control_String (NODE_XY_FORMAT));
}
node_xy_file.File_Type ("Node XY File");
Print (1);
node_xy_file.Open (Project_Filename (key));
}
//---- link rider file data ----
num_files = Highest_Control_Group (NEW_LINK_RIDER_FILE);
if (num_files > 0) {
arcview_flag = false;
//---- read the link rider keys ----
for (i=1; i <= num_files; i++) {
//---- output data file ---
key = Get_Control_String (NEW_LINK_RIDER_FILE, i);
if (key.empty ()) continue;
link_rider_data.number = i;
if (Check_Control_Key (NEW_LINK_RIDER_FORMAT, i)) {
format = Get_Control_String (NEW_LINK_RIDER_FORMAT, i);
link_rider_data.arcview_flag = format.Equals ("ARCVIEW");
} else {
link_rider_data.arcview_flag = false;
}
Print (1);
if (link_rider_data.arcview_flag) {
link_rider_data.file = link_rider_data.arc_file = new Arcview_File ();
link_rider_data.arc_file->File_Type (String ("New Link Rider File #%d") % i);
link_rider_data.arc_file->Shape_Type (VECTOR);
link_rider_data.arc_file->Z_Flag (z_flag);
link_rider_data.arc_file->M_Flag (m_flag);
link_rider_data.arc_file->Create (Project_Filename (key));
link_rider_data.arc_file->Set_Projection (projection.Input_Projection (), projection.Output_Projection ());
arcview_flag = true;
} else {
link_rider_data.file = new Db_Header ();
if (Check_Control_Key (NEW_LINK_RIDER_FORMAT, i)) {
link_rider_data.file->Dbase_Format (format);
}
link_rider_data.file->File_Type (String ("New Link Rider File #%d") % i);
link_rider_data.file->Create (Project_Filename (key));
}
//---- selected modes ----
key = Get_Control_Text (LINK_RIDER_MODES, i);
link_rider_data.modes.clear ();
if (!key.empty () && !key.Equals ("ALL")) {
link_rider_data.all_modes = false;
if (!link_rider_data.modes.Add_Ranges (key)) {
exe->Error ("Adding Modes Ranges");
}
} else {
link_rider_data.all_modes = true;
}
//---- selected lines ----
key = Get_Control_Text (LINK_RIDER_LINES, i);
link_rider_data.lines.clear ();
link_rider_data.all_lines = false;
link_rider_data.each_line = false;
if (key.empty ()) {
link_rider_data.all_lines = true;
} else if (key.Equals ("ALL")) {
link_rider_data.all_lines = true;
} else if (key.Equals ("EACH")) {
link_rider_data.each_line = true;
} else {
key.Parse (link_rider_data.lines);
}
//---- peak hours ----
link_rider_data.peak_hours = (double) Get_Control_Time (LINK_RIDER_PEAK_HOURS, i) / hour;
//---- peak factor ----
link_rider_data.peak_fac = Get_Control_Double (LINK_RIDER_PEAK_FACTOR, i);
//---- peak capacity ----
link_rider_data.peak_cap = Get_Control_Double (LINK_RIDER_PEAK_CAPACITY, i);
//---- offpeak hours ----
link_rider_data.offpeak = (double) Get_Control_Time (LINK_RIDER_OFFPEAK_HOURS, i) / hour;
//---- open node file for arcview output ----
if (link_rider_data.arcview_flag) {
key = Get_Control_String (LINK_RIDER_XY_FILE, i);
if (key.empty ()) {
Error ("A Link Rider XY File is required for Arcview Output");
}
link_rider_data.xy_file = new Db_Header ();
link_rider_data.xy_file->File_Type (String ("Link Rider XY File #%d") % i);
if (Check_Control_Key (LINK_RIDER_XY_FORMAT, i)) {
link_rider_data.xy_file->Dbase_Format (Get_Control_String (LINK_RIDER_XY_FORMAT, i));
}
link_rider_data.xy_file->Open (Project_Filename (key));
link_rider_data.node_fld = link_rider_data.xy_file->Required_Field (NODE_FIELD_NAMES);
link_rider_data.xcoord_fld = link_rider_data.xy_file->Required_Field (X_FIELD_NAMES);
link_rider_data.ycoord_fld = link_rider_data.xy_file->Required_Field (Y_FIELD_NAMES);
link_rider_data.offset = Get_Control_Double (LINK_RIDER_SIDE_OFFSET, i);
} else {
link_rider_data.offset = 0.0;
}
//---- store the control data ----
link_rider_array.push_back (link_rider_data);
}
//---- open the link shape file ----
if (arcview_flag) {
key = Get_Control_String (LINK_SHAPE_FILE);
if (!key.empty ()) {
Print (1);
shape_flag = true;
link_shape.File_Type ("Link Shape File");
link_shape.Set_Projection (projection.Input_Projection (), projection.Output_Projection ());
link_shape.Open (Project_Filename (key));
//---- get the field numbers ----
key = Get_Control_Text (LINK_SHAPE_ANODE);
anode_field = link_shape.Required_Field (key);
Print (0, ", Number=") << anode_field;
key = Get_Control_Text (LINK_SHAPE_BNODE);
bnode_field = link_shape.Required_Field (key);
Print (0, ", Number=") << bnode_field;
}
}
//---- process service level files ----
key = Get_Control_String (SERVICE_FILE);
if (!key.empty ()) {
Print (1);
service_file.File_Type ("Service File");
service_flag = true;
//---- get the file format ----
if (Check_Control_Key (SERVICE_FORMAT)) {
service_file.Dbase_Format (Get_Control_String (SERVICE_FORMAT));
}
service_file.Open (Project_Filename (key));
//---- get the field numbers ----
key = Get_Control_Text (SERVICE_LINE_FIELD);
line_fld = service_file.Required_Field (key);
Print (0, ", Number=") << line_fld;
if (Check_Control_Key (SERVICE_PEAK_FIELD)) {
key = Get_Control_Text (SERVICE_PEAK_FIELD);
peak_fld = service_file.Required_Field (key);
Print (0, ", Number=") << peak_fld;
}
if (Check_Control_Key (SERVICE_OFFPEAK_FIELD)) {
key = Get_Control_Text (SERVICE_OFFPEAK_FIELD);
offpeak_fld = service_file.Required_Field (key);
Print (0, ", Number=") << offpeak_fld;
}
}
}
//---- initialize the base routes ----
num_files = Highest_Control_Group (BASE_ROUTE_FILE, 0);
if (num_files > 0) {
base_routes.Initialize (num_files);
Print (1);
//---- open each file ----
for (i=1; i <= num_files; i++) {
//---- open the base ridership file ----
key = Get_Control_String (BASE_ROUTE_FILE, i);
if (key.empty ()) continue;
fh = base_routes [i-1];
fh->File_Type (String ("Base Route File #%d") % i);
fh->File_ID (String ("Base%d") % i);
//---- get the file format ----
if (Check_Control_Key (BASE_ROUTE_FORMAT, i)) {
fh->Dbase_Format (Get_Control_String (BASE_ROUTE_FORMAT, i));
}
fh->Open (Project_Filename (key));
}
}
//---- initialize the alternative routes ----
num_files = Highest_Control_Group (ALTERNATIVE_ROUTE_FILE, 0);
if (num_files > 0) {
alt_routes.Initialize (num_files);
Print (1);
//---- open each file ----
for (i=1; i <= num_files; i++) {
//---- open the alternative ridership file ----
key = Get_Control_String (ALTERNATIVE_ROUTE_FILE, i);
if (key.empty ()) continue;
fh = alt_routes [i-1];
fh->File_Type (String ("Alternative Route File #%d") % i);
fh->File_ID (String ("Alte%d") % i);
//---- get the file format ----
if (Check_Control_Key (ALTERNATIVE_ROUTE_FORMAT, i)) {
fh->Dbase_Format (Get_Control_String (ALTERNATIVE_ROUTE_FORMAT, i));
}
fh->Open (Project_Filename (key));
}
}
}
void PerfPrep::Program_Control (void)
{
String key;
Strings list;
Str_Itr str_itr;
//---- open network files ----
Data_Service::Program_Control ();
Read_Select_Keys ();
Read_Flow_Time_Keys ();
Print (2, String ("%s Control Keys:") % Program ());
new_file_flag = System_File_Flag (NEW_PERFORMANCE);
//---- open the merge performance ----
key = Get_Control_String (MERGE_PERFORMANCE_FILE);
if (!key.empty ()) {
merge_file.File_Type ("Merge Performance File");
Print (1);
if (Check_Control_Key (MERGE_PERFORMANCE_FORMAT)) {
merge_file.Dbase_Format (Get_Control_String (MERGE_PERFORMANCE_FORMAT));
}
merge_file.Open (Project_Filename (key));
merge_flag = true;
if (!new_file_flag) {
Error ("A New Performance File is required for Merge Processing");
}
}
//---- open the base performance ----
key = Get_Control_String (BASE_PERFORMANCE_FILE);
if (!key.empty ()) {
base_file.File_Type ("Base Performance File");
Print (1);
if (Check_Control_Key (BASE_PERFORMANCE_FORMAT)) {
base_file.Dbase_Format (Get_Control_String (BASE_PERFORMANCE_FORMAT));
}
base_file.Open (Project_Filename (key));
base_flag = true;
if (!new_file_flag) {
Error ("A New Performance File is required for Base Processing");
}
}
//---- open the merge turn delay ----
turn_flag = System_File_Flag (TURN_DELAY);
if (turn_flag) {
key = Get_Control_String (MERGE_TURN_DELAY_FILE);
if (!key.empty ()) {
turn_file.File_Type ("Merge Turn Delay File");
Print (1);
if (Check_Control_Key (MERGE_TURN_DELAY_FORMAT)) {
turn_file.Dbase_Format (Get_Control_String (MERGE_TURN_DELAY_FORMAT));
}
turn_file.Open (Project_Filename (key));
turn_merge_flag = true;
if (!System_File_Flag (NEW_TURN_DELAY)) {
Error ("A New Turn Delay File is required for Merge Processing");
}
}
}
//---- processing method ----
Print (1);
key = Get_Control_Text (PROCESSING_METHOD);
if (!key.empty ()) {
method = Combine_Code (key);
if (method != UPDATE_TIMES) {
if (merge_flag || turn_merge_flag) {
if (method == WEIGHTED_LINK_AVG || method == REPLACE_AVERAGE) {
//---- merge weighting factor ----
factor = Get_Control_Double (MERGE_WEIGHTING_FACTOR);
}
} else {
//Error (String ("Processing Method %s requires Merge Files") % key);
}
}
}
//---- read the smoothing parameters ----
smooth_flag = smooth_data.Read_Control ();
if (smooth_flag) {
if (!smooth_data.Num_Input (time_periods.Num_Periods ())) {
Error ("Smooth Parameters are Illogical");
}
if (!new_file_flag) {
Error ("A New Performance File is required for Data Smoothing");
}
}
//---- set min travel time ----
min_time_flag = Get_Control_Flag (SET_MIN_TRAVEL_TIME);
if (min_time_flag && !new_file_flag) {
Error ("A New Performance File is required for Minimum Travel Times");
}
//---- set merge transit data ----
key = Get_Control_Text (MERGE_TRANSIT_DATA);
if (!key.empty ()) {
transit_flag = true;
if (!System_File_Flag (TRANSIT_STOP) || !System_File_Flag (TRANSIT_ROUTE) ||
!System_File_Flag (TRANSIT_SCHEDULE) || !System_File_Flag (TRANSIT_DRIVER)) {
Error ("Transit Network Files are Required for Transit Loading");
}
if (!new_file_flag) {
Error ("A New Performance File is required to Merge Transit Data");
}
key.Parse (list);
for (str_itr = list.begin (); str_itr != list.end (); str_itr++) {
if (str_itr->Starts_With ("VEH")) {
transit_veh_flag = true;
} else if (str_itr->Starts_With ("PER")) {
transit_person_flag = true;
} else if (str_itr->Starts_With ("PCE") || str_itr->Starts_With ("CAR_EQ")) {
transit_pce_flag = true;
}
}
if (!System_File_Flag (VEHICLE_TYPE) && transit_pce_flag) {
Warning ("Vehicle Type File is Required for Transit PCE Loading");
}
if (!System_File_Flag (RIDERSHIP) && transit_person_flag) {
Warning ("Ridership File is Required for Transit Person Loading");
}
if (!merge_flag) {
method = Combine_Code (Get_Control_Text (PROCESSING_METHOD));
}
}
//---- open the time constraint file ----
key = Get_Control_String (TIME_CONSTRAINT_FILE);
if (!key.empty ()) {
constraint_file.File_Type ("Time Constraint File");
Print (1);
if (Check_Control_Key (TIME_CONSTRAINT_FORMAT)) {
constraint_file.Dbase_Format (Get_Control_String (TIME_CONSTRAINT_FORMAT));
}
constraint_file.Open (Project_Filename (key));
constraint_flag = true;
}
//---- open the time ratio file ----
key = Get_Control_String (NEW_TIME_RATIO_FILE);
if (!key.empty ()) {
time_ratio_file.File_Type ("New Time Ratio File");
time_ratio_file.Create (Project_Filename (key));
time_ratio_flag = true;
}
//---- open the deleted record file ----
key = Get_Control_String (NEW_DELETED_RECORD_FILE);
if (!key.empty ()) {
deleted_file.File_Type ("New Deleted Record File");
Print (1);
if (Check_Control_Key (NEW_DELETED_RECORD_FORMAT)) {
deleted_file.Dbase_Format (Get_Control_String (NEW_DELETED_RECORD_FORMAT));
}
deleted_file.Create (Project_Filename (key));
del_file_flag = true;
}
List_Reports ();
first_delete = deleted_flag = (Report_Flag (DELETED_RECORDS) || del_file_flag);
}
void Validate::Program_Control (void)
{
int i, num;
String key, record;
Dtime low, high;
Db_File label_file;
Str_Map_Stat map_stat;
//---- set equivalence flags ----
line_flag = Report_Flag (LINE_GROUP);
stop_flag = (Report_Flag (STOP_GROUP) || Report_Flag (BOARD_GROUP) || Report_Flag (ALIGHT_GROUP));
Link_Equiv_Flag (Report_Flag (LINK_GROUP) || Report_Flag (GROUP_DETAILS));
Zone_Equiv_Flag (Report_Flag (ZONE_GROUP));
Stop_Equiv_Flag (stop_flag);
Line_Equiv_Flag (line_flag);
//---- open network files ----
Data_Service::Program_Control ();
Print (2, String ("%s Control Keys:") % Program ());
//---- check for traffic counts ----
if (Check_Control_Key (TRAFFIC_COUNT_FILE)) {
link_flag = true;
if (Report_Flag (ZONE_GROUP)) {
if (!System_File_Flag (ZONE)) {
Error ("Zone File is Required for Zone Group Reports");
}
zone_flag = true;
} else if (Report_Flag (AREA_TYPE)) {
zone_flag = System_File_Flag (ZONE);
}
} else {
if (Report_Flag (VOLUME_LEVEL) || Report_Flag (FACILITY_TYPE) ||
Report_Flag (AREA_TYPE) || Report_Flag (ZONE_GROUP) ||
Report_Flag (LINK_GROUP) || Report_Flag (GROUP_DETAILS)) {
Error ("Traffic Count file is Required for Link-Based Reports");
}
}
//---- check for turning movements ----
if (Check_Control_Key (TURN_COUNT_FILE)) {
if ((Report_Flag (TURN_MOVEMENT) || Report_Flag (TURN_LOS)) &&
!System_File_Flag (CONNECTION)) {
Error ("Connection File is Required for Turning Movement Reports");
}
if (Report_Flag (TURN_LOS) && !(System_File_Flag (SIGNAL) &&
System_File_Flag (TIMING_PLAN) && System_File_Flag (PHASING_PLAN))) {
Error ("Signal Data is Required for Turn Level of Service Analysis");
}
turn_flag = true;
} else {
if (Report_Flag (TURN_MOVEMENT) || Report_Flag (TURN_LOS)) {
Error ("Turn Count File is Required for Turning Movement Reports");
}
System_File_False (POCKET);
System_File_False (CONNECTION);
System_File_False (SIGNAL);
System_File_False (TIMING_PLAN);
System_File_False (PHASING_PLAN);
}
//---- check for transit reports ----
if (line_flag || stop_flag) {
if (!System_File_Flag (TRANSIT_STOP) || !System_File_Flag (TRANSIT_ROUTE) ||
!System_File_Flag (TRANSIT_SCHEDULE) || !System_File_Flag (TRANSIT_DRIVER) ||
!System_File_Flag (RIDERSHIP)) {
Error ("Transit Network and Ridership are Required for Transit Reports");
}
if (line_flag && !Check_Control_Key (LINE_EQUIVALENCE_FILE)) {
Error ("Line Group Equivalance is Required for Line Group Reports");
}
if (line_flag && !Check_Control_Key (LINE_GROUP_COUNT_FILE)) {
Error ("Line Group Counts are Required for Line Group Reports");
}
if (stop_flag && !Check_Control_Key (STOP_EQUIVALENCE_FILE)) {
Error ("Stop Group Equivalance is Required for Stop Group Reports");
}
if (stop_flag && !Check_Control_Key (STOP_GROUP_COUNT_FILE)) {
Error ("Stop Group Counts are Required for Stop Group Reports");
}
} else {
System_File_False (TRANSIT_STOP);
System_File_False (TRANSIT_ROUTE);
System_File_False (TRANSIT_SCHEDULE);
System_File_False (TRANSIT_DRIVER);
System_File_False (RIDERSHIP);
}
//---- check for a link delay file ----
if (!System_File_Flag (LINK_DELAY)) {
//---- open the link volume file ----
if (link_flag) {
key = Get_Control_String (INPUT_VOLUME_FILE);
if (key.empty ()) goto control_error;
Print (1);
volume_file.File_Type ("Input Volume File");
volume_file.Open (Project_Filename (key));
Print (1, "Number of Time Periods = ") << volume_file.Num_Periods ();
}
//---- open the turn movement file ----
if (turn_flag) {
key = Get_Control_String (TURN_VOLUME_FILE);
if (key.empty ()) goto control_error;
Print (1);
turn_volume.File_Type ("Turn Volume File");
turn_volume.Open (Project_Filename (key));
}
} else {
delay_flag = true;
}
//---- open the traffic count file ----
if (link_flag) {
key = Get_Control_String (TRAFFIC_COUNT_FILE);
Print (1);
count_file.File_Type ("Traffic Count File");
count_file.Open (Project_Filename (key));
Print (1, "Number of Time Periods = ") << count_file.Num_Periods ();
}
//---- open the turn count file ----
if (turn_flag) {
key = Get_Control_String (TURN_COUNT_FILE);
Print (1);
turn_count.File_Type ("Turn Count File");
turn_count.Open (Project_Filename (key));
}
//---- open the transit line group count file ----
if (line_flag) {
key = Get_Control_String (LINE_GROUP_COUNT_FILE);
Print (1);
line_count_file.File_Type ("Transit Line Group Count File");
line_count_file.Open (Project_Filename (key));
line_count_file.Required_Field ("GROUP", "LINE", "LINEGROUP", "LINEGRP", "ID");
line_count_file.Required_Field ("COUNT", "RIDERS", "PASSENGERS", "TOTAL", "VOLUME");
}
//---- open the transit stop group count file ----
if (stop_flag) {
key = Get_Control_String (STOP_GROUP_COUNT_FILE);
Print (1);
stop_count_file.File_Type ("Transit Stop Group Count File");
stop_count_file.Open (Project_Filename (key));
stop_count_file.Required_Field ("GROUP", "STOP", "STOPGROUP", "STOPGRP", "ID");
if (Report_Flag (STOP_GROUP)) {
stop_count_file.Required_Field ("TOTAL", "ONOFF", "ON_OFF", "PASSENGERS", "COUNT");
}
if (Report_Flag (BOARD_GROUP)) {
stop_count_file.Required_Field ("BOARDINGS", "BOARD", "ON", "PASSENGERS", "COUNT");
}
if (Report_Flag (ALIGHT_GROUP)) {
stop_count_file.Required_Field ("ALIGHTINGS", "ALIGHT", "OFF", "PASSENGERS", "COUNT");
}
}
//---- create new volume file ----
key = Get_Control_String (NEW_VOLUME_FILE);
if (!key.empty ()) {
if (!delay_flag && !link_flag) {
Error ("Link Delay or Volume File is Required to Output Volume Data");
}
Print (1);
output_file.File_Type ("New Volume File");
output_file.Create (Project_Filename (key));
output_flag = true;
}
//---- create new volume count file ----
key = Get_Control_String (NEW_VOLUME_COUNT_FILE);
if (!key.empty ()) {
if (!delay_flag && !link_flag) {
Error ("Volume and Count Files are Required to Output Volume Count Data");
}
Print (1);
vol_cnt_file.File_Type ("New Volume Count File");
vol_cnt_file.Create (Project_Filename (key));
vc_flag = true;
}
//---- adjust the volume ranges ----
hours = 24.0 * sum_periods.Range_Length () / Dtime (MIDNIGHT, SECONDS);
if (hours < 12.0) {
double adjust = (hours <= 4.0) ? 0.1 : 0.5;
for (i=0; volume_level [i] > 0; i++) {
volume_level [i] = (int) (volume_level [i] * adjust + 0.5);
}
}
hours = hours / sum_periods.Num_Periods ();
//---- check the data fields ----
if (link_flag) {
key = "Traffic Count";
num = sum_periods.Num_Periods ();
if (count_file.Num_Periods () < num) goto field_error;
for (i=0; i < num; i++) {
sum_periods.Period_Range (i, low, high);
if (!count_file.In_Range (low) || !count_file.In_Range ((low + high) / 2)) goto field_error;
}
if (!delay_flag) {
key = "Input Volume";
if (volume_file.Num_Periods () < num) goto field_error;
for (i=0; i < num; i++) {
sum_periods.Period_Range (i, low, high);
if (!volume_file.In_Range (low) || !volume_file.In_Range ((low + high) / 2)) goto field_error;
}
}
}
//---- read the analysis method ----
key = Get_Control_Text (ANALYSIS_METHOD);
if (!key.empty ()) {
if (key.Equals ("VOLUME")) {
method = false;
} else if (key.Equals ("VMT")) {
method = true;
} else {
Error (String ("Analysis Method = %s was Unrecognized") % key);
}
}
header1 = String ("\n%29cNum. ------%s------ ---Difference--- --Abs.Error-- Std. %% R ----V/C----") %
BLANK % ((method) ? "--VMT-" : "Volume") % FINISH;
header2 = String (" Obs. Estimate Observed %6.6s %% Avg. %% Dev. RMSE Sq. Avg. Max.\n") %
((method) ? "VMT" : "Volume") % FINISH;
//---- read the adjustment factor ----
factor = Get_Control_Double (ADJUSTMENT_FACTOR);
//---- open the facility type labels ----
if (Report_Flag (FACILITY_TYPE)) {
key = Get_Control_String (FACILITY_TYPE_LABELS);
if (!key.empty ()) {
label_file.File_Type ("Facility Type Label File");
Print (1);
label_file.Open (Project_Filename (key));
while (label_file.Read ()) {
record = label_file.Record_String ();
if (record.empty ()) continue;
record.Split (key);
i = key.Integer ();
map_stat = facility_type.insert (Str_Map_Data (i, record));
if (!map_stat.second) {
Error ("Duplicate Facility Type Label");
}
}
label_file.Close ();
}
}
//---- open the area type labels ----
if (Report_Flag (AREA_TYPE)) {
key = Get_Control_String (AREA_TYPE_LABELS);
if (!key.empty ()) {
label_file.File_Type ("Area Type Label File");
Print (1);
label_file.Open (Project_Filename (key));
while (label_file.Read ()) {
record = label_file.Record_String ();
if (record.empty ()) continue;
record.Split (key);
i = key.Integer ();
map_stat = area_type.insert (Str_Map_Data (i, record));
if (!map_stat.second) {
Error ("Duplicate Area Type Label");
}
}
label_file.Close ();
}
}
//---- write the report names ----
List_Reports ();
//---- read the zone equiv ----
if (Zone_Equiv_Flag ()) {
zone_equiv.Read (Report_Flag (ZONE_EQUIV));
}
//---- process support data ----
if (Link_Equiv_Flag ()) {
link_equiv.Read (Report_Flag (LINK_EQUIV));
}
//---- read the line equiv ----
if (line_flag) {
line_equiv.Read (Report_Flag (LINE_EQUIV));
}
//---- read the stop equiv ----
if (stop_flag) {
stop_equiv.Read (Report_Flag (STOP_EQUIV));
}
return;
//---- error message ----
field_error:
Error (String ("The %s File has insufficient data for %d Time Increments") % key % num);
control_error:
Error (String ("Missing Control Key = %s") % Current_Key ());
}
