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 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); }
bool ConvertTrips::Get_Trip_Data (Trip_File &file, Trip_Data &data, int partition) { int hhold, mode; Person_Index person_index; Int_Map_Itr map_itr; Location_Data *loc_ptr; hhold = file.Household (); if (hhold > max_hh_in) max_hh_in = hhold; hhold_map.insert (Int_Map_Data (hhold, 1)); person_index.Household (hhold); person_index.Person (file.Person ()); person_map.insert (Person_Map_Data (person_index, 1)); if (select_households && !hhold_range.In_Range (hhold)) return (false); mode = file.Mode (); if (mode >= 0 && mode < MAX_MODE && !select_mode [mode]) return (false); if (select_purposes && !purpose_range.In_Range (file.Purpose ())) return (false); if (select_start_times && !start_range.In_Range (file.Start ())) return (false); if (select_end_times && !end_range.In_Range (file.End ())) return (false); if (select_org_zones) { map_itr = location_map.find (file.Origin ()); if (map_itr != location_map.end ()) { loc_ptr = &location_array [map_itr->second]; if (!org_zone_range.In_Range (loc_ptr->Zone ())) return (false); } } if (select_des_zones) { map_itr = location_map.find (file.Destination ()); if (map_itr != location_map.end ()) { loc_ptr = &location_array [map_itr->second]; if (!des_zone_range.In_Range (loc_ptr->Zone ())) return (false); } } trip_file->Copy_Fields (file); if (!trip_file->Write ()) { Error ("Writing Trip File"); } trip_copy++; data.Household (hhold); hhold = partition; //---- don't save the record ---- return (false); }
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_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 TransimsNet::Add_Node_Data (void) { int node, count; Db_Sort_Itr db_itr; Int_Map_Stat map_stat; Node_Data node_rec; //---- read the data file ---- Show_Message (String ("Adding %s -- Record") % node_data_file.File_Type ()); Set_Progress (); count = 0; for (db_itr = node_data_array.begin (); db_itr != node_data_array.end (); db_itr++) { Show_Progress (); node = db_itr->first; if (node_map.find (node) != node_map.end ()) continue; update_node_range.Add_Range (node, node); node_data_array.Read_Record (node); count++; node_data_file.Copy_Fields (node_data_array); node_rec.Clear (); node_rec.Node (node_data_file.Node ()); node_rec.X (node_data_file.X ()); node_rec.Y (node_data_file.Y ()); node_rec.Z (node_data_file.Z ()); node_rec.Subarea (node_data_file.Subarea ()); node_rec.Notes (node_data_file.Notes ()); map_stat = node_map.insert (Int_Map_Data (node_rec.Node (), (int) node_array.size ())); if (!map_stat.second) { Warning ("Duplicate Node Number = ") << node_rec.Node (); continue; } else { node_array.push_back (node_rec); } } End_Progress (); Print (2, String ("Number of %s Records Added = %d") % node_data_file.File_Type () % count); }
void RoutePrep::Transfer_Link (void) { int link_index, dir_index, length, best_len, best; double dx, dy, speed; Ints_Itr st1_itr, st2_itr; Int_Itr a_itr, b_itr; Node_Data *a_ptr, *b_ptr; Link_Data link_rec; Dir_Data dir_rec; if (station_nodes.size () < 2) return; link_rec.Use (Use_Code ("WALK")); link_rec.Type (WALKWAY); link_rec.Divided (1); link_rec.Name ("Transfer Link"); dir_rec.Lanes (1); dir_rec.Speed (Internal_Units (3.0, MPH)); dir_rec.Capacity (1000); speed = UnRound (dir_rec.Speed ()); for (st1_itr = station_nodes.begin (); st1_itr != station_nodes.end (); st1_itr++) { st2_itr = st1_itr + 1; if (st2_itr == station_nodes.end ()) break; for (a_itr = st1_itr->begin (); a_itr != st1_itr->end (); a_itr++) { a_ptr = &node_array [*a_itr]; best = -1; best_len = MAX_INTEGER; for (b_itr = st2_itr->begin (); b_itr != st2_itr->end (); b_itr++) { b_ptr = &node_array [*b_itr]; dx = a_ptr->X () - b_ptr->X (); dy = a_ptr->Y () - b_ptr->Y (); length = DTOI (sqrt (dx * dx + dy * dy)); if (length < best_len) { best = *b_itr; best_len = length; } } if (best < 0) continue; link_index = (int) link_array.size (); dir_index = (int) dir_array.size (); link_rec.Anode (*a_itr); link_rec.Bnode (best); link_rec.Length (best_len); dir_rec.Time0 (UnRound (best_len) / speed); link_rec.AB_Dir (dir_index); dir_rec.Link (link_index); dir_map.insert (Int_Map_Data (dir_rec.Link_Dir (), dir_index)); dir_array.push_back (dir_rec); link_rec.BA_Dir (++dir_index); dir_rec.Dir (1); dir_map.insert (Int_Map_Data (dir_rec.Link_Dir (), dir_index)); dir_array.push_back (dir_rec); link_rec.Link (new_link++); link_map.insert (Int_Map_Data (link_rec.Link (), link_index)); link_array.push_back (link_rec); } } }
bool Relocate::Get_Link_Data (Link_File &file, Link_Data &link_rec, Dir_Data &ab_rec, Dir_Data &ba_rec) { if (!Data_Service::Get_Link_Data (file, link_rec, ab_rec, ba_rec)) return (false); if (target_flag) { link_rec.Divided (2); ab_rec.Sign (2); ba_rec.Sign (2); Int_Map_Itr map_itr = link_map.find (link_rec.Link ()); if (map_itr != link_map.end ()) { Dir_Data *dir_ptr; Link_Data *link_ptr = &link_array [map_itr->second]; if (link_ptr->Anode () == link_rec.Anode () && link_ptr->Bnode () == link_rec.Bnode ()) { link_ptr->Divided (1); if (shape_flag) { Int_Map_Itr map_itr = target_shape_map.find (link_rec.Link ()); if (map_itr != target_shape_map.end ()) { link_ptr->Shape (map_itr->second); } } if (link_ptr->AB_Dir () >= 0) { dir_ptr = &dir_array [link_ptr->AB_Dir ()]; dir_ptr->Sign (1); } if (link_ptr->BA_Dir () >= 0) { dir_ptr = &dir_array [link_ptr->BA_Dir ()]; dir_ptr->Sign (1); } return (false); } else if (link_ptr->Anode () == link_rec.Anode () || link_ptr->Bnode () == link_rec.Bnode ()) { link_ptr->Divided (3); if (shape_flag) { Int_Map_Itr map_itr = target_shape_map.find (link_rec.Link ()); if (map_itr != target_shape_map.end ()) { link_ptr->Shape (map_itr->second); } } } if (link_rec.AB_Dir () >= 0) { link_rec.AB_Dir ((int) dir_array.size ()); target_dir_map.insert (Int_Map_Data (ab_rec.Link_Dir (), link_rec.AB_Dir ())); dir_array.push_back (ab_rec); } if (link_rec.BA_Dir () >= 0) { link_rec.BA_Dir ((int) dir_array.size ()); target_dir_map.insert (Int_Map_Data (ba_rec.Link_Dir (), link_rec.BA_Dir ())); dir_array.push_back (ba_rec); } target_link_map.insert (Int_Map_Data (link_rec.Link (), (int) link_array.size ())); link_array.push_back (link_rec); return (false); } } else { link_rec.Divided (0); ab_rec.Sign (0); ba_rec.Sign (0); } return (true); }
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 ()); }
void NetPrep::Split_Loops (void) { int num_splits = 0; int index, x1, y1, x2, y2, id, node; double dx, dy, len, length, dist; Node_Data node_rec, *node_ptr; Link_Itr link_itr; Link_Data link_rec; Dir_Data *dir_ptr, dir_rec; Shape_Data *shape_ptr, shape_rec; XYZ xyz; XYZ_Itr xyz_itr, mid_itr; Int_Map_Itr map_itr; Int_Map_Stat map_stat; Show_Message ("Splitting Large Loops -- Record"); Set_Progress (); for (id=0, link_itr = link_array.begin (); link_itr != link_array.end (); link_itr++, id++) { Show_Progress (); if (link_itr->Anode () != link_itr->Bnode ()) continue; //---- update the shape records ---- map_itr = shape_map.find (link_itr->Link ()); if (map_itr == shape_map.end ()) continue; shape_ptr = &shape_array [map_itr->second]; shape_rec.Clear (); shape_rec.Link (new_link); length = link_itr->Length () / 2.0; node_ptr = &node_array [link_itr->Anode ()]; x1 = node_ptr->X (); y1 = node_ptr->Y (); len = 0; //---- find the mid-point ---- for (xyz_itr = mid_itr = shape_ptr->begin (); ; xyz_itr++) { if (xyz_itr != shape_ptr->end ()) { x2 = xyz_itr->x; y2 = xyz_itr->y; } else { node_ptr = &node_array [link_itr->Bnode ()]; x2 = node_ptr->X (); y2 = node_ptr->Y (); } dx = x2 - x1; dy = y2 - y1; dist = sqrt (dx * dx + dy * dy); len += dist; if (len >= length || xyz_itr == shape_ptr->end ()) { mid_itr = xyz_itr; if (dist > 0) { node_rec.X (x1); node_rec.Y (y1); } else if (len == length) { node_rec.X (x2); node_rec.Y (y2); } else { dist = (len - length) / dist; node_rec.X ((int) (x1 + dist * dx + 0.5)); node_rec.Y ((int) (y1 + dist * dy + 0.5)); } break; } x1 = x2; y1 = y2; } if (mid_itr != shape_ptr->end ()) { shape_rec.assign (mid_itr, shape_ptr->end ()); shape_map.insert (Int_Map_Data (shape_rec.Link (), (int) shape_array.size ())); shape_array.push_back (shape_rec); shape_ptr->erase (mid_itr); } //---- add the new node ---- node_rec.Node (new_node); node_rec.Z (0); node_rec.Count (2); node = (int) node_array.size (); map_stat = node_map.insert (Int_Map_Data (new_node, node)); if (!map_stat.second) { Warning ("Duplicate Node Number = ") << new_node; } else { node_array.push_back (node_rec); } //---- split the link record ---- link_itr->Length (link_itr->Length () / 2); link_rec = *link_itr; link_itr->Bnode (node); link_rec.Link (new_link); link_rec.Anode (node); index = (int) link_array.size (); //---- get the ab link ---- if (link_itr->AB_Dir () >= 0) { dir_ptr = &dir_array [link_itr->AB_Dir ()]; dir_ptr->Time0 (dir_ptr->Time0 () / 2); dir_rec = *dir_ptr; dir_rec.Link (index); link_rec.AB_Dir ((int) dir_array.size ()); dir_array.push_back (dir_rec); } //---- get the ba link ---- if (link_itr->BA_Dir () >= 0) { dir_ptr = &dir_array [link_itr->BA_Dir ()]; dir_ptr->Time0 (dir_ptr->Time0 () / 2); dir_rec = *dir_ptr; dir_rec.Link (index); link_rec.BA_Dir ((int) dir_array.size ()); dir_array.push_back (dir_rec); } map_stat = link_map.insert (Int_Map_Data (link_rec.Link (), index)); if (!map_stat.second) { Warning ("Duplicate Link Number = ") << link_rec.Link (); } else { link_array.push_back (link_rec); link_itr = link_array.begin () + id; if (link_node_flag) { Link_Nodes rec; rec.link = link_rec.Link (); link_node_array.push_back (rec); } } new_node++; new_link++; num_splits++; } End_Progress (); Print (2, "Number of Large Loop Splits = ") << num_splits; }
void TransimsNet::Zone_Access (void) { int j, link, min_len, area_type, zone, zone_num, location, parking; bool ab_flag, dir_flag; Link_Itr link_itr; Node_Data *node_ptr; Location_Data loc_rec; Parking_Data park_rec; Int_Map_Stat map_stat; Int_Map_Itr map_itr; Park_Detail_Itr detail_itr; Parking_Nest park_nest; Zone_Itr zone_itr; Access_Data access_rec; naccess = (int) access_map.size (); naccess = (int) access_array.size (); if (naccess > 0) { Int_Map_Itr map_itr = --access_map.end (); naccess = ((map_itr->first / 10) + 1) * 10 - 1; } Show_Message (String ("Creating Zone Access Points -- Record")); Set_Progress (); for (link = 0, link_itr = link_array.begin (); link_itr != link_array.end (); link_itr++, link++) { Show_Progress (); if (link_itr->Type () != EXTERNAL) continue; area_type = link_itr->Area_Type (); loc_rec.Link (link); loc_rec.Setback (loc_setback); park_rec.Link (link); min_len = external_offset; if (link_itr->Length () < external_offset * 2) min_len = link_itr->Length () / 2; node_ptr = &node_array [link_itr->Anode ()]; zone = node_ptr->Node (); node_ptr = &node_array [link_itr->Bnode ()]; if (zone < node_ptr->Node ()) { ab_flag = true; } else { ab_flag = false; zone = node_ptr->Node (); } map_itr = zone_map.find (zone); if (map_itr == zone_map.end ()) { Warning (String ("External Link %d Zone %d is Out of Range") % link_itr->Link () % zone); zone_num = -1; } else { zone_num = map_itr->second; } park_rec.Type (BOUNDARY); park_rec.Notes ("External Station"); dir_flag = true; //---- insert activity locations ---- map_itr = zone_centroid.find (zone); if (map_itr == zone_centroid.end ()) { loc_rec.Location (++location_id); location = (int) location_array.size (); zone_centroid.insert (Int_Map_Data (zone, location)); if (ab_flag) { loc_rec.Dir (0); } else { loc_rec.Dir (1); } loc_rec.Offset (min_len); loc_rec.Notes ("External"); loc_rec.Zone (zone_num); //---- insert the location record ---- map_stat = location_map.insert (Int_Map_Data (location_id, location)); if (!map_stat.second) continue; location_array.push_back (loc_rec); } else { location = map_itr->second; } for (j=0; j < 2; j++) { if (j == 0) { if (dir_flag && link_itr->AB_Dir () < 0) continue; if (ab_flag) { park_rec.Offset (min_len); } else { park_rec.Offset (link_itr->Length () - min_len); } } else { if (dir_flag && link_itr->BA_Dir () < 0) continue; if (ab_flag) { park_rec.Offset (link_itr->Length () - min_len); } else { park_rec.Offset (min_len); } } //---- add a parking lot ---- park_rec.Parking (++parking_id); parking = (int) parking_array.size (); park_rec.Dir (j); map_stat = parking_map.insert (Int_Map_Data (parking_id, parking)); if (!map_stat.second) continue; if (details_flag) { park_rec.clear (); for (detail_itr = parking_details.begin (); detail_itr != parking_details.end (); detail_itr++) { if (detail_itr->Area_Type1 () <= area_type && area_type <= detail_itr->Area_Type2 ()) { park_nest.Start (detail_itr->Start ()); park_nest.End (detail_itr->End ()); park_nest.Use (detail_itr->Use ()); park_nest.Time_In (detail_itr->Time_In ()); park_nest.Time_Out (detail_itr->Time_Out ()); park_nest.Hourly (detail_itr->Hourly ()); park_nest.Daily (detail_itr->Daily ()); park_rec.push_back (park_nest); } } } parking_array.push_back (park_rec); //---- add the access link ---- access_rec.Link (++naccess); access_rec.From_Type (LOCATION_ID); access_rec.From_ID (location); access_rec.To_Type (PARKING_ID); access_rec.To_ID (parking); access_rec.Dir (2); access_rec.Time (10); access_rec.Cost (0); access_rec.Notes ("Zone Access"); access_map.insert (Int_Map_Data (access_rec.Link (), (int) access_array.size ())); access_array.push_back (access_rec); } } End_Progress (); }
void RiderSum::Group_Rider_Report (void) { int n, run, runs, num, length, tot_len, period, num_periods, routes, index, stop, to, link; int max_riders, max_board, max_alight, max_runs, total; double factor, max_fac, sum_time, tot_time, time; double vmt, vht, pmt, pht; Dtime low, high; String label; bool flag; Int_Set *group; Int_Set_Itr itr; Int_Map_Itr map_itr, to_itr; Line_Data *line_ptr; Stop_Data *stop_ptr; Line_Stop_Itr stop_itr, next_itr; Line_Run_Itr run_itr; Int_Map stop_index; Int2_Map link_index; Int2_Map_Itr map2_itr; Int2_Key int2_key; Int2_Map_Stat map2_stat; Int_Map_Stat map_stat; Stop_Group_Data data, *data_ptr, *link_ptr; Stop_Group_Itr data_itr; Show_Message ("Line Group Profile -- Record"); Set_Progress (); //---- print the report ---- Header_Number (GROUP_RIDERS); num_periods = sum_periods.Num_Periods (); if (num_periods == 0) num_periods = 1; num = (int) (line_map.size () * stop_map.size ()); if (!Break_Check (num + 5)) { Print (1); Group_Rider_Header (); } routes = 0; memset (&data, '\0', sizeof (data)); for (n = line_equiv.First_Group (); n > 0; n = line_equiv.Next_Group ()) { group = line_equiv.Group_List (n); if (group == 0) continue; label = line_equiv.Group_Label (n); //---- process each time period ---- for (period = 0; period < num_periods; period++) { //---- initialize stop data ---- stop_index.clear (); link_index.clear (); stop_group_array.clear (); routes = 0; vmt = vht = pmt = pht = 0.0; //---- process each line in the line group ---- for (itr = group->begin (); itr != group->end (); itr++) { map_itr = line_map.find (*itr); if (map_itr == line_map.end ()) continue; Show_Progress (); line_ptr = &line_array [map_itr->second]; //---- set the run flags ---- if (!Run_Selection (line_ptr)) continue; if (period_flag [period] == 0) continue; time = 0.0; total = length = 0; flag = false; sum_periods.Period_Range (period, low, high); for (stop_itr = line_ptr->begin (); stop_itr != line_ptr->end (); stop_itr++) { stop_ptr = &stop_array [stop_itr->Stop ()]; stop = stop_ptr->Stop (); map_itr = stop_index.find (stop); next_itr = stop_itr + 1; if (next_itr != line_ptr->end ()) { stop_ptr = &stop_array [next_itr->Stop ()]; to = stop_ptr->Stop (); } else { to = 0; } //---- create the link ---- int2_key = Int2_Key (stop, to); map2_itr = link_index.find (int2_key); if (map2_itr == link_index.end ()) { if (to == 0 && map_itr != stop_index.end ()) { link = map_itr->second; } else { link = (int) stop_group_array.size (); link_index.insert (Int2_Map_Data (int2_key, link)); data.stop = stop; data.to = to; stop_group_array.push_back (data); //---- check for a merge ---- if (to != 0) { to_itr = stop_index.find (to); if (to_itr != stop_index.end ()) { index = (int) stop_group_array.size (); int2_key = Int2_Key (to, 0); map2_stat = link_index.insert (Int2_Map_Data (int2_key, index)); if (map2_stat.second) { data.stop = to; data.to = 0; stop_group_array.push_back (data); } } } } } else { link = map2_itr->second; } link_ptr = &stop_group_array [link]; //---- crete the stop index ---- if (map_itr == stop_index.end ()) { map_stat = stop_index.insert (Int_Map_Data (stop, link)); index = link; } else { index = map_itr->second; } data_ptr = &stop_group_array [index]; if (next_itr != line_ptr->end ()) { length = next_itr->Length () - stop_itr->Length (); } else { length = 0; } sum_time = 0.0; num = runs = 0; for (run=0, run_itr = stop_itr->begin (); run_itr != stop_itr->end (); run_itr++, run++) { if (run_flag [run] == 0) continue; if (run_period [run] != period) continue; data_ptr->board += run_itr->Board (); data_ptr->alight += run_itr->Alight (); link_ptr->riders += run_itr->Load (); runs++; flag = true; if (next_itr != line_ptr->end ()) { link_ptr->runs++; time = next_itr->at (run).Schedule ().Seconds () - run_itr->Schedule ().Seconds (); sum_time += time; num++; vmt += length; vht += time; pmt += length * run_itr->Load (); pht += time * run_itr->Load (); } } if (runs == 0) continue; if (link_ptr->length == 0.0) { link_ptr->length = length; } if (num > 0) { time = sum_time / num; } else { time = 0; } if (link_ptr->time > 0) { link_ptr->time = (link_ptr->time + time) / 2.0; } else { link_ptr->time = time; } } if (flag) routes++; } //---- print the report ---- if (!Break_Check ((int) stop_index.size () + 15)) { Print (1); Group_Rider_Header (); } Print (1, "Group Time Period Routes Description"); Print (2, String ("%5d %12.12s %6d %s") % n % sum_periods.Range_Format (period) % routes % label); Print (2, " Stop Length TTime Alight Board Riders Runs LoadFac"); Print (1); tot_time = 0.0; max_alight = max_board = max_riders = max_runs = total = tot_len = 0; max_fac = 0.0; for (data_itr = stop_group_array.begin (); data_itr != stop_group_array.end (); data_itr++) { map_itr = stop_map.find (data_itr->stop); stop_ptr = &stop_array [map_itr->second]; if (data_itr->runs > 0) { factor = DTOI (data_itr->riders * 10.0 / data_itr->runs) / 10.0; } else { factor = 0.0; } Print (1, String ("%8d %7.0lf %7.0lf %8d %8d %8d %5d %8.1lf") % data_itr->stop % UnRound (data_itr->length) % data_itr->time % data_itr->alight % data_itr->board % data_itr->riders % data_itr->runs % factor); if (Notes_Name_Flag ()) { if (!stop_ptr->Name ().empty ()) { Print (0, String (" %s") % stop_ptr->Name ()); } if (!stop_ptr->Notes ().empty ()) { Print (0, " -- ") << stop_ptr->Notes (); } } if (data_itr->alight > max_alight) max_alight = data_itr->alight; if (data_itr->board > max_board) max_board = data_itr->board; if (data_itr->riders > max_riders) max_riders = data_itr->riders; if (data_itr->runs > max_runs) max_runs = data_itr->runs; if (factor > max_fac) max_fac = factor; tot_len += data_itr->length; tot_time += data_itr->time; total += data_itr->board; } if (max_runs == 0) continue; Print (2, String (" Maximum %8ld %8ld %8ld %5ld %8.1lf") % max_alight % max_board % max_riders % max_runs % max_fac); Print (2, "Total Boardings = ") << total; if (total == 0 || tot_time == 0) continue; factor = UnRound (tot_len); vmt = UnRound (vmt) / 5280.0; vht = vht / 3600.0; pmt = UnRound (pmt) / 5280.0; pht = pht / 3600.0; Print (1, String ("Route Length = %.1lf miles, %.1lf minutes Average Speed = %.1lf mph") % External_Units (factor, MILES) % (tot_time / 60.0) % External_Units ((factor / tot_time), MPH)); Print (1, String ("Vehicle Miles = %.1lf Vehicle Hours = %.1lf") % vmt % vht); Print (1, String ("Passenger Miles = %.1lf Passenger Hours = %.1lf") % pmt % pht); Print (1, String ("Passengers per Vehicle Mile = %.1lf Passengers per Vehicle Hour = %.1lf") % (pmt / vht) % (pht / vht)); vmt = pmt / total; vht = pht * 60.0 / total; Print (1, String ("Average Trip Length = %.1lf miles, %.1lf minutes") % vmt % vht); } } End_Progress (); Header_Number (0); }
bool Path_Builder::Best_Lane_Use (int index, Dtime time, double len_factor, Dtime &ttime, Dtime &delay, int &cost, int &group) { int i, num, tt, cst, imp, lanes, type, grp, use_type [2], costs [2], best [2]; Dtime ttimes [2], delays [2]; double factor; Dir_Data *dir_ptr; Lane_Use_Data *use_ptr; Int_Map_Stat map_stat; Lane_Use_Period *period_ptr; Link_Dir_Data *use_index; dir_ptr = &exe->dir_array [index]; if (path_param.delay_flag) { ttimes [0] = exe->perf_period_array.Travel_Time (index, time, len_factor, forward_flag); if (dir_ptr->Use_Index () >= 0) { ttimes [1] = exe->perf_period_array.Travel_Time (dir_ptr->Use_Index (), time, len_factor, forward_flag); } } if (ttimes [0] < 0 && ttimes [1] <= 0) return (false); if (ttimes [0] == 0) ttimes [0] = dir_ptr->Time0 (); if (ttimes [1] == 0) ttimes [1] = dir_ptr->Time0 (); ttime = ttimes [0]; delay = 0; cost = group = 0; //---- find the time period ---- index = dir_ptr->First_Lane_Use (); if (index < 0) return (true); for (period_ptr = &exe->use_period_array [index]; ; period_ptr = &exe->use_period_array [++index]) { if (period_ptr->Start () <= time && time < period_ptr->End ()) break; if (period_ptr->Periods () == 0) return (true); } //---- set the lane group data ---- best [0] = best [1] = 0; delays [0] = delays [1] = 0; costs [0] = costs [1] = 0; use_type [0] = (period_ptr->Lanes (0) == 0) ? PROHIBIT : APPLY; use_type [1] = (period_ptr->Lanes (1) == 0) ? PROHIBIT : APPLY; type = path_param.traveler_type; num = period_ptr->Records (); index = period_ptr->Index (); for (i=0; i < num; i++, index++) { use_index = &exe->use_period_index [index]; use_ptr = &exe->lane_use_array [use_index->Link ()]; grp = use_index->Dir (); if (use_type [grp] == PROHIBIT) continue; lanes = use_ptr->High_Lane () - use_ptr->Low_Lane () + 1; if (lanes >= period_ptr->Lanes (grp)) { if (path_param.veh_type < 0 || use_ptr->Min_Veh_Type () < 0 || (use_ptr->Min_Veh_Type () <= path_param.veh_type && path_param.veh_type <= use_ptr->Max_Veh_Type ())) { if (type == 0 || use_ptr->Min_Traveler () < 0 || (use_ptr->Min_Traveler () <= type && type <= use_ptr->Max_Traveler ())) { if (Use_Permission (use_ptr->Use (), path_param.use)) { if (use_ptr->Type () == APPLY) { cst = use_ptr->Toll (); tt = use_ptr->Min_Delay (); if (use_ptr->Max_Delay () > use_ptr->Min_Delay ()) { map_stat = lane_use_delay.insert (Int_Map_Data (use_index->Link_Dir (), 0)); if (map_stat.second) { map_stat.first->second = DTOI ((use_ptr->Max_Delay () - use_ptr->Min_Delay ()) * path_param.random.Probability ()); } tt += map_stat.first->second; } imp = Resolve (tt * path_param.value_time + cst * path_param.value_cost); if (imp < best [grp] || best [grp] == 0) { delays [grp] = tt; costs [grp] = cst; best [grp] = imp; } use_type [grp] = APPLY; } else if (use_ptr->Type () == PROHIBIT) { use_type [grp] = PROHIBIT; } else if (use_ptr->Type () == REQUIRE) { use_type [1-grp] = PROHIBIT; } continue; } } } if (use_ptr->Type () == LIMIT) { use_type [grp] = PROHIBIT; } } } //---- select the best lane group ---- if (use_type [0] == PROHIBIT && use_type [1] == PROHIBIT) return (false); if (use_type [0] == APPLY && use_type [1] == APPLY) { best [0] += Resolve (ttimes [0] * path_param.value_time); best [1] += Resolve (ttimes [1] * path_param.value_time); if (random_flag) { factor = 1.0 + path_param.random_imped * (path_param.random.Probability () - 0.5) / 100.0; best [1] = DTOI (best [1] * factor); } if (best [1] > 0 && best [0] > 0) { group = (best [1] < best [0]) ? 1 : 0; } else { group = 0; } } else if (use_type [0] == APPLY) { group = 0; } else { group = 1; } delay = delays [group]; cost = costs [group]; ttime = ttimes [group]; return ((ttime > 0)); }
void IntControl::Read_Signal (void) { int signal, node, num; String buffer; Strings nodes; Signal_Data signal_rec; Int_Map_Itr map_itr; Int_Map_Stat map_stat; Int_Set_Stat set_stat; Str_Itr str_itr; Int_Itr node_itr; Node_Data *node_ptr; //---- store the signal data ---- Show_Message (String ("Reading %s -- Record") % signal_file.File_Type ()); Set_Progress (); num_new = num_update = 0; while (signal_file.Read (false)) { Show_Progress (); //---- check the signal number ---- signal = signal_file.Signal (); if (signal == 0) continue; map_itr = signal_map.find (signal); if (map_itr != signal_map.end ()) { if (update_flag) { set_stat = update_signal.insert (signal); if (!set_stat.second) { Warning ("Duplicate Signal Number = ") << signal; } num_update++; nsignal++; } else { Warning (String ("Signal %d Already Exists") % signal); } goto read_nest; } //---- gather the warrant signal data ---- signal_rec.Clear (); signal_rec.Signal (signal); signal_rec.Group (signal_file.Group ()); buffer = signal_file.Nodes (); if (buffer.empty ()) goto read_nest; num = buffer.Parse (nodes, "|+/"); if (num == 0) goto read_nest; signal_rec.nodes.reserve (num); for (str_itr = nodes.begin (); str_itr != nodes.end (); str_itr++) { node = str_itr->Integer (); if (node <= 0) break; map_itr = node_map.find (node); if (map_itr == node_map.end ()) { Warning (String ("Signal %d Node %d was Not Found") % signal_rec.Signal () % node); continue; } node_ptr = &node_array [map_itr->second]; if (node_ptr->Control () >= 0 && signal_file.Version () > 40) { Warning (String ("Node %d is assigned to multiple signals") % node); continue; } else if (node_ptr->Control () < -1) { Warning (String ("Node %d has a Sign/Signal control conflict") % node); continue; } signal_rec.nodes.push_back (map_itr->second); } if (signal_rec.nodes.size () == 0) goto read_nest; //---- insert the signal warrant ---- num = (int) signal_array.size (); map_stat = signal_map.insert (Int_Map_Data (signal, num)); if (!map_stat.second) { Warning ("Duplicate Signal Number = ") << signal_rec.Signal (); goto read_nest; } //---- set the node controls ---- for (node_itr = signal_rec.nodes.begin (); node_itr != signal_rec.nodes.end (); node_itr++) { node_ptr = &node_array [*node_itr]; node_ptr->Control (num); } signal_array.push_back (signal_rec); num_new++; nsignal++; read_nest: for (num = signal_file.Times (); num > 0; num--) { if (!signal_file.Read (true)) { Error (String ("Number of Time Records for Signal %d") % signal); } Show_Progress (); } } End_Progress (); signal_file.Close (); Print (2, String ("Number of %s Records = %d") % signal_file.File_Type () % Progress_Count ()); if (num_new > 0) { Print (1, "Number of New Signal Records = ") << num_new; } if (num_update > 0) { Print (1, "Number of Signal Updates = ") << num_update; } }
void LinkSum::Zone_Summary (void) { int i, j, z, count, link, nrec, nzone, index, flow_index; double factor, vmt, vht, flow; Dtime time; Link_Data *link_ptr; Link_Perf_Period_Itr period_itr; Flow_Time_Data flow_data; Link_Loc_Map_Itr loc_itr, first_itr; Doubles dbl; Doubles_Itr itr; Int_Map_Itr map_itr; Show_Message ("Summarize Activity Locations on Links -- Record"); Set_Progress (); link = count = nrec = 0; link_ptr = 0; for (loc_itr = first_itr = link_location.begin (); loc_itr != link_location.end (); loc_itr++) { Show_Progress (); if (loc_itr->second.link == link) { count++; } else { if (link > 0) { link_ptr = &link_array [link]; if (!select_flag || link_ptr->Use () != 0) { first_itr->second.count = count; } } first_itr = loc_itr; link = loc_itr->second.link; count = 1; } } Set_Progress (); //---- set the count data for all records ---- link = 0; for (loc_itr = link_location.begin (); loc_itr != link_location.end (); loc_itr++) { Show_Progress (); if (loc_itr->second.link == link) { loc_itr->second.count = count; } else { link = loc_itr->second.link; count = loc_itr->second.count; } if (count > 0) { nrec += count; zone_list.insert (Int_Map_Data (loc_itr->second.zone, (int) zone_list.size ())); } } nzone = (int) zone_list.size (); Break_Check (4); Print (2, "Number of Link Locations = ") << nrec; Print (1, "Number of Selected Zones = ") << nzone; //---- allocate space for zone summaries ---- zone_vmt.assign (num_inc, dbl); zone_vht.assign (num_inc, dbl); for (itr = zone_vmt.begin (); itr != zone_vmt.end (); itr++) { itr->assign (nzone, 0.0); } for (itr = zone_vht.begin (); itr != zone_vht.end (); itr++) { itr->assign (nzone, 0.0); } //---- summarizes link data by zone ---- link = 0; for (loc_itr = link_location.begin (); loc_itr != link_location.end (); loc_itr++) { Show_Progress (); if (loc_itr->second.count == 0) continue; if (loc_itr->second.link != link) { link = loc_itr->second.link; link_ptr = &link_array [link]; } map_itr = zone_list.find (loc_itr->second.zone); if (map_itr == zone_list.end ()) continue; z = map_itr->second; factor = UnRound (link_ptr->Length ()) / loc_itr->second.count; //---- process each direction ---- for (i=0; i < 2; i++) { if (i) { if (link_ptr->Use () == -1) continue; index = link_ptr->BA_Dir (); } else { if (link_ptr->Use () == -2) continue; index = link_ptr->AB_Dir (); } if (index < 0) continue; flow_index = dir_array [index].Flow_Index (); for (j=0, period_itr = link_perf_array.begin (); period_itr != link_perf_array.end (); period_itr++, j++) { flow_data = period_itr->Total_Flow_Time (index, flow_index); flow = flow_data.Flow (); time = flow_data.Time (); if (flow > 0) { vmt = flow * factor; vht = flow * time / loc_itr->second.count; zone_vmt [j] [z] += vmt; zone_vht [j] [z] += vht; } } } } End_Progress (); }
void TransitDiff::Read_Line (void) { int i, num, route; bool keep_flag; Int_Map_Stat map_stat; Int_Map_Itr map_itr; Line_Data line_rec; //---- store the route data ---- Show_Message (String ("Reading %s -- Record") % compare_line_file.File_Type ()); Set_Progress (); while (compare_line_file.Read (false)) { Show_Progress (); line_rec.Clear (); keep_flag = true; route = compare_line_file.Route (); if (route == 0) keep_flag = false; line_rec.Route (route); if (compare_line_file.Stops () < 2) keep_flag = false; line_rec.Mode (compare_line_file.Mode ()); line_rec.Type (compare_line_file.Type ()); line_rec.Name (compare_line_file.Name ()); map_itr = veh_type_map.find (line_rec.Type ()); if (map_itr == veh_type_map.end ()) { Warning (String ("Transit Route %d Vehicle Type %d was Not Found") % route % line_rec.Type ()); } else { line_rec.Type (map_itr->second); } num = compare_line_file.Num_Nest (); if (num > 0) line_rec.reserve (num); for (i=1; i <= num; i++) { if (!compare_line_file.Read (true)) { Error (String ("Number of Stop Records for Route %d") % compare_line_file.Route ()); } Show_Progress (); //---- process a stop record ---- int zone, stop; Line_Stop line_stop; Int_Map_Itr itr; stop = compare_line_file.Stop (); itr = compare_stop_map.find (stop); if (itr == compare_stop_map.end ()) { Warning (String ("Transit Stop %d on Route %d was Not Found") % stop % route); continue; } line_stop.Stop (itr->second); zone = compare_line_file.Zone (); line_stop.Zone (zone); line_stop.Time_Flag ((compare_line_file.Time_Flag () > 0)); line_rec.push_back (line_stop); } if (keep_flag) { map_stat = compare_line_map.insert (Int_Map_Data (line_rec.Route (), (int) compare_line_array.size ())); if (!map_stat.second) { Warning ("Duplicate Route Number = ") << line_rec.Route (); } else { compare_line_array.push_back (line_rec); } } } End_Progress (); compare_line_file.Close (); Print (2, String ("Number of %s Records = %d") % compare_line_file.File_Type () % Progress_Count ()); num = (int) compare_line_array.size (); if (num && num != Progress_Count ()) { Print (1, String ("Number of %s Data Records = %d") % compare_line_file.File_ID () % num); } }
void RiderSum::Write_Group_Rider (void) { int n, run, runs, num, length, period, num_periods, routes, index, stop, to, link, capacity; double factor, sum_time, time, capfac; Dtime low, high; String label; bool flag; Int_Set *group; Int_Set_Itr itr; Int_Map_Itr map_itr, to_itr; Line_Data *line_ptr; Stop_Data *stop_ptr; Line_Stop_Itr stop_itr, next_itr; Line_Run_Itr run_itr; Int_Map stop_index; Int2_Map link_index; Int2_Map_Itr map2_itr; Int2_Key int2_key; Int2_Map_Stat map2_stat; Int_Map_Stat map_stat; Stop_Group_Data data, *data_ptr, *link_ptr; Stop_Group_Itr data_itr; Veh_Type_Data *veh_type_ptr, *run_type_ptr; fstream &file = line_group_file.File (); num_periods = sum_periods.Num_Periods (); if (num_periods == 0) num_periods = 1; Show_Message (String ("Writing % -- Record") % line_group_file.File_Type ()); Set_Progress (); file << "Group\tPeriod\tRoutes\tStops\tDescription\n"; file << "Stop\tLength\tTTime\tAlight\tBoard\tRiders\tRuns\tLoadFac\tCapacity\tCapFac\tStopName\n"; //---- process each line group ---- routes = 0; memset (&data, '\0', sizeof (data)); for (n = line_equiv.First_Group (); n > 0; n = line_equiv.Next_Group ()) { group = line_equiv.Group_List (n); if (group == 0) continue; label = line_equiv.Group_Label (n); //---- process each time period ---- for (period = 0; period < num_periods; period++) { //---- initialize stop data ---- stop_index.clear (); link_index.clear (); stop_group_array.clear (); routes = 0; //---- process each line in the line group ---- for (itr = group->begin (); itr != group->end (); itr++) { map_itr = line_map.find (*itr); if (map_itr == line_map.end ()) continue; Show_Progress (); line_ptr = &line_array [map_itr->second]; //---- set the run flags ---- if (!Run_Selection (line_ptr)) continue; //---- check the period flag ---- if (period_flag [period] == 0) continue; time = 0.0; length = 0; flag = false; veh_type_ptr = &veh_type_array [line_ptr->Type ()]; sum_periods.Period_Range (period, low, high); for (stop_itr = line_ptr->begin (); stop_itr != line_ptr->end (); stop_itr++) { stop_ptr = &stop_array [stop_itr->Stop ()]; stop = stop_ptr->Stop (); map_itr = stop_index.find (stop); next_itr = stop_itr + 1; if (next_itr != line_ptr->end ()) { stop_ptr = &stop_array [next_itr->Stop ()]; to = stop_ptr->Stop (); } else { to = 0; } //---- create the link ---- int2_key = Int2_Key (stop, to); map2_itr = link_index.find (int2_key); if (map2_itr == link_index.end ()) { if (to == 0 && map_itr != stop_index.end ()) { link = map_itr->second; } else { link = (int) stop_group_array.size (); link_index.insert (Int2_Map_Data (int2_key, link)); data.stop = stop; data.to = to; stop_group_array.push_back (data); //---- check for a merge ---- if (to != 0) { to_itr = stop_index.find (to); if (to_itr != stop_index.end ()) { index = (int) stop_group_array.size (); int2_key = Int2_Key (to, 0); map2_stat = link_index.insert (Int2_Map_Data (int2_key, index)); if (map2_stat.second) { data.stop = to; data.to = 0; stop_group_array.push_back (data); } } } } } else { link = map2_itr->second; } link_ptr = &stop_group_array [link]; //---- crete the stop index ---- if (map_itr == stop_index.end ()) { map_stat = stop_index.insert (Int_Map_Data (stop, link)); index = link; } else { index = map_itr->second; } data_ptr = &stop_group_array [index]; if (next_itr != line_ptr->end ()) { length = next_itr->Length () - stop_itr->Length (); } else { length = 0; } sum_time = 0.0; num = runs = 0; for (run=0, run_itr = stop_itr->begin (); run_itr != stop_itr->end (); run_itr++, run++) { if (run_flag [run] == 0) continue; if (run_period [run] != period) continue; data_ptr->board += run_itr->Board (); data_ptr->alight += run_itr->Alight (); link_ptr->riders += run_itr->Load (); runs++; flag = true; if (next_itr != line_ptr->end ()) { if (line_ptr->run_types.size () > 0) { run_type_ptr = &veh_type_array [line_ptr->Run_Type (run)]; capacity = run_type_ptr->Capacity (); } else { capacity = veh_type_ptr->Capacity (); } link_ptr->runs++; link_ptr->capacity += capacity; time = next_itr->at (run).Schedule ().Seconds () - run_itr->Schedule ().Seconds (); sum_time += time; num++; } } if (runs == 0) continue; if (link_ptr->length == 0.0) { link_ptr->length = length; } if (num > 0) { time = sum_time / num; } else { time = 0; } if (link_ptr->time > 0) { link_ptr->time = (link_ptr->time + time) / 2.0; } else { link_ptr->time = time; } } if (flag) routes++; } file << n << "\t" << sum_periods.Range_Format (period) << "\t" << routes << "\t" << stop_index.size () << "\t" << label << "\n"; for (data_itr = stop_group_array.begin (); data_itr != stop_group_array.end (); data_itr++) { map_itr = stop_map.find (data_itr->stop); stop_ptr = &stop_array [map_itr->second]; if (data_itr->runs > 0) { factor = DTOI (data_itr->riders * 10.0 / data_itr->runs) / 10.0; } else { factor = 0; } if (data_itr->capacity > 0) { capfac = DTOI (data_itr->riders * 10.0 / data_itr->capacity) / 10.0; } else { capfac = 0; } file << data_itr->stop << "\t" << UnRound (data_itr->length) << "\t" << data_itr->time << "\t" << data_itr->alight << "\t" << data_itr->board << "\t" << data_itr->riders << "\t" << data_itr->runs << "\t" << factor << "\t" << data_itr->capacity << "\t" << capfac << "\t"; if (Notes_Name_Flag ()) { file << stop_ptr->Name (); if (!stop_ptr->Notes ().empty ()) { file << " -- " << stop_ptr->Notes (); } } file << "\n"; } } } End_Progress (); line_group_file.Close (); }
void Data_Service::Read_Veh_Types (Veh_Type_File &file) { int num, cell_size; double length, min_len; Veh_Type_Data veh_type_rec; Int_Map_Stat map_stat; Veh_Type_Itr veh_type_itr; //---- store the vehicle type data ---- Show_Message (String ("Reading %s -- Record") % file.File_Type ()); Set_Progress (); Initialize_Veh_Types (file); while (file.Read ()) { Show_Progress (); veh_type_rec.Clear (); if (Get_Veh_Type_Data (file, veh_type_rec)) { map_stat = veh_type_map.insert (Int_Map_Data (veh_type_rec.Type (), (int) veh_type_array.size ())); if (!map_stat.second) { Warning ("Duplicate Vehicle Type Number = ") << veh_type_rec.Type (); continue; } else { veh_type_array.push_back (veh_type_rec); } } } End_Progress (); file.Close (); Print (2, String ("Number of %s Records = %d") % file.File_Type () % Progress_Count ()); num = (int) veh_type_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 (VEHICLE_TYPE); //---- set the PCE factor ---- num = Use_Code ("CAR"); length = 0.0; min_len = MAX_INTEGER; for (veh_type_itr = veh_type_array.begin (); veh_type_itr != veh_type_array.end (); veh_type_itr++) { if ((veh_type_itr->Use () & num) != 0) { length = veh_type_itr->Length (); break; } if (veh_type_itr->Length () < min_len) min_len = veh_type_itr->Length (); } if (length <= 0.0) length = min_len; if (length <= 0.0) return; cell_size = DTOI (min_len); for (veh_type_itr = veh_type_array.begin (); veh_type_itr != veh_type_array.end (); veh_type_itr++) { veh_type_itr->PCE (Round (veh_type_itr->Length () / length)); veh_type_itr->Cells (MAX (((veh_type_itr->Length () + cell_size / 2) / cell_size), 1)); } }
void ExportNet::New_Links (void) { int i, node, link, new_link, count, length, index, park_len, speed, time, dir; double offset, len, factor; Int_Map_Itr map_itr; Link_Data link_data, link_rec; Split_Itr split_itr, split2_itr; Link_Split_Itr link_itr; Points points; Dir_Data dir_ab, dir_ba, dir_rec; Shape_Data shape_rec; Points_Itr pt_itr; XYZ xyz; park_len = Round (Internal_Units (20, METERS)); speed = Round (Internal_Units (5, MPS)); time = Round (Internal_Units (20/5, SECONDS)); map_itr = --link_map.end (); link = map_itr->first; new_link = ((link + 1) / 100 + 1) * 100; count = 0; //---- split links ---- Set_Progress (); for (link=0, link_itr = link_splits.begin (); link_itr != link_splits.end (); link_itr++, link++) { if (link_itr->size () == 0) continue; Show_Progress (); link_data = link_array [link]; if (link_data.AB_Dir () >= 0) { dir_ab = dir_array [link_data.AB_Dir ()]; } if (link_data.BA_Dir () >= 0) { dir_ba = dir_array [link_data.BA_Dir ()]; } offset = 0.0; for (split_itr = split2_itr = link_itr->begin (); split_itr != link_itr->end (); split2_itr = split_itr++) { link_rec = link_data; link_rec.Name (link_data.Name ()); index = (int) link_array.size (); link_rec.Divided (3); split_itr->link = index; link_rec.Link (new_link++); if ((split_itr + 1) != link_itr->end ()) { link_rec.Bnode (split_itr->node); length = split_itr->offset; link_rec.Boffset (0); } else { length = link_rec.Length (); } if (split_itr != split2_itr) { link_rec.Anode (split2_itr->node); length -= split2_itr->offset; link_rec.Aoffset (0); offset = UnRound (split2_itr->offset); } len = UnRound (length); link_rec.Length (length); factor = (double) length / link_data.Length (); //---- split the link shape ---- if (link_data.Shape () >= 0) { Link_Shape (&link_data, 0, points, offset, len); if (points.size () > 2) { shape_rec.Clear (); shape_rec.Link (link_rec.Link ()); for (pt_itr = points.begin () + 1; pt_itr != points.end (); pt_itr++) { xyz.x = Round (pt_itr->x); xyz.y = Round (pt_itr->y); xyz.z = Round (pt_itr->z); shape_rec.push_back (xyz); } link_rec.Shape ((int) shape_array.size ()); shape_map.insert (Int_Map_Data (shape_rec.Link (), link_rec.Shape ())); shape_array.push_back (shape_rec); } else { link_rec.Shape (-1); } } //---- process each direction ---- if (link_data.AB_Dir () >= 0) { dir_rec = dir_ab; dir_rec.Link (index); dir_rec.First_Connect_From (-1); dir_rec.First_Connect_To (-1); if ((split_itr + 1) != link_itr->end ()) { dir_rec.First_Pocket (-1); } dir_rec.Time0 ((int) (dir_rec.Time0 () * factor + 0.5)); dir = (int) dir_array.size (); link_rec.AB_Dir (dir); dir_map.insert (Int_Map_Data (dir_rec.Link_Dir (), dir)); dir_array.push_back (dir_rec); } else { link_rec.AB_Dir (-1); } if (link_data.BA_Dir () >= 0) { dir_rec = dir_ba; dir_rec.Link (index); dir_rec.First_Connect_From (-1); dir_rec.First_Connect_To (-1); if (split_itr != split2_itr) { dir_rec.First_Pocket (-1); } dir_rec.Time0 ((int) (dir_rec.Time0 () * factor + 0.5)); dir = (int) dir_array.size (); link_rec.BA_Dir (dir); dir_map.insert (Int_Map_Data (dir_rec.Link_Dir (), dir)); dir_array.push_back (dir_rec); } else { link_rec.BA_Dir (-1); } //---- insert the link ---- link_map.insert (Int_Map_Data (link_rec.Link (), index)); link_array.push_back (link_rec); count++; } } //---- add parking connection links ---- Set_Progress (); for (link=0, link_itr = link_splits.begin (); link_itr != link_splits.end (); link_itr++, link++) { if (link_itr->size () == 0) continue; Show_Progress (); for (split_itr = split2_itr = link_itr->begin (); split_itr != link_itr->end (); split2_itr = split_itr++) { for (i=0; i < 2; i++) { index = (int) link_array.size (); if (i == 0) { node = split_itr->park_ab; if (node < 0) continue; split_itr->link_ab = index; } else { node = split_itr->park_ba; if (node < 0) continue; split_itr->link_ba = index; } link_rec.Clear (); link_rec.Divided (3); link_rec.Link (new_link++); link_rec.Anode (split_itr->node); link_rec.Bnode (node); link_rec.Length (park_len); link_rec.Use (ANY); link_rec.Type (LOCAL); link_rec.Name ("Parking"); //---- insert directional data ---- dir_rec.Clear (); dir_rec.Link (index); dir_rec.Dir (0); dir_rec.Lanes (1); dir_rec.Speed (speed); dir_rec.Capacity (300); dir_rec.Time0 (time); dir_rec.Sign (YIELD_SIGN); dir = (int) dir_array.size (); link_rec.AB_Dir (dir); dir_map.insert (Int_Map_Data (dir_rec.Link_Dir (), dir)); dir_array.push_back (dir_rec); dir_rec.Dir (1); dir_rec.Sign (NO_CONTROL); dir = (int) dir_array.size (); link_rec.BA_Dir (dir); dir_map.insert (Int_Map_Data (dir_rec.Link_Dir (), dir)); dir_array.push_back (dir_rec); //---- insert the link ---- link_map.insert (Int_Map_Data (link_rec.Link (), index)); link_array.push_back (link_rec); count++; } } } Print (2, "Number of New Link Records = ") << count; }