void Network_Service::Read_Line (void)
{
Line_File *file = (Line_File *) Network_Db_File (TRANSIT_ROUTE);
//---- store the transit route data ----
Show_Message ("Reading %s -- Record", file->File_Type ());
Set_Progress ();
if (Check_Data () || Renumber ()) {
if (!Network_Data_Flag (TRANSIT_STOP) &&
(Network_File_Flag (TRANSIT_STOP) || Network_Option_Flag (TRANSIT_STOP))) {
Error (file_error, "Transit Stop", file->File_ID ());
}
}
First_Record (true);
int i, num;
while (file->Read (false)) {
Show_Progress ();
if (Line_Processing (file)) {
if (!line_data.Add ()) goto add_error;
}
First_Record (false);
num = file->Stops ();
for (i=1; i <= num; i++) {
if (!file->Read (true)) {
Error ("Number of Nested Records for Route %d", file->Route ());
}
Show_Progress ();
if (Line_Processing (file)) {
if (!line_data.Add ()) goto add_error;
}
}
}
End_Progress ();
file->Close ();
line_data.Route_Records (Progress_Count ());
Print (2, "Number of %s Records = %d", file->File_Type (), Progress_Count ());
num = line_data.Num_Records ();
if (num && num != Progress_Count ()) {
Print (1, "Number of Transit Route Data Records = %d", num);
}
line_data.Optimize ();
if (num > 0) Network_Data_True (TRANSIT_ROUTE);
return;
add_error:
Error ("Adding Record to the Transit Route Data List");
}
void Data_Service::Read_Lines (Line_File &file)
{
int i, num;
bool keep_flag;
Int_Map_Stat map_stat;
Line_Data line_rec;
//---- store the route data ----
Show_Message (String ("Reading %s -- Record") % file.File_Type ());
Set_Progress ();
Initialize_Lines (file);
while (file.Read (false)) {
Show_Progress ();
line_rec.Clear ();
keep_flag = Get_Line_Data (file, line_rec);
num = file.Num_Nest ();
if (num > 0) line_rec.reserve (num);
for (i=1; i <= num; i++) {
if (!file.Read (true)) {
Error (String ("Number of Stop Records for Route %d") % file.Route ());
}
Show_Progress ();
Get_Line_Data (file, line_rec);
}
if (keep_flag) {
map_stat = line_map.insert (Int_Map_Data (line_rec.Route (), (int) line_array.size ()));
if (!map_stat.second) {
Warning ("Duplicate Route Number = ") << line_rec.Route ();
} else {
line_array.push_back (line_rec);
line_array.Add_Route_Stops ((int) line_rec.size ());
}
}
}
End_Progress ();
file.Close ();
Print (2, String ("Number of %s Records = %d") % file.File_Type () % Progress_Count ());
num = (int) line_array.size ();
if (num && num != Progress_Count ()) {
Print (1, String ("Number of %s Data Records = %d") % file.File_ID () % num);
}
if (num > 0) System_Data_True (TRANSIT_ROUTE);
}
void Data_Service::Read_Shapes (Shape_File &file)
{
int i, num;
bool keep_flag;
Shape_Data shape_rec;
Int_Map_Stat map_stat;
//---- store the shape point data ----
Show_Message (String ("Reading %s -- Record") % file.File_Type ());
Set_Progress ();
Initialize_Shapes (file);
while (file.Read (false)) {
Show_Progress ();
shape_rec.Clear ();
keep_flag = Get_Shape_Data (file, shape_rec);
num = file.Num_Nest ();
if (num > 0) shape_rec.reserve (num);
for (i=1; i <= num; i++) {
if (!file.Read (true)) {
Error (String ("Number of Nested Records for Link %d") % file.Link ());
}
Show_Progress ();
Get_Shape_Data (file, shape_rec);
}
if (keep_flag) {
map_stat = shape_map.insert (Int_Map_Data (shape_rec.Link (), (int) shape_array.size ()));
if (!map_stat.second) {
Warning ("Duplicate Link Number = ") << shape_rec.Link ();
} else {
shape_array.push_back (shape_rec);
}
}
}
End_Progress ();
file.Close ();
Print (2, String ("Number of %s Records = %d") % file.File_Type () % Progress_Count ());
num = (int) shape_array.size ();
if (num && num != Progress_Count ()) {
Print (1, String ("Number of Link %s Records = %d") % file.File_ID () % num);
}
if (num > 0) System_Data_True (SHAPE);
}
void Data_Service::Read_Locations (void)
{
Location_File *file = (Location_File *) System_File_Handle (LOCATION);
int num;
bool zone_flag = System_Data_Flag (ZONE);
Int_Map_Stat map_stat;
Location_Data location_rec;
//---- store the location data ----
Show_Message (String ("Reading %s -- Record") % file->File_Type ());
Set_Progress ();
Initialize_Locations (*file);
while (file->Read ()) {
Show_Progress ();
location_rec.Clear ();
if (Get_Location_Data (*file, location_rec)) {
map_stat = location_map.insert (Int_Map_Data (location_rec.Location (), (int) location_array.size ()));
if (!map_stat.second) {
Warning ("Duplicate Location Number = ") << location_rec.Location ();
continue;
} else {
if (!file->Setback_Flag () && location_rec.Setback () == 0) {
location_rec.Setback (Internal_Units (100.0, FEET));
}
location_array.push_back (location_rec);
if (!zone_flag && location_rec.Zone () > Max_Zone_Number ()) {
Max_Zone_Number (location_rec.Zone ());
}
}
}
}
End_Progress ();
file->Close ();
Print (2, String ("Number of %s Records = %d") % file->File_Type () % Progress_Count ());
num = (int) location_array.size ();
if (num && num != Progress_Count ()) {
Print (1, String ("Number of %s Data Records = %d") % file->File_ID () % num);
}
if (num > 0) System_Data_True (LOCATION);
}
void Data_Service::Read_Events (void)
{
Event_File *file = (Event_File *) System_File_Handle (EVENT);
int num;
Event_Data event_rec;
Event_Index event_index;
Event_Map_Stat map_stat;
//---- store the event data ----
Show_Message (String ("Reading %s -- Record") % file->File_Type ());
Set_Progress ();
Initialize_Events (*file);
while (file->Read ()) {
Show_Progress ();
event_rec.Clear ();
if (Get_Event_Data (*file, event_rec)) {
event_rec.Get_Event_Index (event_index);
map_stat = event_map.insert (Event_Map_Data (event_index, (int) event_array.size ()));
if (!map_stat.second) {
Warning (String ("Duplicate Event Record = %d-%d-%d-%d-%d") %
event_index.Household () % event_index.Person () % event_index.Tour () %
event_index.Trip () % event_index.Event ());
continue;
} else {
event_array.push_back (event_rec);
}
}
}
End_Progress ();
file->Close ();
Print (2, String ("Number of %s Records = %d") % file->File_Type () % Progress_Count ());
num = (int) event_array.size ();
if (num && num != Progress_Count ()) {
Print (1, String ("Number of %d Data Records = %d") % file->File_ID () % num);
}
if (num > 0) System_Data_True (EVENT);
}
void Data_Service::Read_Zones (void)
{
Zone_File *file = (Zone_File *) System_File_Handle (ZONE);
Zone_Data zone_rec;
Int_Map_Stat map_stat;
//---- store the zone data ----
Show_Message (String ("Reading %s -- Record") % file->File_Type ());
Set_Progress ();
Initialize_Zones (*file);
while (file->Read ()) {
Show_Progress ();
zone_rec.Clear ();
if (Get_Zone_Data (*file, zone_rec)) {
map_stat = zone_map.insert (Int_Map_Data (zone_rec.Zone (), (int) zone_array.size ()));
if (!map_stat.second) {
Warning ("Duplicate Zone Number = ") << zone_rec.Zone ();
continue;
} else {
zone_array.push_back (zone_rec);
if (zone_rec.Zone () > Max_Zone_Number ()) {
Max_Zone_Number (zone_rec.Zone ());
}
}
}
}
End_Progress ();
file->Close ();
Print (2, String ("Number of %s Records = %d") % file->File_Type () % Progress_Count ());
int num = (int) zone_array.size ();
if (num && num != Progress_Count ()) {
Print (1, String ("Number of %s Data Records = %d") % file->File_ID () % num);
}
if (num != Max_Zone_Number ()) Print (1, "Highest Zone Number = ") << Max_Zone_Number ();
if (num > 0) System_Data_True (ZONE);
}
void ArcNet::Write_Subzone (void)
{
XYZ_Point point;
int z_field = subzone_file.Optional_Field ("Z_COORD", "ELEVATION", "Z");
arcview_subzone.Num_Points (1);
Show_Message ("Reading %s -- Record", subzone_file.File_Type ());
Set_Progress (1000);
while (subzone_file.Read ()) {
Show_Progress ();
arcview_subzone.Copy_Fields (&subzone_file);
point.x = subzone_file.X ();
point.y = subzone_file.Y ();
subzone_file.Get_Field (z_field, &(point.z));
arcview_subzone.points.Set (1, &point);
if (!arcview_subzone.Write_Record ()) {
Error ("Writing ArcView Subzone File");
}
}
End_Progress ();
subzone_file.Close ();
arcview_subzone.Close ();
Print (2, "Number of %s Records = %d", subzone_file.File_Type (), Progress_Count ());
}
void IntControl::Read_Deletes (void)
{
int node;
//---- store the delete data ----
Show_Message ("Reading %s -- Record", delete_file.File_Type ());
Set_Progress ();
while (delete_file.Read ()) {
Show_Progress ();
Get_Integer (delete_file.Record (), &node);
if (node == 0) continue;
if (!delete_node.Add (node)) {
Error ("Adding Delete Node Record");
}
}
End_Progress ();
delete_file.Close ();
Print (2, "Number of %s Records = %d", delete_file.File_Type (), Progress_Count ());
}
void Network_Service::Read_Phasing (void)
{
Db_File *file = Network_Db_File (PHASING_PLAN);
//---- store the phasing plan data ----
Show_Message ("Reading %s -- Record", file->File_Type ());
Set_Progress ();
if (Check_Data () || Renumber ()) {
if (!Network_File_Flag (NODE) && Network_Option_Flag (NODE)) {
Error (file_error, "Node", file->File_ID ());
}
if (!Network_File_Flag (LINK) && Network_Option_Flag (LINK)) {
Error (file_error, "Link", file->File_ID ());
}
if (!Network_File_Flag (TIMING_PLAN) && Network_Option_Flag (TIMING_PLAN)) {
Error (file_error, "Timing Plan", file->File_ID ());
}
}
file->Num_Records ();
First_Record (true);
while (file->Read ()) {
Show_Progress ();
if (Phasing_Processing (file)) {
if (!phasing_data.Add ()) {
Error ("Adding Record to the Phasing Plan List");
}
}
First_Record (false);
}
End_Progress ();
file->Close ();
phasing_data.Max_Records (phasing_data.Num_Records ());
Print (2, "Number of %s Records = %d", file->File_Type (), Progress_Count ());
int num = phasing_data.Num_Records ();
if (num && num != Progress_Count ()) {
Print (1, "Number of Phasing Plan Data Records = %d", num);
}
if (num > 0) Network_Data_True (PHASING_PLAN);
}
void LocationData::Read_Polygons (void)
{
int i, index, num_pts;
Arcview_File *poly_file;
Boundary poly_rec;
Index_Array *polygon;
Db_Index_Array *data;
//---- read the arcview boundary file ----
for (i=0; i < num_polygons; i++) {
poly_file = polygon_files [i];
if (poly_file == NULL) continue;
Show_Message ("Reading %s -- Record", poly_file->File_Type ());
Set_Progress (1000);
//---- read each record ----
index = 0;
polygon = polygons [i];
data = polygon_db [i];
while (poly_file->Read_Record ()) {
Show_Progress ();
poly_rec.zone = ++index;
num_pts = poly_file->Num_Points ();
poly_rec.points = new Point_Data ();
if (poly_rec.points == NULL || !poly_rec.points->Num_Points (num_pts)) {
Error ("Insufficient Memory for Boundary Polygons");
}
num_pts *= sizeof (XY_Point);
memcpy (poly_rec.points->Get_XY_Data (1), poly_file->Get_XY_Data (1), num_pts);
if (!polygon->Add (&poly_rec)) {
Error ("Adding Boundary Polygon");
}
//----- add to the database ----
data->Copy_Fields (poly_file);
data->Put_Field (1, index);
if (!data->Add_Record ()) {
Error ("Writing Boundary Polygon Database");
}
}
End_Progress ();
Print (2, "Number of %s Records = %d", poly_file->File_Type (), Progress_Count ());
poly_file->Close ();
}
}
void Network_Service::Read_Turn (void)
{
Turn_File *file = (Turn_File *) Network_Db_File (TURN_PROHIBITION);
//---- store the turn prohibition data ----
Show_Message ("Reading %s -- Record", file->File_Type ());
Set_Progress ();
if (Check_Data () || Renumber ()) {
if (!Network_File_Flag (NODE) && Network_Option_Flag (NODE) && file->Node_Based ()) {
Error (file_error, "Node", file->File_ID ());
}
if (!Network_File_Flag (LINK) && Network_Option_Flag (LINK)) {
Error (file_error, "Link", file->File_ID ());
}
}
file->Num_Records ();
First_Record (true);
while (file->Read ()) {
Show_Progress ();
if (Turn_Processing (file)) {
if (!turn_data.Add ()) {
Error ("Adding Record to the Turn Data List");
}
}
First_Record (false);
}
End_Progress ();
file->Close ();
Print (2, "Number of %s Records = %d", file->File_Type (), Progress_Count ());
int num = turn_data.Num_Records ();
if (num && num != Progress_Count ()) {
Print (1, "Number of Turn Prohibition Data Records = %d", num);
}
turn_data.Optimize ();
if (num > 0) Network_Data_True (TURN_PROHIBITION);
}
void RoutePrep::Read_Node_Map (void)
{
String record;
Strings fields;
int node, index;
Int_Map_Itr map_itr;
Int_Map_Stat map_stat;
Node_Data *node_ptr;
Show_Message (String ("Reading %s -- Record") % node_map_file.File_Type ());
Set_Progress ();
while (node_map_file.Read ()) {
Show_Progress ();
record = node_map_file.Record_String ();
record.Parse (fields);
node = fields [0].Integer ();
if (node <= 0) continue;
index = fields [1].Integer ();
if (index > 0) {
map_itr = node_map.find (index);
if (map_itr == node_map.end ()) {
Warning (String ("Node Map %d to %d was Not Found in the Node File") % node % index);
continue;
}
index = map_itr->second;
}
//---- insert the node;
map_stat = input_map.insert (Int_Map_Data (node, index));
if (!map_stat.second) {
Warning (String ("Duplicate Node Map %d to %d and %d") % node % index % map_stat.first->second);
continue;
}
if (index >= 0) {
node_ptr = &node_array [index];
node_ptr->Control (node);
}
}
End_Progress ();
node_map_file.Close ();
Print (2, String ("Number of %s Records = %d") % node_map_file.File_Type () % Progress_Count ());
}
void Demand_Service::Read_Vehicle (void)
{
vehicle_data.Sorted (!sort_flag);
Db_File *file = Demand_Db_File (VEHICLE);
//---- store the vehicle data ----
Show_Message ("Reading %s -- Record", file->File_Type ());
Set_Progress (50000);
if (Check_Data () || Renumber ()) {
if (!Network_File_Flag (PARKING) && Network_Option_Flag (PARKING)) {
Error (file_error, "Parking", file->File_ID ());
}
}
//file->Num_Records ();
First_Record (true);
while (file->Read ()) {
Show_Progress ();
if (Vehicle_Processing (file)) {
if (!vehicle_data.Add ()) {
Error ("Adding Record to the Vehicle Data Array");
}
}
First_Record (false);
}
End_Progress ();
file->Close ();
Print (2, "Number of %s Records = %d", file->File_Type (), Progress_Count ());
int num = vehicle_data.Num_Records ();
if (num && num != Progress_Count ()) {
Print (1, "Number of Vehicle Data Records = %d", num);
}
vehicle_data.Optimize (compress_flag);
if (num > 0) Demand_Data_True (VEHICLE);
}
void CheckSurvey::Survey_Weights (void)
{
int id, count;
double weight;
char *str_ptr;
Household_Data *household_ptr;
count = 0;
//---- read the survey household weights ----
Show_Message ("Reading %s -- Record", weight_file.File_Type ());
Set_Progress (50000);
while (weight_file.Read ()) {
str_ptr = weight_file.Record ();
//---- check the household id ----
str_ptr = Get_Integer (str_ptr, &id);
if (id <= 0) continue;
Show_Progress ();
household_ptr = survey_hh_data.Get (id);
if (household_ptr == NULL) continue;
Get_Double (str_ptr, &weight);
household_ptr->Location ((int) (weight + random.Probability ()));
count++;
}
End_Progress ();
weight_file.Close ();
Print (2, "Number of %s Records = %d", weight_file.File_Type (), Progress_Count ());
if (count != Progress_Count ()) {
Print (1, "Number of Household Weights Kept = %d", count);
}
}
void TransitAccess::Read_Link (void)
{
int anode, bnode, dist, zone, type;
double len;
String text;
Zone_Map_Itr zone_itr;
Node_Map_Itr node_itr;
//---- walk link data ----
Show_Message (String ("Reading %s -- Record") % link_data_file.File_Type ());
Set_Progress ();
while (link_data_file.Read ()) {
Show_Progress ();
anode = link_data_file.Get_Integer (link_anode_fld);
bnode = link_data_file.Get_Integer (link_bnode_fld);
if (skip_links.find (Int2_Key (anode, bnode)) != skip_links.end ()) continue;
if (skip_links.find (Int2_Key (bnode, anode)) != skip_links.end ()) continue;
len = link_data_file.Get_Double (link_len_fld);
zone = link_data_file.Get_Integer (link_zone_fld);
type = link_data_file.Get_Integer (link_type_fld);
if (!type_range.In_Range (type)) continue;
zone_itr = zone_map.find (zone);
if (zone_itr == zone_map.end ()) continue;
if (zone_itr->second.walk == 0) continue;
dist = DTOI (len * 100.0 * zone_itr->second.weight);
node_itr = node_map.find (anode);
if (node_itr != node_map.end ()) {
node_itr->second.use = 1;
}
node_itr = node_map.find (bnode);
if (node_itr != node_map.end ()) {
node_itr->second.use = 1;
}
text (" N=%d-%d MODE=13 SPEED=3 ONEWAY=T DIST=%d") % anode % bnode % dist;
sidewalk_file.File () << "SUPPORT" << text << endl;
walk_link_file.File () << "SUPPLINK" << text << endl;
}
End_Progress ();
link_data_file.Close ();
Print (2, "Number of Link Data Records = ") << Progress_Count ();
}
void Demand_Service::Read_Population (void)
{
Db_File *file = Demand_Db_File (POPULATION);
//---- store the population data ----
Show_Message ("Reading %s -- Record", file->File_Type ());
Set_Progress (50000);
if (Check_Data () || Renumber ()) {
if (!Demand_File_Flag (HOUSEHOLD) && Demand_Option_Flag (HOUSEHOLD)) {
Error (file_error, "Household", file->File_ID ());
}
}
//file->Num_Records ();
First_Record (true);
while (file->Read ()) {
Show_Progress ();
if (Population_Processing (file)) {
if (!population_data.Add ()) {
Error ("Adding Record to the Population Data Array");
}
}
First_Record (false);
}
End_Progress ();
file->Close ();
Print (2, "Number of %s Records = %d", file->File_Type (), Progress_Count ());
int num = population_data.Num_Records ();
if (num && num != Progress_Count ()) {
Print (1, "Number of Population Data Records = %d", num);
}
population_data.Optimize ();
if (num > 0) Demand_Data_True (POPULATION);
}
void ActivityPattern::Survey_Population (void)
{
int hhold;
Survey_HHold *household_ptr;
Survey_Person *population_ptr;
if (!survey_pop_data.Max_Records (survey_pop_file.Num_Records ())) goto mem_error;
//---- read the survey population file ----
Show_Message ("Reading %s -- Record", survey_pop_file.File_Type ());
Set_Progress (50000);
while (survey_pop_file.Read ()) {
Show_Progress ();
//---- check the household id ----
hhold = survey_pop_file.Household ();
if (hhold <= 0) continue;
household_ptr = survey_hh_data.Get (hhold);
if (household_ptr == NULL) {
Error ("Survey Person Household %d was Not Found", hhold);
}
population_ptr = survey_pop_data.New_Record (true);
if (population_ptr == NULL) goto mem_error;
population_ptr->Household (hhold);
population_ptr->Person (survey_pop_file.Person ());
population_ptr->Age (survey_pop_file.Age ());
population_ptr->Gender (survey_pop_file.Gender ());
population_ptr->Work (survey_pop_file.Work ());
population_ptr->Drive (survey_pop_file.Drive ());
population_ptr->Count (0);
if (!survey_pop_data.Add ()) {
Error ("Adding Record to the Population Data Array");
}
}
End_Progress ();
survey_pop_file.Close ();
Print (2, "Number of %s Records = %d", survey_pop_file.File_Type (), Progress_Count ());
survey_pop_data.Optimize ();
return;
mem_error:
Error ("Insufficient Memory for Survey Population Data");
}
void PlanSum::Write_Turns (void)
{
int i;
char *time1_ptr, *time2_ptr;
Movement_Data *move_ptr;
Movement_Array *array_ptr;
Dir_Data *dir_ptr;
Show_Message ("Writing %s -- Record", turn_file.File_Type ());
Set_Progress (10000);
//---- write each turn movement ----
for (i=1; i <= num_inc; i++) {
array_ptr = movement_data [i];
time1_ptr = time_periods.Range_Format (i);
time2_ptr = strstr (time1_ptr, "..");
*time2_ptr = '\0';
time2_ptr += 2;
for (move_ptr = array_ptr->First_Key (); move_ptr; move_ptr = array_ptr->Next_Key ()) {
Show_Progress ();
turn_file.Node (move_ptr->node);
dir_ptr = dir_data [move_ptr->in_link];
turn_file.In_Link (dir_ptr->Link ());
dir_ptr = dir_data [move_ptr->out_link];
turn_file.Out_Link (dir_ptr->Link ());
turn_file.Start (time1_ptr);
turn_file.End (time2_ptr);
turn_file.Volume (move_ptr->volume);
//---- save the record ----
if (!turn_file.Write ()) {
Error ("Writing Turn Movement File");
}
}
}
End_Progress ();
Print (2, "Number of %s Records = %d", turn_file.File_Type (), Progress_Count ());
turn_file.Close ();
}
void NewFormat::Read_Persons (void)
{
int hhold;
Person_Data person_rec;
Int_Map_Itr map_itr;
Household_Data *hhold_ptr;
//---- process the person file ----
Show_Message (String ("Reading %s -- Record") % person_file.File_Type ());
Set_Progress ();
while (person_file.Read ()) {
Show_Progress ();
hhold = person_file.Household ();
map_itr = hhold_map.find (hhold);
if (map_itr == hhold_map.end ()) {
Error (String ("Person %d Household %d was Not Found") % Progress_Count () % hhold);
}
hhold_ptr = &hhold_array [map_itr->second];
person_rec.Person (person_file.Person ());
person_rec.Age (person_file.Age ());
person_rec.Relate (person_file.Relate ());
person_rec.Gender (person_file.Gender ());
person_rec.Work (person_file.Work ());
person_rec.Drive (person_file.Drive ());
hhold_ptr->push_back (person_rec);
}
End_Progress ();
person_file.Close ();
Print (2, String ("Number of %s Records = %d") % person_file.File_Type () % Progress_Count ());
}
void GISNet::Read_Node (void)
{
int node, node_field, z_field;
XYZ_Point *pt_ptr;
Node_Data node_rec;
//---- initialize the node array ----
node_field = gis_node.Required_Field ("NODE", "ID", "NODE_ID", "NODEID", "N");
z_field = gis_node.Optional_Field ("Z_COORD", "ELEVATION", "Z");
//---- read each node record----
Show_Message ("Reading %s -- Record", gis_node.File_Type ());
Set_Progress (1000);
while (gis_node.Read_Record ()) {
Show_Progress ();
//---- read the node data ----
gis_node.Get_Field (node_field, &node);
if (node == 0) continue;
if (node >= first_node) first_node = node + 1;
pt_ptr = gis_node.points.First ();
//---- save to index class -----
node_rec.Node (node);
node_rec.X (Round (pt_ptr->x));
node_rec.Y (Round (pt_ptr->y));
node_rec.Z (Round (pt_ptr->z));
if (!node_data.Add (&node_rec)) {
Error ("Adding Node Data Record");
}
}
End_Progress ();
gis_node.Close ();
Print (2, "Number of %s Records = %d", gis_node.File_Type (), Progress_Count ());
}
void LocationData::Read_Boundary (void)
{
int zone, num_pts;
Boundary zone_rec;
//---- read the arcview boundary file ----
Show_Message ("Reading %s -- Record", boundary_file.File_Type ());
Set_Progress (1000);
while (boundary_file.Read_Record ()) {
Show_Progress ();
//---- get the zone field ----
boundary_file.Get_Field (zone_field, &zone);
if (zone == 0) continue;
zone_rec.zone = zone;
num_pts = boundary_file.Num_Points ();
zone_rec.points = new Point_Data ();
if (zone_rec.points == NULL || !zone_rec.points->Num_Points (num_pts)) {
Error ("Insufficient Memory for Zone Polygons");
}
num_pts *= sizeof (XY_Point);
memcpy (zone_rec.points->Get_XY_Data (1), boundary_file.Get_XY_Data (1), num_pts);
if (!zone_boundary.Add (&zone_rec)) {
Error ("Adding Zone Boundary");
}
}
End_Progress ();
Print (2, "Number of %s Records = %d", boundary_file.File_Type (), Progress_Count ());
boundary_file.Close ();
}
void TripSum::Write_Trips (void)
{
int org, des, period, trips, total;
Matrix_Data *trip_ptr;
//---- write the records ----
Show_Message ("Writing %s -- Record", trip_file.File_Type ());
Set_Progress (10000);
total = 0;
for (trip_ptr = trip_table.First_Key (); trip_ptr; trip_ptr = trip_table.Next_Key ()) {
Show_Progress ();
trips = trip_ptr->Data ();
if (trips == 0) continue;
trip_table.Key (trip_ptr->ID (), &org, &des, &period);
trip_file.Origin (org);
trip_file.Destination (des);
trip_file.Period (period);
trip_file.Data (trips);
total += trips;
if (!trip_file.Write ()) {
Error ("Writing %s", trip_file.File_Type ());
}
}
End_Progress ();
trip_file.Close ();
Print (2, "Number of %s Records = %d", trip_file.File_Type (), Progress_Count ());
Print (1, "Number of %s Trips = %d", trip_file.File_Type (), total);
}
void LinkSum::Write_Activity (void)
{
Show_Message ("Writing Link Activity File -- Record");
Set_Progress ();
link_db.Rewind ();
while (link_db.Read_Record ()) {
Show_Progress ();
activity_file.Copy_Fields (&link_db);
if (!activity_file.Write ()) {
Error ("Writing the Link Activity File");
}
}
End_Progress ();
Print (2, "Number of Link Activity Records = %d", Progress_Count ());
activity_file.Close ();
}
void TripSum::Read_Vehicle (void)
{
int id, num_out;
Vehicle_File *file, *new_file;
file = (Vehicle_File *) Demand_Db_Base (VEHICLE);
new_file = (Vehicle_File *) Demand_Db_Base (NEW_VEHICLE);
//---- process each vehicle ----
Show_Message ("Reading %s -- Record", file->File_Type ());
Set_Progress (10000);
num_out = 0;
while (file->Read ()) {
Show_Progress ();
id = file->Vehicle ();
if (id == 0) continue;
if (vehicle_list.Get_Index (id) == 0) continue;
new_file->Copy_Fields (file);
if (!new_file->Write ()) {
Error ("Writing %s", new_file->File_Type ());
}
num_out++;
}
End_Progress ();
Print (2, "Number of Vehicle Records Read = %d", Progress_Count ());
Print (1, "Number of Vehicle Records Written = %d", num_out);
file->Close ();
new_file->Close ();
}
void ActivityPattern::Write_Count (void)
{
char buffer [STRING_BUFFER];
Survey_Person *person_ptr;
Show_Message ("Writing %s -- Record", count_file.File_Type ());
Set_Progress (10000);
for (person_ptr = survey_pop_data.First_Key (); person_ptr; person_ptr = survey_pop_data.Next_Key ()) {
Show_Progress ();
str_fmt (buffer, sizeof (buffer), "%d\t%d\t%d",
person_ptr->Household (), person_ptr->Person (), person_ptr->Count ());
if (!count_file.Write (buffer)) {
Error ("Writing %s", count_file.File_Type ());
}
}
End_Progress ();
count_file.Close ();
Print (2, "Number of %s Records = %d", count_file.File_Type (), Progress_Count ());
}
void Data_Service::Read_Timing_Plans (Timing_File &file)
{
int i, num, count;
bool keep;
Timing_Record timing_rec;
Timing_Data *timing_ptr;
Signal_Data *signal_ptr;
//---- store the timing plan data ----
Show_Message (String ("Reading %s -- Record") % file.File_Type ());
Set_Progress ();
Initialize_Timing_Plans (file);
count = 0;
timing_ptr = &(timing_rec.timing_data);
while (file.Read (false)) {
Show_Progress ();
timing_rec.Clear ();
keep = Get_Timing_Data (file, timing_rec);
num = file.Num_Nest ();
if (num > 0) timing_ptr->reserve (num);
for (i=1; i <= num; i++) {
if (!file.Read (true)) {
Error (String ("Number of Phase Records for Signal %d Plan %d") %
file.Signal () % file.Timing ());
}
Show_Progress ();
Get_Timing_Data (file, timing_rec);
}
//---- save the results ----
if (keep) {
if (file.Version () <= 40) {
bool keep;
Timing40_Map_Itr timing40_itr;
Timing40_Data *timing40_ptr;
Timing_Itr timing_itr;
timing40_itr = timing40_map.find (timing_ptr->Timing ());
if (timing40_itr == timing40_map.end ()) {
Warning (String ("Timing Plan %d was Not Found in the Signal file") % timing_ptr->Timing ());
continue;
}
timing40_ptr = (Timing40_Data *) &(timing40_itr->second);
timing_rec.Signal (timing40_ptr->Signal ());
signal_ptr = &signal_array [timing_rec.Signal ()];
keep = true;
for (timing_itr = signal_ptr->timing_plan.begin (); timing_itr != signal_ptr->timing_plan.end (); timing_itr++) {
if (timing_itr->Timing () == timing40_ptr->Timing ()) {
Timing_Phase_Itr phase_itr = timing_ptr->begin ();
timing_itr->push_back (*phase_itr);
count++;
keep = false;
break;
}
}
if (!keep) continue;
timing_ptr->Timing (timing40_ptr->Timing ());
timing_ptr->Type (timing40_ptr->Type ());
timing_ptr->Offset (timing40_ptr->Offset ());
} else {
signal_ptr = &signal_array [timing_rec.Signal ()];
}
signal_ptr->timing_plan.push_back (*timing_ptr);
count += (int) timing_ptr->size () + 1;
}
}
End_Progress ();
file.Close ();
Print (2, String ("Number of %s Records = %d") % file.File_Type () % Progress_Count ());
if (count && count != Progress_Count ()) {
Print (1, String ("Number of %s Data Records = %d") % file.File_ID () % count);
}
if (count > 0) System_Data_True (TIMING_PLAN);
//---- repair Version 4.0 data ----
if (file.Version () <= 40) {
int first, prev, next, barrier, ring, position, cycle;
bool flag;
Signal_Itr signal_itr;
Timing_Itr timing_itr;
Timing_Phase_Itr phase_itr;
for (signal_itr = signal_array.begin (); signal_itr != signal_array.end (); signal_itr++) {
for (timing_itr = signal_itr->timing_plan.begin (); timing_itr != signal_itr->timing_plan.end (); timing_itr++) {
//---- map the ring positions ----
for (ring=1; ; ring++) {
flag = false;
for (phase_itr = timing_itr->begin (); phase_itr != timing_itr->end (); phase_itr++) {
if (phase_itr->Ring () == ring) {
flag = true;
break;
}
}
if (!flag) break;
first = prev = phase_itr->Phase ();
next = phase_itr->Position ();
barrier = phase_itr->Barrier ();
if (barrier == 0) {
phase_itr->Barrier ((barrier = 1));
}
count = (int) timing_itr->size ();
position = 1;
phase_itr->Position (position);
cycle = MAX ((phase_itr->Min_Green () + phase_itr->Extension ()), phase_itr->Max_Green ()) +
phase_itr->Yellow () + phase_itr->All_Red ();
while (next != first && count-- > 0) {
flag = false;
for (phase_itr = timing_itr->begin (); phase_itr != timing_itr->end (); phase_itr++) {
if (phase_itr->Phase () == next) {
flag = true;
break;
}
}
if (!flag) {
Warning (String ("Signal %d Timing %d Phase %d was Not Found") %
signal_itr->Signal () % timing_itr->Timing () % next);
break;
}
if (phase_itr->Ring () == 0) {
phase_itr->Ring (ring);
} else if (phase_itr->Ring () != ring) {
Warning (String ("Signal %d Timing %d Phase %d to %d is Not in Ring %d") %
signal_itr->Signal () % timing_itr->Timing () % prev % next % ring);
break;
}
if (phase_itr->Barrier () == 0) {
phase_itr->Barrier (barrier);
}
if (phase_itr->Barrier () == barrier) {
position++;
} else {
position = 1;
barrier = phase_itr->Barrier ();
}
prev = next;
next = phase_itr->Position ();
phase_itr->Position (position);
cycle += MAX ((phase_itr->Min_Green () + phase_itr->Extension ()), phase_itr->Max_Green ()) +
phase_itr->Yellow () + phase_itr->All_Red ();
}
if (ring == 1) {
timing_itr->Cycle (cycle);
}
}
}
}
}
}
void TransitAccess::Read_Zone (void)
{
int zone, barrier, pef;
double area;
Int_Itr value_itr;
Dbl_Itr factor_itr;
Zone_Data zone_data;
Zone_Map_Stat map_stat;
Zone_Map_Itr zone_itr;
Data_Range_Itr range_itr;
bool barrier_flag = (location_map.size () > 0);
Show_Message (String ("Reading %s -- Record") % zone_file.File_Type ());
Set_Progress ();
nzones = 0;
memset (&zone_data, '\0', sizeof (zone_data));
while (zone_file.Read ()) {
Show_Progress ();
zone = zone_file.Get_Integer (zone_fld);
if (zone == 0) continue;
zone_data.x_coord = zone_file.Get_Integer (zone_x_fld);
zone_data.y_coord = zone_file.Get_Integer (zone_y_fld);
if (zone_data.x_coord == 0 && zone_data.y_coord == 0) continue;
zone_data.location = zone_file.Get_Integer (zone_loc_fld);
zone_data.barrier = 0;
if (barrier_flag) {
for (barrier=1, range_itr = location_map.begin (); range_itr != location_map.end (); range_itr++, barrier++) {
if (range_itr->In_Range (zone_data.location)) {
zone_data.barrier = barrier;
break;
}
}
if (zone_data.barrier == 0) {
Warning (String ("Location %d was Not Assigned to a Barrier Group") % zone_data.location);
continue;
}
}
area = zone_file.Get_Double (zone_area_fld);
zone_data.distance = MIN (1.0, (0.75 * sqrt (area)));
zone_data.walk = zone_file.Get_Integer (zone_long_fld);
pef = zone_file.Get_Integer (zone_pef_fld);
zone_data.weight = 1.0;
for (value_itr = pef_values.begin (), factor_itr = pef_factors.begin (); value_itr != pef_values.end (); value_itr++, factor_itr++) {
if (pef < *value_itr) {
zone_data.weight = *factor_itr;
break;
}
}
map_stat = zone_map.insert (Zone_Map_Data (zone, zone_data));
if (!map_stat.second) {
Warning (String ("Duplicate Zone Number = %d") % zone);
}
if (zone > nzones) nzones = zone;
}
End_Progress ();
zone_file.Close ();
Print (2, "Number of Zone Records = ") << Progress_Count ();
zone = (int) zone_map.size ();
if (zone != Progress_Count ()) {
Print (1, "Number of Zones Kept = ") << zone;
}
Print (1, "Highest Zone Number = ") << nzones;
//---- get the CBD coordinates ----
zone_itr = zone_map.find (cbd_zone);
if (zone_itr == zone_map.end ()) {
Error (String ("CBD Zone %d was Not Found") % cbd_zone);
}
cbd_x = zone_itr->second.x_coord;
cbd_y = zone_itr->second.y_coord;
}
void NewFormat::Read_Routes (void)
{
String field;
int i, node, route, route_fld, mode_fld, ttime_fld, name_fld, note_fld, node_fld, dwell_fld, time_fld, spd_fld;
int head_fld [24], offset_fld [24], ttim_fld [24];
Int_Map_Stat map_stat;
Int_Map_Itr map_itr;
Route_Header route_rec, *route_ptr;
//---- process the route header file ----
Show_Message (String ("Reading %s -- Record") % route_header.File_Type ());
Set_Progress ();
route_fld = route_header.Required_Field ("ROUTE", "LINE");
mode_fld = route_header.Required_Field ("MODE", "TYPE");
ttime_fld = route_header.Optional_Field ("TTIME", "TIME", "MIN_TIME");
name_fld = route_header.Optional_Field ("NAME", "ROUTE_NAME", "RTNAME", "DESCRIPTION");
note_fld = route_header.Optional_Field (NOTES_FIELD_NAMES);
for (i=1; i <= route_periods; i++) {
field ("HEADWAY_%d") % i;
head_fld [i-1] = route_header.Required_Field (field.c_str ());
field ("OFFSET_%d") % i;
offset_fld [i-1] = route_header.Optional_Field (field.c_str ());
field ("TTIME_%d") % i;
ttim_fld [i-1] = route_header.Optional_Field (field.c_str ());
if (ttim_fld [i-1] < 0) ttim_fld [i-1] = ttime_fld;
}
while (route_header.Read ()) {
Show_Progress ();
route_rec.Clear ();
route_rec.Route (route_header.Get_Integer (route_fld));
if (route_rec.Route () == 0) continue;
//---- set the parking type ----
route_rec.Mode (Transit_Code (route_header.Get_String (mode_fld)));
route_rec.Name (route_header.Get_String (name_fld));
route_rec.Notes (route_header.Get_String (note_fld));
switch (route_rec.Mode ()) {
case LOCAL_BUS:
route_rec.Veh_Type (4);
break;
case EXPRESS_BUS:
route_rec.Veh_Type (5);
break;
case BRT:
route_rec.Veh_Type (6);
break;
case STREETCAR:
route_rec.Veh_Type (7);
break;
case LRT:
route_rec.Veh_Type (8);
break;
case RAPIDRAIL:
route_rec.Veh_Type (9);
break;
case REGIONRAIL:
route_rec.Veh_Type (10);
break;
}
if (veh_type_array.size () > 0) {
route_rec.Veh_Type (VehType40_Map (route_rec.Veh_Type (), 0));
if (route_rec.Veh_Type () > 0) {
Int_Map_Itr map_itr = veh_type_map.find (route_rec.Veh_Type ());
if (map_itr == veh_type_map.end ()) {
Warning (String ("Transit Vehicle Type %d was Not Found") % route_rec.Veh_Type ());
route_rec.Veh_Type (0);
} else {
route_rec.Veh_Type (map_itr->second);
}
} else {
route_rec.Veh_Type (0);
}
}
for (i=0; i < route_periods; i++) {
Route_Period period_rec;
period_rec.Headway (route_header.Get_Time (head_fld [i]));
period_rec.Offset (route_header.Get_Time (offset_fld [i]));
period_rec.TTime (route_header.Get_Integer (ttim_fld [i]));
route_rec.periods.push_back (period_rec);
}
map_stat = route_map.insert (Int_Map_Data (route_rec.Route (), (int) route_nodes_array.size ()));
if (!map_stat.second) {
Warning ("Duplicate Route Number = ") << route_rec.Route ();
} else {
route_nodes_array.push_back (route_rec);
}
}
End_Progress ();
Print (2, String ("Number of %s Records = %d") % route_header.File_Type () % Progress_Count ());
//---- process the route nodes file ----
Show_Message (String ("Reading %s -- Record") % route_nodes.File_Type ());
Set_Progress ();
route_fld = route_nodes.Required_Field ("ROUTE", "LINE");
node_fld = route_nodes.Required_Field ("NODE", "STOP");
dwell_fld = route_nodes.Optional_Field ("DWELL", "DWELL_TIME", "STOP_TIME", "STOPTIME");
time_fld = route_nodes.Optional_Field ("TIME", "TTIME", "RUNTIME", "RUN_TIME");
spd_fld = route_nodes.Optional_Field ("SPEED", "SPD", "RUNSPD", "RUN_SPD", "RUN_SPEED");
while (route_nodes.Read ()) {
Show_Progress ();
route = route_nodes.Get_Integer (route_fld);
map_itr = route_map.find (route);
if (map_itr == route_map.end ()) {
Warning (String ("Route Nodes Route %d was Not Found in the Route Header File") % route);
continue;
}
route_ptr = &route_nodes_array [map_itr->second];
Route_Node node_rec;
node = route_nodes.Get_Integer (node_fld);
if (node < 0) {
node_rec.Type (NO_STOP);
node = -node;
} else {
node_rec.Type (STOP);
}
map_itr = node_map.find (node);
if (map_itr == node_map.end ()) {
Warning (String ("Route %d Node %d was Not Found") % route % node);
continue;
}
node_rec.Node (map_itr->second);
node_rec.Dwell (Dtime (route_nodes.Get_Integer (dwell_fld), SECONDS));
node_rec.Time (Dtime (route_nodes.Get_Integer (time_fld), SECONDS));
node_rec.Speed (Internal_Units (route_nodes.Get_Double (spd_fld), MPS));
route_ptr->nodes.push_back (node_rec);
}
End_Progress ();
Print (2, String ("Number of %s Records = %d") % route_nodes.File_Type () % Progress_Count ());
}
bool Data_Service::Get_Event_Data (Event_File &file, Event_Data &event_rec)
{
int hhold, lvalue, link, dir, offset, dir_index;
hhold = file.Household ();
if (hhold < 1) return (false);
event_rec.Household (hhold);
event_rec.Person (file.Person ());
event_rec.Tour (MAX (file.Tour (), 1));
event_rec.Trip (file.Trip ());
event_rec.Event (file.Event ());
if (file.Version () <= 40) {
event_rec.Mode (Trip_Mode_Map (file.Mode ()));
} else {
event_rec.Mode (file.Mode ());
}
event_rec.Schedule (file.Schedule ());
event_rec.Actual (file.Actual ());
//---- check/convert the link number and direction ----
link = file.Link ();
if (link > 0) {
dir = file.Dir ();
offset = Round (file.Offset ());
Link_Data *link_ptr = Set_Link_Direction (file, link, dir, offset);
if (link_ptr == 0) return (false);
if (dir) {
dir_index = link_ptr->BA_Dir ();
} else {
dir_index = link_ptr->AB_Dir ();
}
if (dir_index < 0) {
Warning (String ("Event %d Link %d Direction %s was Not Found") % Progress_Count () %
link_ptr->Link () % ((dir) ? "BA" : "AB"));
}
event_rec.Dir_Index (dir_index);
event_rec.Offset (offset);
event_rec.Lane (file.Lane ());
}
lvalue = file.Route ();
if (lvalue > 0) {
if (System_File_Flag (TRANSIT_ROUTE)) {
Int_Map_Itr map_itr = line_map.find (lvalue);
if (map_itr == line_map.end ()) {
Warning (String ("Event %d Route %d was Not Found") % Progress_Count () % lvalue);
return (false);
}
event_rec.Route (map_itr->second);
} else {
event_rec.Route (lvalue);
}
}
return (true);
}
void ArcTraveler::Read_Traveler (void)
{
int id_field, veh_field, start_field, end_field, dist_field, ttime_field, speed_field;
int i, traveler, last_traveler, last_spd, last_time, time, nsaved, link, dir, lane, start_time;
double distance, ttime, offset, side, speed;
bool select_flag;
Link_Data *link_ptr;
Point_Data points;
Traveler_Data *data_ptr;
Show_Message ("Reading %s -- Record", traveler_file.File_Type ());
Set_Progress (10000);
select_flag = (travelers.Num_Ranges () > 0);
id_field = arcview_traveler.Field_Number ("TRAVELER");
veh_field = arcview_traveler.Field_Number ("VEHICLE");
start_field = arcview_traveler.Field_Number ("STARTTIME");
end_field = arcview_traveler.Field_Number ("ENDTIME");
dist_field = arcview_traveler.Field_Number ("DISTANCE");
ttime_field = arcview_traveler.Field_Number ("TTIME");
speed_field = arcview_traveler.Field_Number ("SPEED");
if (!traveler_data.Max_Records (MIN (traveler_file.Estimate_Records (), 100000))) goto mem_error;
//---- read and sort the traveler file ----
while (traveler_file.Read ()) {
Show_Progress ();
//---- check the traveler id ----
traveler = traveler_file.Traveler ();
if (select_flag && !travelers.In_Range (traveler)) continue;
//---- check the time ----
time = times.Step (traveler_file.Time ());
if (time_flag && !times.In_Range (time)) continue;
//---- check the location ----
link = traveler_file.Link ();
dir = traveler_file.Dir ();
offset = traveler_file.Offset ();
lane = traveler_file.Lane ();
if (link == 0 || lane == 0) continue;
if (subarea_flag) {
link_ptr = link_data.Get (link);
if (link_ptr == NULL) continue;
if (dir == 0) {
distance = offset;
} else {
distance = UnRound (link_ptr->Length ()) - offset;
}
Link_Shape (link_ptr, dir, &points, distance, 0.0, 0.0);
if (!In_Polygon (points [1]->x, points [1]->y, &select_subarea.points)) continue;
}
//---- save the data record ----
data_ptr = traveler_data.New_Record (true);
if (data_ptr == NULL) goto mem_error;
data_ptr->Traveler (traveler);
data_ptr->Time (time);
data_ptr->Vehicle (traveler_file.Vehicle ());
data_ptr->Link (link);
data_ptr->Dir (dir);
data_ptr->Offset (Round (offset));
data_ptr->Lane (lane);
data_ptr->Distance (Round (traveler_file.Distance ()));
data_ptr->Speed (Round (traveler_file.Speed ()));
if (!traveler_data.Add ()) goto mem_error;
}
End_Progress ();
Print (2, "Number of Traveler Records Read = %d", Progress_Count ());
traveler_file.Close ();
//---- output the selected travelers ----
Show_Message ("Writing %s -- Record", arcview_traveler.File_Type ());
Set_Progress (10000);
last_traveler = last_time = start_time = time = nsaved = 0;
last_spd = 1;
distance = ttime = 0.0;
for (data_ptr = traveler_data.First_Key (); ; data_ptr = traveler_data.Next_Key ()) {
Show_Progress ();
if (data_ptr != NULL) {
traveler = data_ptr->Traveler ();
time = data_ptr->Time ();
}
if (traveler != last_traveler || (last_spd > 0 && (time - last_time) > 1) || data_ptr == NULL) {
if (last_traveler > 0 && last_time > start_time) {
ttime = last_time - start_time;
speed = distance / ttime;
if (speed > 0.01) {
arcview_traveler.Put_Field (end_field, times.Format_Time (last_time));
arcview_traveler.Put_Field (dist_field, distance);
arcview_traveler.Put_Field (ttime_field, ttime);
arcview_traveler.Put_Field (speed_field, distance / ttime);
if (!arcview_traveler.Write_Record ()) {
Error ("Writing ArcView Traveler File");
}
nsaved++;
}
}
if (data_ptr == NULL) break;
last_traveler = traveler;
distance = 0;
arcview_traveler.Put_Field (id_field, traveler);
last_time = start_time = data_ptr->Time ();
last_spd = data_ptr->Speed ();
arcview_traveler.Put_Field (start_field, times.Format_Time (start_time));
arcview_traveler.points.Reset ();
}
if (data_ptr->Vehicle () > 0) {
arcview_traveler.Put_Field (veh_field, data_ptr->Vehicle ());
}
link = data_ptr->Link ();
dir = data_ptr->Dir ();
lane = data_ptr->Lane ();
offset = UnRound (data_ptr->Offset ());
distance += UnRound (data_ptr->Distance ());
last_time = time;
last_spd = data_ptr->Speed ();
link_ptr = link_data.Get (link);
side = (2 * lane - 1) * lane_width / 2.0;
if (dir == 1) offset = UnRound (link_ptr->Length ()) - offset;
Link_Shape (link_ptr, dir, &points, offset, 0.0, side);
for (i=1; i <= points.Num_Points (); i++) {
if (!arcview_traveler.points.Add (points [i])) goto mem_error;
}
}
End_Progress ();
arcview_traveler.Close ();
Print (1, "Number of Traveler Records Saved = %d", nsaved);
return;
mem_error:
Error ("Insufficient Memory for Traveler Data");
return;
}
