int Data_Service::Put_Skim_Data (Skim_File &file, Skim_Record &data)
{
file.Origin (data.Origin ());
file.Destination (data.Destination ());
file.Period (data.Period ());
file.Count (data.Count ());
if (file.Data_Type () == TIME_TABLE || file.Total_Time_Flag ()) {
file.Time (Dtime (data.Time ()).Round_Seconds ());
} else {
file.Walk (Dtime (data.Walk ()).Round_Seconds ());
file.Drive (Dtime (data.Drive ()).Round_Seconds ());
file.Transit (Dtime (data.Transit ()).Round_Seconds ());
file.Wait (Dtime (data.Wait ()).Round_Seconds ());
file.Other (Dtime (data.Other ()).Round_Seconds ());
}
file.Length (UnRound (data.Length ()));
file.Cost (UnRound (data.Cost ()));
file.Impedance (data.Impedance ());
if (!file.Write ()) {
Error (String ("Writing %s") % file.File_Type ());
}
return (1);
}
bool SideFriction::Lane_Use_Processing (Db_File *fh)
{
Lane_Use_Data *lane_use_ptr;
Lane_Use_File *file = (Lane_Use_File *) fh;
if (Network_Service::Lane_Use_Processing (file)) {
new_file->Copy_Fields (file);
lane_use_ptr = lane_use_data.New_Record ();
new_file->Link (lane_use_ptr->Link ());
new_file->Dir (lane_use_ptr->Dir ());
new_file->Lane (lane_use_ptr->Lane ());
new_file->Use (Use_Code (lane_use_ptr->Use ()));
new_file->Type (Restrict_Code ((Restrict_Type) lane_use_ptr->Type ()));
new_file->Start (time_step.Format_Step (Resolve (lane_use_ptr->Start ())));
new_file->End (time_step.Format_Step (Resolve (lane_use_ptr->End ())));
new_file->Offset (UnRound (lane_use_ptr->Offset ()));
new_file->Length (UnRound (lane_use_ptr->Length ()));
if (!new_file->Write ()) {
Error ("Writing %s", new_file->File_Type ());
}
num_use++;
return (true);
}
return (false);
}
bool ArcDelay::Performance_Processing (Db_File *fh)
{
//---- check the subarea polygon ----
if (subarea_flag) {
Delay_File *file = (Delay_File *) fh;
if (!file->Nest ()) {
int link;
Node_Data *node_ptr;
Link_Data *link_ptr;
link = file->Link ();
if (link < 0) link = -link;
link_ptr = link_data.Get (link);
if (link_ptr == NULL) return (false);
node_ptr = node_data.Get (link_ptr->Anode ());
if (!In_Polygon (UnRound (node_ptr->X ()), UnRound (node_ptr->Y ()), &select_subarea.points)) {
node_ptr = node_data.Get (link_ptr->Bnode ());
if (!In_Polygon (UnRound (node_ptr->X ()), UnRound (node_ptr->Y ()), &select_subarea.points)) {
return (false);
}
}
}
}
return (Demand_Service::Performance_Processing (fh));
}
bool ArcPlan::Get_Location_Data (Location_File &file, Location_Data &location_rec)
{
int link, dir, index;
double offset, setback, side;
Point_Map_Stat map_stat;
Link_Data *link_ptr;
if (Data_Service::Get_Location_Data (file, location_rec)) {
link = location_rec.Link ();
dir = location_rec.Dir ();
offset = UnRound (location_rec.Offset ());
setback = UnRound (location_rec.Setback ());
side = location_side;
if (setback > side) side = setback;
link_ptr = &link_array [link];
if (lanes_flag) {
bool dir_flag;
int center, num_lanes;
Dir_Data *dir_ptr;
if (dir == 0) {
index = link_ptr->AB_Dir ();
dir_flag = (link_ptr->BA_Dir () >= 0);
} else {
index = link_ptr->BA_Dir ();
dir_flag = (link_ptr->AB_Dir () >= 0);
}
if (index >= 0) {
dir_ptr = &dir_array [index];
num_lanes = dir_ptr->Lanes () + dir_ptr->Left () + dir_ptr->Right ();
} else {
num_lanes = 0;
}
if (center_flag && !dir_flag) {
center = num_lanes + 1;
} else {
center = 1;
}
side += (2 * num_lanes - center) * lane_width / 2.0;
}
Link_Shape (link_ptr, dir, points, offset, 0.0, side);
//---- save the location point data ----
map_stat = location_pt.insert (Point_Map_Data (location_rec.Location (), points [0]));
if (!map_stat.second) {
Warning ("Duplicate Location Record = ") << location_rec.Location ();
}
return (true);
}
return (false);
}
int Data_Service::Put_Node_Data (Node_File &file, Node_Data &data)
{
file.Node (data.Node ());
file.X (UnRound (data.X ()));
file.Y (UnRound (data.Y ()));
file.Z (UnRound (data.Z ()));
file.Subarea (data.Subarea ());
file.Partition (data.Partition ());
file.Notes (data.Notes ());
if (!file.Write ()) {
Error (String ("Writing %s") % file.File_Type ());
}
return (1);
}
bool ArcNet::Parking_Processing (Db_File *fh)
{
int link, dir;
double offset;
XYZ_Point *pt_ptr;
Offset_Data offset_rec;
Link_Data *link_ptr;
Parking_Data *parking_ptr;
Parking_File *file = (Parking_File *) fh;
if (First_Record ()) {
arcview_parking.Num_Points (1);
if (!parking_offset.Max_Records (file->Num_Records ())) {
Error ("Insufficient Memory for Parking Points");
}
}
if (Network_Service::Parking_Processing (file)) {
arcview_parking.Copy_Fields (file);
parking_ptr = parking_data.New_Record ();
if (select_time) {
if (!time_range.Span_Range (parking_ptr->Start (), parking_ptr->End ())) return (false);
}
link = parking_ptr->Link ();
dir = parking_ptr->Dir ();
offset = UnRound (parking_ptr->Offset ());
link_ptr = link_data.Get (link);
Link_Shape (link_ptr, dir, &points, offset, 0.0, parking_side);
pt_ptr = points [1];
arcview_parking.points.Set (1, pt_ptr);
if (!arcview_parking.Write_Record ()) {
Error ("Writing ArcView Parking File");
}
//---- save the parking offset data ----
offset_rec.ID (parking_ptr->ID ());
offset_rec.Link (link);
offset_rec.Dir (dir);
offset_rec.Offset (offset);
offset_rec.X (pt_ptr->x);
offset_rec.Y (pt_ptr->y);
offset_rec.Z (pt_ptr->z);
if (!parking_offset.Add (&offset_rec)) {
Error ("Saving Parking Offsets");
}
}
return (false);
}
string Dtime::Time_Label (bool pad_flag)
{
if (!pad_flag) return (Time_Label ());
int hour, minute, seconds, min_time, hour_time;
double time;
String text;
Units_Type time_format = Time_Format ();
time = UnRound (DTOI (dtime));
min_time = 60;
hour_time = min_time * 60;
if (time > 3 * MIDNIGHT) {
time = 3 * MIDNIGHT;
}
if (time_format == HOURS) {
text ("%09.6lf") % (time / hour_time);
} else if (time_format == SECONDS) {
text ("%05d") % time;
} else {
seconds = DTOI (time);
hour = seconds / hour_time;
seconds -= hour * hour_time;
minute = seconds / min_time;
seconds -= minute * min_time;
text ("%02d%02d%02d") % hour % minute % seconds;
}
return (text);
}
string Dtime::Time_Label (Units_Type time_format)
{
int hour, minute, seconds, min_time, hour_time;
double time;
String text;
if (time_format == NO_UNITS) time_format = Time_Format ();
time = UnRound (DTOI (dtime));
min_time = 60;
hour_time = min_time * 60;
if (time > 3 * MIDNIGHT) {
time = 3 * MIDNIGHT;
}
if (time_format == HOURS) {
text (time / hour_time);
} else if (time_format == SECONDS) {
text (time);
} else {
seconds = DTOI (time);
hour = seconds / hour_time;
seconds -= hour * hour_time;
minute = seconds / min_time;
seconds -= minute * min_time;
if (seconds > 0) {
text ("%d%02d%02d") % hour % minute % seconds;
} else {
text ("%d%02d") % hour % minute;
}
}
return (text);
}
int Data_Service::Put_Connect_Data (Connect_File &file, Connect_Data &data)
{
Dir_Data *dir_ptr;
Link_Data *link_ptr;
dir_ptr = &dir_array [data.Dir_Index ()];
link_ptr = &link_array [dir_ptr->Link ()];
file.Link (link_ptr->Link ());
file.Dir (dir_ptr->Dir ());
file.Lanes (Make_Lane_Range (dir_ptr, data.Low_Lane (), data.High_Lane ()));
dir_ptr = &dir_array [data.To_Index ()];
link_ptr = &link_array [dir_ptr->Link ()];
file.To_Link (link_ptr->Link ());
file.To_Lanes (Make_Lane_Range (dir_ptr, data.To_Low_Lane (), data.To_High_Lane ()));
file.Type (data.Type ());
file.Penalty (data.Penalty ());
file.Speed (UnRound (data.Speed ()));
file.Capacity (data.Capacity ());
file.Notes (data.Notes ());
if (!file.Write ()) {
Error (String ("Writing %s") % file.File_Type ());
}
return (1);
}
void ArcSnapshot::Set_Subarea (void)
{
Link_Itr link_itr;
Node_Data *node_ptr;
for (link_itr = link_array.begin (); link_itr != link_array.end (); link_itr++) {
node_ptr = &node_array [link_itr->Anode ()];
if (!In_Polygon (subarea_file, UnRound (node_ptr->X ()), UnRound (node_ptr->Y ()))) {
node_ptr = &node_array [link_itr->Bnode ()];
if (!In_Polygon (subarea_file, UnRound (node_ptr->X ()), UnRound (node_ptr->Y ()))) {
link_itr->Use (0);
}
}
}
}
bool ArcNet::Location_Processing (Db_File *fh)
{
int link, dir;
double offset;
XYZ_Point *pt_ptr;
Offset_Data offset_rec;
Link_Data *link_ptr;
Location_Data *location_ptr;
Location_File *file = (Location_File *) fh;
if (First_Record ()) {
arcview_location.Num_Points (1);
if (!location_offset.Max_Records (file->Num_Records ())) {
Error ("Insufficient Memory for Location Points");
}
}
if (Network_Service::Location_Processing (file)) {
arcview_location.Copy_Fields (file);
location_ptr = location_data.New_Record ();
link = location_ptr->Link ();
dir = location_ptr->Dir ();
offset = UnRound (location_ptr->Offset ());
link_ptr = link_data.Get (link);
Link_Shape (link_ptr, dir, &points, offset, 0.0, location_side);
pt_ptr = points [1];
arcview_location.points.Set (1, pt_ptr);
if (!arcview_location.Write_Record ()) {
Error ("Writing ArcView Activity Location File");
}
//---- save the location offset data ----
offset_rec.ID (location_ptr->ID ());
offset_rec.Link (link);
offset_rec.Dir (dir);
offset_rec.Offset (offset);
offset_rec.X (pt_ptr->x);
offset_rec.Y (pt_ptr->y);
offset_rec.Z (pt_ptr->z);
if (!location_offset.Add (&offset_rec)) {
Error ("Saving Activity Location Offsets");
}
}
return (false);
}
bool ArcPlan::Get_Parking_Data (Parking_File &file, Parking_Data &parking_rec)
{
int link, dir, index;
double offset, side;
Point_Map_Stat map_stat;
Link_Data *link_ptr;
if (Data_Service::Get_Parking_Data (file, parking_rec)) {
if (!file.Nested ()) {
link = parking_rec.Link ();
dir = parking_rec.Dir ();
offset = UnRound (parking_rec.Offset ());
side = parking_side;
link_ptr = &link_array [link];
if (lanes_flag) {
bool dir_flag;
int center, num_lanes;
Dir_Data *dir_ptr;
if (dir == 0) {
index = link_ptr->AB_Dir ();
dir_flag = (link_ptr->BA_Dir () >= 0);
} else {
index = link_ptr->BA_Dir ();
dir_flag = (link_ptr->AB_Dir () >= 0);
}
if (index >= 0) {
dir_ptr = &dir_array [index];
num_lanes = dir_ptr->Lanes () + dir_ptr->Left () + dir_ptr->Right ();
} else {
num_lanes = 0;
}
if (center_flag && !dir_flag) {
center = num_lanes + 1;
} else {
center = 1;
}
side += (2 * num_lanes - center) * lane_width / 2.0;
}
Link_Shape (link_ptr, dir, points, offset, 0.0, side);
//---- save the parking point data ----
map_stat = parking_pt.insert (Point_Map_Data (parking_rec.Parking (), points [0]));
if (!map_stat.second && file.Version () > 40) {
Warning ("Duplicate Parking Record = ") << parking_rec.Parking ();
}
}
return (true);
}
return (false);
}
void VISSIMNet::Write_Zone (void)
{
int node;
Link_Name *link_ptr;
Location_Data *location_ptr;
Access_Data *access_ptr;
fprintf (file, "\n<ZONES>");
for (location_ptr = location_data.First_Key (); location_ptr; location_ptr = location_data.Next_Key ()) {
fprintf (file, "\n<ZONE NO=\"%d\" XCOORD=\"%.2lf\" YCOORD=\"%.2lf\" >",
location_ptr->Location (), UnRound (location_ptr->X ()), UnRound (location_ptr->Y ()));
//---- find the attrach node ----
link_ptr = link_data.Get (location_ptr->Link ());
if (location_ptr->Offset () > link_ptr->Length () / 2) {
node = link_ptr->Bnode ();
} else {
node = link_ptr->Anode ();
}
//---- process links ----
fprintf (file, "\n<CONNECTORS>");
for (access_ptr = access_data.First (); access_ptr; access_ptr = access_data.Next ()) {
if (access_ptr->From_Type () == LOCATION_ID && access_ptr->From_ID () == location_ptr->Location ()) {
fprintf (file, "\n<CONNECTOR NODENO=\"%d\" DIRECTION=\"false\" />", node);
}
if (access_ptr->To_Type () == LOCATION_ID && access_ptr->To_ID () == location_ptr->Location ()) {
fprintf (file, "\n<CONNECTOR NODENO=\"%d\" DIRECTION=\"true\" />", node);
}
}
fprintf (file, "\n</CONNECTORS>");
fprintf (file, "\n</ZONE>");
}
fprintf (file, "\n</ZONES>");
}
bool SideFriction::Stop_Processing (Db_File *fh)
{
int link, dir;
double offset;
XYZ_Point *pt_ptr;
Offset_Data offset_rec;
Link_Data *link_ptr;
Stop_Data *stop_ptr;
Stop_File *file = (Stop_File *) fh;
if (First_Record () && subarea_flag) {
if (!stop_offset.Max_Records (file->Num_Records ())) {
Error ("Insufficient Memory for Transit Stop Points");
}
}
if (Network_Service::Stop_Processing (file)) {
if (subarea_flag) {
stop_ptr = stop_data.New_Record ();
link = stop_ptr->Link ();
dir = stop_ptr->Dir ();
offset = UnRound (stop_ptr->Offset ());
link_ptr = link_data.Get (link);
Link_Shape (link_ptr, dir, &points, offset, 0.0, 2.0);
pt_ptr = points [1];
//---- save the stop offset data ----
offset_rec.ID (stop_ptr->ID ());
offset_rec.Link (link);
offset_rec.Dir (dir);
offset_rec.Offset (offset);
offset_rec.X (pt_ptr->x);
offset_rec.Y (pt_ptr->y);
offset_rec.Z (pt_ptr->z);
if (!stop_offset.Add (&offset_rec)) {
Error ("Saving Transit Stop Offsets");
}
}
return (true);
}
return (false);
}
bool SubareaNet::Node_Processing (Db_File *fh)
{
Node_File *file = (Node_File *) fh;
//---- reserve memory ----
if (First_Record ()) {
if (!node_db.Max_Records (file->Num_Records ())) {
Error ("Insufficient Memory for Node Database");
}
}
//---- do standard processing ----
if (Network_Service::Node_Processing (fh)) {
//---- copy the record to the node database ----
node_db.Copy_Fields (file);
if (!node_db.Add_Record ()) {
Error ("Writing Node Database");
}
//---- check the subarea boundary ----
Node_Data *node_ptr = node_data.New_Record ();
if (In_Polygon (UnRound (node_ptr->X ()), UnRound (node_ptr->Y ()), &subarea_boundary.points)) {
node_ptr->Type (1);
} else {
node_ptr->Type (0);
}
return (true);
}
return (false);
}
bool TransimsNet::Zone_Processing (Db_File *fh)
{
if (Network_Service::Zone_Processing (fh)) {
if (zout_flag) {
Zone_File *file = (Zone_File *) fh;
Zone_File *new_file = (Zone_File *) Network_Db_File (NEW_ZONE);
new_file->Copy_Fields (file);
if (Projection_Flag ()) {
Zone_Data *zone_ptr = zone_data.New_Record ();
new_file->X (UnRound (zone_ptr->X ()));
new_file->Y (UnRound (zone_ptr->Y ()));
}
if (!new_file->Write ()) {
Error ("Writing Zone Number %d", new_file->Zone ());
}
nzout++;
}
return (true);
}
return (false);
}
int Data_Service::Put_Parking_Data (Parking_File &file, Parking_Data &data)
{
Park_Nest_Itr nest_itr;
Link_Data *link_ptr;
int count = 0;
link_ptr = &link_array [data.Link ()];
file.Parking (data.Parking ());
file.Link (link_ptr->Link ());
file.Dir (data.Dir ());
file.Offset (UnRound (data.Offset ()));
file.Type (data.Type ());
file.Num_Nest ((int) data.size ());
file.Notes (data.Notes ());
if (!file.Write (false)) {
Error (String ("Writing %s") % file.File_Type ());
}
count++;
for (nest_itr = data.begin (); nest_itr != data.end (); nest_itr++) {
file.Use (nest_itr->Use ());
file.Start (nest_itr->Start ());
file.End (nest_itr->End ());
file.Space (nest_itr->Space ());
file.Time_In (nest_itr->Time_In ());
file.Time_Out (nest_itr->Time_Out ());
file.Hourly (nest_itr->Hourly ());
file.Daily (nest_itr->Daily ());
if (!file.Write (true)) {
Error (String ("Writing %s") % file.File_Type ());
}
count++;
}
return (count);
}
void ArcNet::Route_Nodes (void)
{
int i, n, node, node0, route, nroutes, overlap, dir, route_field;
double offset, length, side, side_offset;
bool offset_flag, first;
AB_Data *ab_ptr;
Dir_Data *dir_ptr;
Node_Data *node_ptr;
Link_Data *link_ptr;
Route_Data *route_ptr;
XYZ_Point point;
offset_flag = (route_offset != 0.0);
side = 0.0;
//---- set the overlap count ----
if (!overlap_flag) {
for (link_ptr = link_data.First (); link_ptr; link_ptr = link_data.Next ()) {
link_ptr->Aoffset (0);
link_ptr->Boffset (0);
}
}
//---- write the route file ----
Show_Message ("Writing Transit Routes -- Record");
Set_Progress (100);
nroutes = 0;
route_field = route_header_db.Required_Field ("ROUTE", "LINE");
route_header_db.Rewind ();
while (route_header_db.Read_Record ()) {
Show_Progress ();
arcview_route.points.Reset ();
arcview_route.Copy_Fields (&route_header_db);
route_header_db.Get_Field (route_field, &route);
route_ptr = route_data.Get (route);
if (route_ptr == NULL) continue;
//---- create the path vector ---
node0 = 0;
first = true;
for (n=1; n <= route_ptr->Nodes (); n++) {
node = route_ptr->Node (n);
if (node0 == 0) {
node0 = node;
continue;
}
ab_ptr = ab_key.Get (abs(node0), abs(node));
if (ab_ptr == NULL) {
Warning ("No Link between Nodes %d and %d on Route %d", node0, node, route);
node0 = node;
node_ptr = node_data.Get (abs (node0));
if (node_ptr != NULL) {
point.x = UnRound (node_ptr->X ());
point.y = UnRound (node_ptr->Y ());
point.z = UnRound (node_ptr->Z ());
if (!arcview_route.points.Add (&point)) {
Error ("Insufficient Memory for Route Node Shape Points");
}
}
continue;
}
dir_ptr = dir_data [ab_ptr->dir];
dir = dir_ptr->Dir ();
node0 = node;
link_ptr = link_data.Get (dir_ptr->Link ());
offset = length = UnRound (link_ptr->Length ());
side_offset = route_offset;
if (side_offset > length / 3.0) {
side_offset = length / 3.0;
}
if (offset_flag) {
if (!overlap_flag) {
if (dir == 0) {
overlap = link_ptr->Aoffset () + 1;
link_ptr->Aoffset (overlap);
} else {
overlap = link_ptr->Boffset () + 1;
link_ptr->Boffset (overlap);
}
side = side_offset = route_offset * overlap;
if (side_offset > length / 3.0) {
side_offset = length / 3.0;
}
offset -= side_offset;
length -= 2.0 * side_offset;
} else {
offset -= side_offset;
length -= 2.0 * side_offset;
if (link_ptr->AB_Dir () > 0 && link_ptr->BA_Dir () > 0) {
side = side_offset;
} else {
side = 0.0;
}
}
i = 1;
} else if (first) {
i = 1;
first = false;
} else {
i = 2;
}
if (dir == 0) {
Link_Shape (link_ptr, 0, &points, side_offset, length, side);
} else {
Link_Shape (link_ptr, 1, &points, offset, length, side);
}
for (; i <= points.Num_Points (); i++) {
if (!arcview_route.points.Add (points [i])) {
Error ("Insufficient Memory for Route Node Shape Points");
}
}
}
if (!arcview_route.Write_Record ()) {
Error ("Writing ArcView Route Node File");
}
nroutes++;
}
End_Progress ();
Print (2, "Number of Transit Routes = %d", nroutes);
arcview_route.Close ();
}
void LinkSum::Perf_Detail_Report (void)
{
int i, j, k, k1, lanes, max_lanes, tod_list, index, flow_index;
double base_time, loaded_time, length, len, base, diff, value, percent, flow, factor;
Dtime low, high, tod;
bool connect_flag;
String units, vmt, lane_mi;
Link_Itr link_itr;
Dir_Data *dir_ptr;
Link_Perf_Period_Itr period_itr;
Link_Perf_Array *period_ptr;
Link_Perf_Data perf_data;
Flow_Time_Period_Itr turn_itr;
Flow_Time_Array *compare_ptr;
Flow_Time_Data *turn_ptr;
Lane_Use_Period *use_ptr;
Connect_Data *connect_ptr;
Doubles_Itr itr;
Show_Message ("Creating the Network Performance Details Report -- Record");
Set_Progress ();
//---- clear the summary bins -----
for (j=0, itr = sum_bin.begin (); itr != sum_bin.end (); itr++, j++) {
itr->assign (NUM_SUM_BINS, 0.0);
}
connect_flag = System_Data_Flag (CONNECTION) && (turn_perf_array.size () > 0) && (compare_turn_array.size () > 0);
//---- process each link ----
for (link_itr = link_array.begin (); link_itr != link_array.end (); link_itr++) {
Show_Progress ();
if (select_flag && link_itr->Use () == 0) continue;
length = UnRound (link_itr->Length ());
len = 0;
for (i=0; i < 2; i++) {
if (i) {
if (link_itr->Use () == -1) continue;
index = link_itr->BA_Dir ();
} else {
if (link_itr->Use () == -2) continue;
index = link_itr->AB_Dir ();
}
if (index < 0) continue;
dir_ptr = &dir_array [index];
flow_index = dir_ptr->Flow_Index ();
base_time = dir_ptr->Time0 ();
if (base_time <= 0.0) continue;
tod_list = dir_ptr->First_Lane_Use ();
max_lanes = dir_ptr->Lanes ();
if (max_lanes < 1) max_lanes = 1;
lanes = max_lanes;
if (len == 0) {
len = length;
} else {
len = 0;
}
//---- process each time period ----
for (j=0, period_itr = link_perf_array.begin (); period_itr != link_perf_array.end (); period_itr++, j++) {
if (tod_list >= 0) {
//---- get the time period ----
sum_periods.Period_Range (j, low, high);
tod = (low + high + 1) / 2;
lanes = max_lanes;
k = tod_list;
for (use_ptr = &use_period_array [k]; ; use_ptr = &use_period_array [++k]) {
if (use_ptr->Start () <= tod && tod < use_ptr->End ()) {
lanes = use_ptr->Lanes0 () + use_ptr->Lanes1 ();
break;
}
if (use_ptr->Periods () == 0) break;
}
}
perf_data = period_itr->Total_Link_Perf (index, flow_index);
loaded_time = perf_data.Time ();
flow = perf_data.Flow ();
sum_bin [j] [LINKS] += 1;
sum_bin [j] [LENGTH] += len;
sum_bin [j] [LANES] += lanes * length;
sum_bin [j] [VMT] += flow * length;
sum_bin [j] [VHT] += flow * loaded_time;
sum_bin [j] [VHD] += flow * (loaded_time - base_time);
sum_bin [j] [TIME_RATIO] += (double) loaded_time / base_time;
sum_bin [j] [DENSITY] += perf_data.Density ();
sum_bin [j] [MAX_DEN] = MAX (sum_bin [j] [MAX_DEN], perf_data.Max_Density ());
sum_bin [j] [QUEUE] += perf_data.Queue ();
sum_bin [j] [MAX_QUEUE] = MAX (sum_bin [j] [MAX_QUEUE], perf_data.Max_Queue ());
sum_bin [j] [FAILURE] += perf_data.Failure ();
if (Ratio_Flag ()) {
sum_bin [j] [CONG_VMT] += perf_data.Ratio_VMT ();
sum_bin [j] [CONG_VHT] += perf_data.Ratio_VHT ();
sum_bin [j] [CONG_TIME] += perf_data.Ratio_Count ();
sum_bin [j] [COUNT] += perf_data.Occupancy ();
}
if (compare_flag) {
period_ptr = &compare_link_array [j];
perf_data = period_ptr->Total_Link_Perf (index, flow_index);
loaded_time = perf_data.Time ();
flow = perf_data.Flow ();
sum_bin [j] [VMT+PREV] += flow * length;
sum_bin [j] [VHT+PREV] += flow * loaded_time;
sum_bin [j] [VHD+PREV] += flow * (loaded_time - base_time);
sum_bin [j] [TIME_RATIO+PREV] += (double) loaded_time / base_time;
sum_bin [j] [DENSITY+PREV] += perf_data.Density ();
sum_bin [j] [MAX_DEN+PREV] = MAX (sum_bin [j] [MAX_DEN+PREV], perf_data.Max_Density ());
sum_bin [j] [QUEUE+PREV] += perf_data.Queue ();
sum_bin [j] [MAX_QUEUE+PREV] = MAX (sum_bin [j] [MAX_QUEUE+PREV], perf_data.Max_Queue ());
sum_bin [j] [FAILURE+PREV] += perf_data.Failure ();
if (Ratio_Flag ()) {
sum_bin [j] [CONG_VMT+PREV] += perf_data.Ratio_VMT ();
sum_bin [j] [CONG_VHT+PREV] += perf_data.Ratio_VHT ();
sum_bin [j] [CONG_TIME+PREV] += perf_data.Ratio_Count ();
sum_bin [j] [COUNT+PREV] += perf_data.Occupancy ();
}
}
}
//---- get the turning movements ----
if (connect_flag) {
for (k=dir_ptr->First_Connect (); k >= 0; k = connect_ptr->Next_Index ()) {
connect_ptr = &connect_array [k];
if (connect_ptr->Type () != LEFT && connect_ptr->Type () != RIGHT &&
connect_ptr->Type () != UTURN) continue;
for (j=0, turn_itr = turn_perf_array.begin (); turn_itr != turn_perf_array.end (); turn_itr++, j++) {
turn_ptr = &turn_itr->at (k);
sum_bin [j] [TURNS] += turn_ptr->Flow ();
if (compare_flag) {
compare_ptr = &compare_turn_array [j];
turn_ptr = &compare_ptr->at (k);
sum_bin [j] [TURNS+PREV] += turn_ptr->Flow ();
}
}
}
}
}
}
End_Progress ();
//---- print the report ----
Header_Number (PERF_DETAIL);
if (!Break_Check (num_inc * 16)) {
Print (1);
Perf_Detail_Header ();
}
if (Metric_Flag ()) {
factor = 1.0 / 1000.0;
units = "Kilometers";
vmt = "VKT";
lane_mi = "km";
} else {
factor = 1.0 / MILETOFEET;
units = "Miles";
vmt = "VMT";
lane_mi = "mi";
}
tod.Hours (1);
for (i=0; i <= num_inc; i++) {
len = sum_bin [i] [LINKS];
if (len == 0.0) continue;
if (i < num_inc) {
for (k = 0; k <= COUNT; k++) {
k1 = k + PREV;
if (k < VMT) {
sum_bin [num_inc] [k] = MAX (sum_bin [i] [k], sum_bin [num_inc] [k]);
if (compare_flag) {
sum_bin [num_inc] [k1] = MAX (sum_bin [i] [k1], sum_bin [num_inc] [k1]);
}
} else {
sum_bin [num_inc] [k] += sum_bin [i] [k];
if (compare_flag) {
sum_bin [num_inc] [k1] += sum_bin [i] [k1];
}
}
}
}
if (i < num_inc && sum_bin [i] [VHT] == 0.0 && (!compare_flag || sum_bin [i] [VHT+PREV] == 0.0)) continue;
if (i) {
if (!Break_Check ((Ratio_Flag () ? 19 : 16))) {
Print (1);
}
}
Print (1, String ("Time Period%22c") % BLANK);
if (i == num_inc) {
Print (0, " Total");
len *= num_inc;
} else {
Print (0, String ("%12.12s") % sum_periods.Range_Format (i));
}
Print (1, String ("Number of Links %13.2lf") % sum_bin [i] [LINKS]);
Print (1, String ("Number of Roadway %-10.10s %13.2lf") % units % (sum_bin [i] [LENGTH] * factor));
Print (1, String ("Number of Lane %-10.10s %13.2lf") % units % (sum_bin [i] [LANES] * factor));
Print (1, String ("Vehicle %-20.20s %13.2lf") % (units + " of Travel") % (sum_bin [i] [VMT] * factor));
if (compare_flag) {
base = sum_bin [i] [VMT+PREV] * factor;
diff = sum_bin [i] [VMT] * factor - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
Print (1, String ("Vehicle Hours of Travel %13.2lf") % (sum_bin [i] [VHT] / tod));
if (compare_flag) {
base = sum_bin [i] [VHT+PREV] / tod;
diff = sum_bin [i] [VHT] / tod - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
Print (1, String ("Vehicle Hours of Delay %13.2lf") % (sum_bin [i] [VHD] / tod));
if (compare_flag) {
base = sum_bin [i] [VHD+PREV] / tod;
diff = sum_bin [i] [VHD] / tod - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
Print (1, String ("Number of Queued Vehicles %13.2lf") % UnRound (sum_bin [i] [QUEUE]));
if (compare_flag) {
base = sum_bin [i] [QUEUE+PREV];
diff = sum_bin [i] [QUEUE] - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
Print (1, String ("Maximum Queued Vehicles %13.2lf") % sum_bin [i] [MAX_QUEUE]);
if (compare_flag) {
base = sum_bin [i] [MAX_QUEUE+PREV];
diff = sum_bin [i] [MAX_QUEUE] - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
Print (1, String ("Number of Cycle Failures %13.2lf") % sum_bin [i] [FAILURE]);
if (compare_flag) {
base = sum_bin [i] [FAILURE+PREV];
diff = sum_bin [i] [FAILURE] - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
Print (1, String ("Number of Turning Movements %13.2lf") % sum_bin [i] [TURNS]);
if (compare_flag) {
base = sum_bin [i] [TURNS+PREV];
diff = sum_bin [i] [TURNS] - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
Print (1, String ("Average Link Time Ratio %13.2lf") % (sum_bin [i] [TIME_RATIO] / len));
if (compare_flag) {
base = sum_bin [i] [TIME_RATIO+PREV] / len;
diff = sum_bin [i] [TIME_RATIO] / len - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
Print (1, String ("Average Link Density (/ln-%s) %13.2lf") % lane_mi % UnRound (sum_bin [i] [DENSITY] / len));
if (compare_flag) {
base = UnRound (sum_bin [i] [DENSITY+PREV] / len);
diff = UnRound (sum_bin [i] [DENSITY] / len) - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
Print (1, String ("Maximum Link Density (/ln-%s) %13.2lf") % lane_mi % UnRound (sum_bin [i] [MAX_DEN]));
if (compare_flag) {
base = UnRound (sum_bin [i] [MAX_DEN+PREV]);
diff = UnRound (sum_bin [i] [MAX_DEN]) - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
length = sum_bin [i] [VMT] * factor;
loaded_time = sum_bin [i] [VHT] / tod;
if (loaded_time == 0.0) {
loaded_time = length;
} else {
loaded_time = length / loaded_time;
}
Print (1, String ("Average %-19.19s %13.2lf") % (units + " per Hour") % loaded_time);
if (compare_flag) {
length = sum_bin [i] [VMT+PREV] * factor;
base = sum_bin [i] [VHT+PREV] / tod;
if (base == 0.0) {
base = length;
} else {
base = length / base;
}
diff = loaded_time - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
if (Ratio_Flag ()) {
value = sum_bin [i] [VMT];
if (value == 0.0) value = 1.0;
percent = 100.0 * sum_bin [i] [CONG_VMT] / value;
Print (1, String ("Percent %s Congested %13.2lf") % vmt % percent);
if (compare_flag) {
value = sum_bin [i] [VMT+PREV];
if (value == 0.0) value = 1.0;
base = 100.0 * sum_bin [i] [CONG_VMT+PREV] / value;
diff = percent - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
value = sum_bin [i] [VHT];
if (value == 0.0) value = 1.0;
percent = 100.0 * sum_bin [i] [CONG_VHT] / value;
Print (1, String ("Percent VHT Congested %13.2lf") % percent);
if (compare_flag) {
value = sum_bin [i] [VHT+PREV];
if (value == 0.0) value = 1.0;
base = 100.0 * sum_bin [i] [CONG_VHT+PREV] / value;
diff = percent - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
value = sum_bin [i] [COUNT];
if (value == 0.0) value = 1.0;
percent = 100.0 * sum_bin [i] [CONG_TIME] / value;
Print (1, String ("Percent Time Congested %13.2lf") % percent);
if (compare_flag) {
value = sum_bin [i] [COUNT+PREV];
if (value == 0.0) value = 1.0;
base = 100.0 * sum_bin [i] [CONG_TIME+PREV] / value;
diff = percent - base;
Print (0, String (" %13.2lf %13.2lf (%.2lf%%)") % base % diff % ((base > 0.0) ? (100.0 * diff / base) : 0.0) % FINISH);
}
}
}
Header_Number (0);
}
void RiderSum::Line_Rider_Report (void)
{
int riders, board, alight, run, runs, num, length, tot_len, period, num_periods;
int max_riders, max_board, max_alight, max_runs, total, capacity, max_cap;
double factor, max_fac, sum_time, tot_time, time, capfac, max_capfac;
double vmt, vht, pmt, pht;
Dtime low, high;
Int_Map_Itr map_itr;
Line_Data *line_ptr;
Stop_Data *stop_ptr;
Line_Stop_Itr stop_itr, next_itr;
Line_Run_Itr run_itr;
Veh_Type_Data *veh_type_ptr, *run_type_ptr;
Show_Message ("Line Rider Profile -- Record");
Set_Progress ();
//---- print the report ----
Header_Number (LINE_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);
Line_Rider_Header ();
}
//---- process each route ----
for (map_itr = line_map.begin (); map_itr != line_map.end (); map_itr++) {
Show_Progress ();
if (select_routes && !route_range.In_Range (map_itr->first)) continue;
line_ptr = &line_array [map_itr->second];
if (select_modes && !select_mode [line_ptr->Mode ()]) continue;
//---- check the link criteria ----
if (!Link_Selection (line_ptr)) continue;
//---- set the run flags ----
if (!Run_Selection (line_ptr)) continue;
//---- save the route ridership data ----
veh_type_ptr = &veh_type_array [line_ptr->Type ()];
for (period = 0; period < num_periods; period++) {
if (period_flag [period] == 0) continue;
if (!Break_Check ((int) line_ptr->size () + 15)) {
Print (1);
Line_Rider_Header ();
}
veh_type_ptr = &veh_type_array [line_ptr->Type ()];
Print (1, " Route Mode Type Time Period Name");
Print (2, String ("%8d %10.10s %4d %12.12s") % line_ptr->Route () %
Transit_Code ((Transit_Type) line_ptr->Mode ()) % veh_type_ptr->Type () %
sum_periods.Range_Format (period));
if (!line_ptr->Name ().empty ()) {
Print (0, String (" %s") % line_ptr->Name ());
}
if (Notes_Name_Flag ()) {
if (!line_ptr->Notes ().empty ()) {
Print (0, String (" -- %s") % line_ptr->Notes ());
}
}
Print (2, " Stop Length TTime Alight Board Riders Runs LoadFac Capacity CapFac");
Print (1);
time = tot_time = 0.0;
max_alight = max_board = max_riders = max_runs = total = length = tot_len = max_cap = 0;
max_fac = vmt = vht = pmt = pht = max_capfac = 0.0;
sum_periods.Period_Range (period, low, high);
for (stop_itr = line_ptr->begin (); stop_itr != line_ptr->end (); stop_itr++) {
riders = board = alight = runs = capacity = 0;
stop_ptr = &stop_array [stop_itr->Stop ()];
next_itr = stop_itr + 1;
if (next_itr != line_ptr->end ()) {
length = next_itr->Length () - stop_itr->Length ();
} else {
length = 0;
}
sum_time = 0.0;
num = 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;
board += run_itr->Board ();
alight += run_itr->Alight ();
riders += run_itr->Load ();
runs++;
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 ();
}
if (next_itr != line_ptr->end ()) {
time = next_itr->at (run).Schedule ().Seconds () - run_itr->Schedule ().Seconds ();
vmt += length;
vht += time;
pmt += length * run_itr->Load ();
pht += time * run_itr->Load ();
sum_time += time;
num++;
}
}
if (runs == 0) continue;
if (capacity == 0) capacity = runs;
factor = (double) riders / runs;
capfac = DTOI (riders * 10.0 / capacity) / 10.0;
if (next_itr == line_ptr->end ()) runs = 0;
if (num > 0) {
time = sum_time / num;
} else {
time = 0;
}
Print (1, String ("%8d %7.0lf %7.0lf %8d %8d %8d %5d %8.1lf %6d %8.1lf") % stop_ptr->Stop () %
UnRound (length) % time % alight % board % riders % runs % factor % capacity % capfac);
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 (alight > max_alight) max_alight = alight;
if (board > max_board) max_board = board;
if (riders > max_riders) max_riders = riders;
if (runs > max_runs) max_runs = runs;
if (factor > max_fac) max_fac = factor;
if (capacity > max_cap) max_cap = capacity;
if (capfac > max_capfac) max_capfac = capfac;
tot_len += length;
tot_time += time;
total += board;
}
if (max_runs == 0) continue;
Print (2, String (" Maximum %8ld %8ld %8ld %5ld %8.1lf %6lf %8.1lf") %
max_alight % max_board % max_riders % max_runs % max_fac % max_cap % max_capfac);
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);
}
void LinkSum::Write_Group (void)
{
int i, j, nrec, group, index;
String buffer, base;
double factor;
Units_Type units;
Doubles vmt, vht;
Int_Set *set_ptr;
Int_Set_Itr itr;
Int_Map_Itr map_itr;
Show_Message (String ("Writing %s -- Record") % group_file.File_Type ());
Set_Progress ();
if (Metric_Flag ()) {
factor = 1.0 / 1000.0;
base = "K";
units = KILOMETERS;
} else {
factor = 1.0 / MILETOFEET;
base = "M";
units = MILES;
}
//---- set the data fields and file header ----
group_file.Add_Field ("GROUP", DB_INTEGER, 10);
for (i=0; i < num_inc; i++) {
buffer = base + sum_periods.Range_Label (i);
group_file.Add_Field (buffer, DB_DOUBLE, 16.2, units);
buffer [0] = 'H';
group_file.Add_Field (buffer, DB_DOUBLE, 16.2, HOURS);
}
group_file.Write_Header ();
//---- process each group ----
nrec = 0;
for (group=1; group <= zone_equiv.Num_Groups (); group++) {
Show_Progress ();
set_ptr = zone_equiv.Group_List (group);
if (set_ptr == 0) continue;
vmt.assign (num_inc, 0.0);
vht.assign (num_inc, 0.0);
//---- process each zone in the group ----
for (itr = set_ptr->begin (); itr != set_ptr->end (); itr++) {
map_itr = zone_list.find (*itr);
if (map_itr == zone_list.end ()) continue;
index = map_itr->second;
for (i=0; i < num_inc; i++) {
vmt [i] += zone_vmt [i] [index];
vht [i] += zone_vht [i] [index];
}
}
//---- save the group data ----
group_file.Put_Field (0, group);
for (i=0, j=1; i < num_inc; i++) {
group_file.Put_Field (j++, UnRound (vmt [i] * factor));
group_file.Put_Field (j++, vht [i] / 3600.0);
}
if (!group_file.Write ()) {
Error (String ("Writing %s") % group_file.File_Type ());
}
nrec++;
}
End_Progress ();
Print (2, "Number of Group Travel Records = ") << nrec;
}
void Microsimulator::Problem_Plan (int problem, Travel_Plan_Data *plan_ptr, int dir, int lane, int cell)
{
int traveler;
if (plan_ptr->Mode () != DRIVER_MODE) {
traveler = plan_ptr->Traveler ();
Traveler_Data *traveler_ptr = traveler_data [traveler];
traveler_ptr->Problem (true);
traveler = traveler_ptr->Traveler ();
} else {
traveler = plan_ptr->Vehicle ();
}
if (problem_flag) {
int link = 0;
int direction = 0;
Rider_Data *rider_ptr = NULL;
problem_file.Mode (plan_ptr->Mode ());
problem_file.Trip (plan_ptr->Trip ());
problem_file.Leg (plan_ptr->Leg ());
problem_file.Problem (problem);
problem_file.Time (time_step.Format_Step (step));
if (dir > 0) {
Grid_Data *grid_ptr = grid_data [dir];
if (grid_ptr != NULL) {
Link_Data *link_ptr = link_data [grid_ptr->Link ()];
if (link_ptr != NULL) {
link = link_ptr->Link ();
}
direction = grid_ptr->Dir ();
}
}
problem_file.Link (link);
problem_file.Dir (direction);
problem_file.Lane (lane);
problem_file.Offset (UnRound (cell * cell_size));
problem_file.Route (0);
if (plan_ptr->Mode () == DRIVER_MODE) {
Msim_Vehicle *vehicle_ptr = vehicle_data [traveler];
if (vehicle_ptr != NULL) {
traveler = vehicle_ptr->Vehicle ();
problem_file.Household (rider_data.Route (traveler));
problem_file.Person (rider_data.Run (traveler));
problem_file.Route (rider_data.Route (traveler));
} else {
problem_file.Household (traveler);
problem_file.Person (0);
}
} else {
problem_file.Household (traveler / Traveler_Scale ());
problem_file.Person (traveler % Traveler_Scale ());
if (plan_ptr->Mode () == TRANSIT_MODE) {
rider_ptr = rider_data [plan_ptr->Vehicle ()];
if (rider_ptr != NULL) {
problem_file.Route (rider_ptr->Route ());
}
}
}
problem_file.Start (time_step.Format_Step (plan_ptr->Start_Time ()));
problem_file.Origin (0);
if (plan_ptr->Start_Type () == PARKING_ID) {
Parking_Data *parking_ptr = parking_data [plan_ptr->Start_Index ()];
if (parking_ptr != NULL) {
problem_file.Origin (parking_ptr->ID ());
} else {
problem_file.Origin (plan_file.Start_ID ());
}
} else if (plan_ptr->Start_Type () == STOP_ID) {
int index = plan_ptr->Start_Index ();
if (rider_ptr != NULL) {
index = rider_ptr->Stop (index);
}
Stop_Data *stop_ptr = stop_data [index];
if (stop_ptr != NULL) {
problem_file.Origin (stop_ptr->ID ());
} else {
problem_file.Origin (plan_file.Start_ID ());
}
}
problem_file.Arrive (time_step.Format_Step (plan_ptr->End_Time ()));
problem_file.Destination (0);
if (plan_ptr->End_Type () == PARKING_ID) {
Parking_Data *parking_ptr = parking_data [plan_ptr->End_Index ()];
if (parking_ptr != NULL) {
problem_file.Destination (parking_ptr->ID ());
} else {
problem_file.Destination (plan_file.Start_ID ());
}
} else if (plan_ptr->End_Type () == STOP_ID) {
int index = plan_ptr->End_Index ();
if (rider_ptr != NULL) {
index = rider_ptr->Stop (index);
}
Stop_Data *stop_ptr = stop_data [index];
if (stop_ptr != NULL) {
problem_file.Destination (stop_ptr->ID ());
} else {
problem_file.Destination (plan_file.End_ID ());
}
}
if (!problem_file.Write ()) {
Error ("Writing %s", problem_file.File_Type ());
}
}
if (dir > 0 && problem_output.In_Range (step, dir)) {
problem_output.Problem (problem);
problem_output.Link_Dir (dir);
problem_output.Summarize (step);
}
}
bool Data_Service::Get_Location_Data (Location_File &file, Location_Data &location_rec)
{
int link, dir, offset;
double setback;
Link_Data *link_ptr;
//---- read and save the data ----
location_rec.Location (file.Location ());
if (location_rec.Location () == 0) return (false);
//---- check/convert the link number and direction ----
link = file.Link ();
dir = file.Dir ();
offset = Round (file.Offset ());
link_ptr = Set_Link_Direction (file, link, dir, offset);
location_rec.Link (link);
location_rec.Dir (dir);
location_rec.Offset (offset);
setback = file.Setback ();
location_rec.Setback (setback);
if (Location_XY_Flag ()) {
Points points;
Link_Shape (link_ptr, dir, points, UnRound (offset), 0.0, setback);
if (points.size () > 0) {
location_rec.X (points [0].x);
location_rec.Y (points [0].y);
} else {
Node_Data *node_ptr = &node_array [link_ptr->Anode ()];
location_rec.X (node_ptr->X ());
location_rec.Y (node_ptr->Y ());
}
}
location_rec.Zone (file.Zone ());
if (location_rec.Zone () > 0 && System_Data_Flag (ZONE)) {
Int_Map_Itr map_itr = zone_map.find (location_rec.Zone ());
if (map_itr == zone_map.end ()) {
Warning (String ("Location %d Zone %d was Not Found") % location_rec.Location () % location_rec.Zone ());
return (false);
}
location_rec.Zone (map_itr->second);
} else if (location_rec.Zone () == 0) {
location_rec.Zone (-1);
//---- delete extra activity location used for transit stops ----
if (file.Version () <= 40) return (false);
}
location_rec.Notes (file.Notes ());
return (true);
}
bool ArcNet::Lane_Use_Processing (Db_File *fh)
{
int i, dir, center, lane, num_lanes;
double length, offset, start, end, side;
Link_Data *link_ptr;
Dir_Data *dir_ptr;
Lane_Use_Data *lane_use_ptr;
Lane_Use_File *file = (Lane_Use_File *) fh;
if (Network_Service::Lane_Use_Processing (file)) {
arcview_lane_use.Copy_Fields (file);
lane_use_ptr = lane_use_data.New_Record ();
if (select_time) {
if (!time_range.Span_Range (lane_use_ptr->Start (), lane_use_ptr->End ())) return (false);
}
link_ptr = link_data.Get (lane_use_ptr->Link ());
dir = lane_use_ptr->Dir ();
offset = UnRound (lane_use_ptr->Offset ());
length = UnRound (lane_use_ptr->Length ());
if (offset == 0.0 && length == 0.0) {
offset = 0.0;
length = UnRound (link_ptr->Length ());
}
start = offset;
end = start + length;
if (dir == 0) {
side = UnRound (link_ptr->Aoffset ());
if (start < side) start = side;
side = UnRound (link_ptr->Length () - link_ptr->Boffset ());
if (end > side) end = side;
length = end - start;
offset = start;
} else {
side = UnRound (link_ptr->Boffset ());
if (start < side) start = side;
side = UnRound (link_ptr->Length () - link_ptr->Aoffset ());
if (end > side) end = side;
length = end - start;
offset = UnRound (link_ptr->Length ()) - start;
}
if (lanes_flag) {
if (center_flag) {
if (link_ptr->BA_Dir () == 0) {
dir_ptr = dir_data [link_ptr->AB_Dir ()];
center = dir_ptr->Left () + dir_ptr->Thru () + dir_ptr->Right () + 1;
} else if (link_ptr->AB_Dir () == 0) {
dir_ptr = dir_data [link_ptr->BA_Dir ()];
center = dir_ptr->Left () + dir_ptr->Thru () + dir_ptr->Right () + 1;
} else {
center = 1;
}
} else {
center = 1;
}
lane = lane_use_ptr->Lane ();
if (lane == 0) {
if (dir == 0) {
dir_ptr = dir_data [link_ptr->AB_Dir ()];
} else {
dir_ptr = dir_data [link_ptr->BA_Dir ()];
}
lane = dir_ptr->Left ();
num_lanes = lane + dir_ptr->Thru ();
arcview_lane_use.parts.Reset ();
arcview_lane_use.points.Reset ();
for (++lane; lane <= num_lanes; lane++) {
side = (2 * lane - center) * lane_width / 2.0;
Link_Shape (link_ptr, dir, &points, offset, length, side);
if (!arcview_lane_use.parts.Add (arcview_lane_use.points.Num_Points ())) goto mem_error;
for (i=1; i <= points.Num_Points (); i++) {
if (!arcview_lane_use.points.Add (points [i])) goto mem_error;
}
}
if (!arcview_lane_use.Write_Record ()) goto write_error;
return (false);
} else {
arcview_lane_use.Num_Parts (1);
side = (2 * lane - center) * lane_width / 2.0;
}
} else {
side = 0.0;
}
if (Link_Shape (link_ptr, dir, &arcview_lane_use.points, offset, length, side)) {
if (!arcview_lane_use.Write_Record ()) goto write_error;
}
}
return (false);
mem_error:
Error ("Insufficient Memory for Lane Use Shape Points");
return (false);
write_error:
Error ("Writing ArcView Lane Use File");
return (false);
}
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;
}
void Emissions::Write_Link_Veh (void)
{
int i, j, k, lnk_field, veh_field, fac_field, link_dir, last_dir, num_rec;
int vehicle, num, n0, num_out, veh_num [100], veh_id, num_veh;
double vmt, veh_vmt [100], veh_wt;
Link_Data *link_ptr;
Dir_Data *dir_ptr;
Speed_Bin_Data *bin_ptr;
Category_Data *veh_ptr;
Value_Map *veh_map;
Traveler_Data *data_ptr;
Vol_Spd_Data *vsp_ptr;
veh_ptr = category_data.Get (VEHTYPE);
//---- create the data fields ----
link_veh_file.Add_Field ("linkID", Db_Code::INTEGER, 10);
lnk_field = 1;
link_veh_file.Add_Field ("sourceTypeID", Db_Code::INTEGER, 4);
veh_field = 2;
link_veh_file.Add_Field ("sourceTypeHourFraction", Db_Code::DOUBLE, 9, 2);
fac_field = 3;
link_veh_file.Write_Header ();
//---- save the data to the file ----
Show_Message ("Writing %s -- Record", link_veh_file.File_Type ());
Set_Progress ();
num_rec = 0;
memset (vmt_bin, '\0', sizeof (vmt_bin));
//---- check the data source ----
if (traveler_flag) {
//---- traveler data method ----
for (j=0; ; j++) {
if (link_eq_flag) {
if (j == 0) {
link_dir = link_list.First_Key ();
} else {
link_dir = link_list.Next_Key ();
}
if (link_dir == 0) break;
dir_ptr = dir_data [link_dir];
if (dir_ptr == NULL) continue;
} else {
if (j == 0) {
dir_ptr = dir_data.First ();
} else {
dir_ptr = dir_data.Next ();
}
if (dir_ptr == NULL) break;
}
Show_Progress ();
link_ptr = link_data.Get (dir_ptr->Link ());
if (link_ptr == NULL) continue;
num = last_dir = num_veh = num_out = 0;
memset (vmt_bin, '\0', sizeof (vmt_bin));
for (data_ptr = traveler_data.First_Key (); data_ptr; data_ptr = traveler_data.Next_Key ()) {
if (data_ptr->Link_Dir () != dir_ptr->Link_Dir ()) continue;
if (data_ptr->Traveler () != last_dir) {
num++;
last_dir = data_ptr->Traveler ();
}
vmt_bin [data_ptr->Vehicle ()] += UnRound (data_ptr->Distance ());
if (data_ptr->Vehicle () > num_out) num_out = data_ptr->Vehicle ();
}
if (num == 0) continue;
link_veh_file.Put_Field (lnk_field, (dir_ptr->Link () * 10 + dir_ptr->Dir ()));
for (i=1; i <= num_out; i++) {
vehicle = i;
vmt = vmt_bin [i];
for (veh_id = 0; ; veh_id++) {
if (veh_id == 0) {
veh_map = veh_ptr->First_Member (vehicle, 1);
} else {
veh_map = veh_ptr->Next_Member (vehicle, 1);
if (veh_map == NULL) break;
}
if (veh_map == NULL) {
veh_id = vehicle;
veh_wt = 1.0;
} else {
veh_id = veh_map->Value ();
veh_wt = veh_map->Weight ();
}
//---- scan existing vehicle IDs ----
for (k=0; k < num_veh; k++) {
if (veh_id == veh_num [k]) {
veh_vmt [k] += vmt * veh_wt;
break;
}
}
if (k == num_veh) {
veh_num [k] = veh_id;
veh_vmt [k] = vmt * veh_wt;
num_veh++;
}
}
}
//---- calculate the total link vmt ----
vmt = 0.0;
for (i=0; i < num_veh; i++) {
vmt += veh_vmt [i];
}
if (vmt > 0.0) {
//---- output the fraction for each vehicle type ----
for (i=0; i < num_veh; i++) {
link_veh_file.Put_Field (veh_field, veh_num [i]);
link_veh_file.Put_Field (fac_field, veh_vmt [i] / vmt);
if (!link_veh_file.Write ()) {
Error ("Writing %s", link_veh_file.File_Type ());
}
num_rec++;
}
}
}
} else if (vol_spd_flag) {
//---- volume speed data method ----
last_dir = num = 0;
for (vsp_ptr = vol_spd_data.First_Key (); ; vsp_ptr = vol_spd_data.Next_Key ()) {
if (vsp_ptr != NULL) {
Show_Progress ();
link_dir = vsp_ptr->Link ();
}
if (link_dir != last_dir || vsp_ptr == NULL) {
if (last_dir > 0 && num > 0) {
link_veh_file.Put_Field (lnk_field, last_dir);
num_veh = 0;
for (i=1; i <= vol_spd_data.Num_Volume (); i++) {
vehicle = i;
vmt = vmt_bin [i];
for (veh_id = 0; ; veh_id++) {
if (veh_id == 0) {
veh_map = veh_ptr->First_Member (vehicle, 1);
} else {
veh_map = veh_ptr->Next_Member (vehicle, 1);
if (veh_map == NULL) break;
}
if (veh_map == NULL) {
veh_id = vehicle;
veh_wt = 1.0;
} else {
veh_id = veh_map->Value ();
veh_wt = veh_map->Weight ();
}
//---- scan existing vehicle IDs ----
for (k=0; k < num_veh; k++) {
if (veh_id == veh_num [k]) {
veh_vmt [k] += vmt * veh_wt;
break;
}
}
if (k == num_veh) {
veh_num [k] = veh_id;
veh_vmt [k] = vmt * veh_wt;
num_veh++;
}
}
}
//---- calculate the total link vmt ----
vmt = 0.0;
for (i=0; i < num_veh; i++) {
vmt += veh_vmt [i];
}
if (vmt > 0.0) {
//---- output the fraction for each vehicle type ----
for (i=0; i < num_veh; i++) {
link_veh_file.Put_Field (veh_field, veh_num [i]);
link_veh_file.Put_Field (fac_field, veh_vmt [i] / vmt);
if (!link_veh_file.Write ()) {
Error ("Writing %s", link_veh_file.File_Type ());
}
num_rec++;
}
}
}
if (vsp_ptr == NULL) break;
last_dir = link_dir;
num = 0;
memset (vmt_bin, '\0', sizeof (vmt_bin));
}
for (i=1; i <= vsp_ptr->Num_Volume (); i++) {
vmt_bin [i] += vsp_ptr->Volume (i) * vsp_ptr->Length ();
}
num++;
}
} else {
last_dir = 0;
num = data_group.Num_Records ();
for (bin_ptr = speed_bin_data.First_Key (); ; bin_ptr = speed_bin_data.Next_Key ()) {
if (bin_ptr != NULL) {
Show_Progress ();
link_dir = bin_ptr->link_dir;
} else {
link_dir = -1;
}
if (link_dir != last_dir) {
if (last_dir > 0) {
dir_ptr = dir_data [last_dir];
if (dir_ptr != NULL) {
link_ptr = link_data.Get (dir_ptr->Link ());
if (link_ptr != NULL) {
link_veh_file.Put_Field (lnk_field, (dir_ptr->Link () * 10 + dir_ptr->Dir ()));
num_veh = 0;
for (i=0; i < num; i++) {
n0 = i * num_bins;
if (i > 0) {
for (j=0; j < num_bins; j++) {
spd_bin [j] = spd_bin [j + n0];
}
}
num_out = Speed_Bin_Distribution ();
vmt = 0.0;
for (j=1; j <= num_out; j++) {
vmt += vmt_bin [i];
}
vehicle = i + 1;
for (veh_id = 0; ; veh_id++) {
if (veh_id == 0) {
veh_map = veh_ptr->First_Member (vehicle, 1);
} else {
veh_map = veh_ptr->Next_Member (vehicle, 1);
if (veh_map == NULL) break;
}
if (veh_map == NULL) {
veh_id = vehicle;
veh_wt = 1.0;
} else {
veh_id = veh_map->Value ();
veh_wt = veh_map->Weight ();
}
//---- scan existing vehicle IDs ----
for (k=0; k < num_veh; k++) {
if (veh_id == veh_num [k]) {
veh_vmt [k] += vmt * veh_wt;
break;
}
}
if (k == num_veh) {
veh_num [k] = veh_id;
veh_vmt [k] = vmt * veh_wt;
num_veh++;
}
}
}
//---- calculate the total link vmt ----
vmt = 0.0;
for (i=0; i < num_veh; i++) {
vmt += veh_vmt [i];
}
if (vmt > 0.0) {
//---- output the fraction for each vehicle type ----
for (i=0; i < num_veh; i++) {
link_veh_file.Put_Field (veh_field, veh_num [i]);
link_veh_file.Put_Field (fac_field, veh_vmt [i] / vmt);
if (!link_veh_file.Write ()) {
Error ("Writing %s", link_veh_file.File_Type ());
}
num_rec++;
}
}
}
}
}
last_dir = link_dir;
memset (spd_bin, '\0', sizeof (spd_bin));
}
if (bin_ptr == NULL) break;
//---- sum the speed bin distribution ----
for (i=0; i < num; i++) {
n0 = i * num_bins;
for (j=0; j <= num_bins; j++) {
spd_bin [j + n0] += bin_ptr->bin [j + n0] * volume_factor;
}
}
}
}
End_Progress ();
link_veh_file.Close ();
Print (2, "Number of %s Records = %d", link_veh_file.File_Type (), num_rec);
}
bool ArcPlan::Get_Problem_Data (Problem_File &file, Problem_Data &problem_rec, int partition)
{
Location_Data *loc_ptr;
Trip_Index trip_index;
if (Data_Service::Get_Problem_Data (file, problem_rec, partition)) {
if (select_problems && !problem_range.In_Range (problem_rec.Problem ())) return (false);
if (select_households && !hhold_range.In_Range (problem_rec.Household ())) return (false);
if (problem_rec.Mode () < MAX_MODE && !select_mode [problem_rec.Mode ()]) return (false);
if (select_purposes && !purpose_range.In_Range (problem_rec.Purpose ())) return (false);
if (select_start_times && !start_range.In_Range (problem_rec.Start ())) return (false);
if (select_end_times && !end_range.In_Range (problem_rec.End ())) return (false);
if (select_origins && !org_range.In_Range (file.Origin ())) return (false);
if (select_destinations && !des_range.In_Range (file.Destination ())) return (false);
if (select_org_zones) {
loc_ptr = &location_array [problem_rec.Origin ()];
if (!org_zone_range.In_Range (loc_ptr->Zone ())) return (false);
}
if (select_des_zones) {
loc_ptr = &location_array [problem_rec.Destination ()];
if (!des_zone_range.In_Range (loc_ptr->Zone ())) return (false);
}
if (select_travelers && !traveler_range.In_Range (problem_rec.Type ())) return (false);
//---- check the selection records ----
if (System_File_Flag (SELECTION)) {
Select_Map_Itr sel_itr;
sel_itr = select_map.Best (problem_rec.Household (), problem_rec.Person (), problem_rec.Tour (), problem_rec.Trip ());
if (sel_itr == select_map.end ()) return (false);
}
//---- draw the problem record ----
if (problem_out) {
XYZ_Point point;
arcview_problem.clear ();
arcview_problem.Copy_Fields (file);
if (problem_method == 3) {
if (file.Link () > 0 && problem_rec.Dir_Index () >= 0) {
int lane, center;
double side;
Dir_Data *dir_ptr = &dir_array [problem_rec.Dir_Index ()];
Link_Data *link_ptr = &link_array [dir_ptr->Link ()];
lane = problem_rec.Lane () + 1;
if (center_flag) {
if (link_ptr->BA_Dir () < 0) {
center = dir_ptr->Left () + dir_ptr->Lanes () + dir_ptr->Right () + 1;
} else if (link_ptr->AB_Dir () < 0) {
center = dir_ptr->Left () + dir_ptr->Lanes () + dir_ptr->Right () + 1;
} else {
center = 1;
}
} else {
center = 1;
}
side = (2 * lane - center) * lane_width / 2.0;
Link_Shape (link_ptr, dir_ptr->Dir (), points, UnRound (problem_rec.Offset ()), 0.0, side);
arcview_problem.assign (1, points [0]);
} else {
loc_ptr = &location_array [problem_rec.Origin ()];
point.x = UnRound (loc_ptr->X ());
point.y = UnRound (loc_ptr->Y ());
arcview_problem.push_back (point);
}
} else if (problem_method < 2) {
loc_ptr = &location_array [problem_rec.Origin ()];
point.x = UnRound (loc_ptr->X ());
point.y = UnRound (loc_ptr->Y ());
arcview_problem.push_back (point);
}
if (problem_method != 1) {
loc_ptr = &location_array [problem_rec.Destination ()];
point.x = UnRound (loc_ptr->X ());
point.y = UnRound (loc_ptr->Y ());
arcview_problem.push_back (point);
}
if (!arcview_problem.Write_Record ()) {
Error (String ("Writing %s") % arcview_problem.File_Type ());
}
num_problem++;
}
//---- save the problem index ----
if (plan_flag) {
trip_index.Set (problem_rec.Household (), problem_rec.Person (), problem_rec.Tour (), problem_rec.Trip ());
problem_map.insert (Trip_Map_Data (trip_index, problem_rec.Problem ()));
}
}
return (false);
}
void ArcPlan::Write_Route (Offset_Data *org_ptr, Offset_Data *des_ptr)
{
int i, j, route, num_legs, stop, link_dir, dir;
int start_link_dir, end_link_dir;
double offset, length, link_len, side;
bool offset_flag, board, alight;
Link_Data *link_ptr;
Line_Data *line_ptr;
Driver_Data *driver_ptr;
Offset_Data *stop_ptr;
offset_flag = (route_offset != 0.0);
side = 0.0;
//---- get the route data ----
route = plan_file.Route ();
line_ptr = line_data.Get (route);
if (line_ptr == NULL) {
Warning ("Transit Route %d was Not Found", route);
return;
}
board = alight = false;
//---- create the route shape ----
if (driver_flag) {
//---- get the start and end link offsets ----
start_link_dir = org_ptr->Link_Dir ();
end_link_dir = des_ptr->Link_Dir ();
//---- get the route links ----
driver_ptr = driver_data [line_ptr->Driver ()];
num_legs = driver_ptr->Links ();
//---- create transit legs ----
for (i=1; i <= num_legs; i++) {
dir = driver_ptr->Dir (i);
link_dir = driver_ptr->Link_Dir (i);
link_ptr = link_data.Get (driver_ptr->Link (i));
link_len = UnRound (link_ptr->Length ());
length = link_len - 2 * route_offset;
if (dir == 0) {
offset = route_offset;
} else {
offset = link_len - route_offset;
}
if (!board) {
if (start_link_dir != link_dir) continue;
offset = org_ptr->Offset ();
if (dir == 0) {
length = link_len - offset - route_offset;
} else {
length = offset - route_offset;
}
}
if (end_link_dir == link_dir) {
alight = true;
if (dir == 0) {
length = des_ptr->Offset () - offset;
} else {
length = offset - des_ptr->Offset ();
}
}
if (offset_flag) {
if (link_ptr->AB_Dir () > 0 && link_ptr->BA_Dir () > 0) {
side = route_offset;
} else {
side = 0.0;
}
}
Link_Shape (link_ptr, dir, &points, offset, length, side);
//---- draw the link segment ----
if (side == 0.0 && !board) {
j = 2;
} else {
j = 1;
}
for (; j <= points.Num_Points (); j++) {
if (!arcview_plan.points.Add (points [j])) goto point_error;
}
board = true;
if (alight == true) break;
}
} else {
for (i=1; i <= line_ptr->Stops (); i++) {
stop = line_ptr->Stop (i);
if (!board) {
if (org_ptr->ID () != stop) continue;
board = true;
stop_ptr = org_ptr;
} else {
stop_ptr = stop_offset.Get (stop);
if (stop_ptr == NULL) goto stop_error;
}
link_ptr = link_data.Get (stop_ptr->Link ());
offset = stop_ptr->Offset ();
if (offset_flag) {
if (link_ptr->AB_Dir () > 0 && link_ptr->BA_Dir () > 0) {
side = route_offset;
} else {
side = 0.0;
}
}
Link_Shape (link_ptr, stop_ptr->Dir (), &points, offset, 0.0, side);
if (!arcview_plan.points.Add (points [1])) goto point_error;
if (des_ptr->ID () == stop) {
alight = true;
break;
}
}
}
if (board == false || alight == false) {
Warning ("Stops %d to %d were Not Found on Route %d", org_ptr->ID (), des_ptr->ID (), route);
}
return;
point_error:
Error ("Insufficient Memory for %d Points", arcview_plan.points.Num_Points ());
stop_error:
Warning ("Route %d Stop %d was Not Found in the Stop File", line_ptr->Route (), stop);
}
void SideFriction::Stop_Delay (void)
{
int stop, stops, run, runs, dir, route, period, lane, ln, time;
int stop_id, offset, low, high, length, start, link_dir, num;
char buffer [FIELD_BUFFER];
Stop_Data *stop_ptr;
Line_Data *line_ptr;
Link_Data *link_ptr;
Dir_Data *dir_ptr;
Offset_Data *offset_ptr;
Link_Use_Data *use_ptr;
Show_Message ("Estimate Transit Stop Delay -- Route");
Set_Progress (100);
//---- read each route ----
for (line_ptr = line_data.First_Key (); line_ptr; line_ptr = line_data.Next_Key ()) {
Show_Progress ();
route = line_ptr->Route ();
stops = line_ptr->Stops ();
runs = line_ptr->Runs ();
if (route_flag) {
if (!select_routes.In_Range (route)) continue;
}
if (!select_modes [line_ptr->Mode ()]) continue;
for (stop=1; stop <= stops; stop++) {
stop_id = line_ptr->Stop (stop);
//---- check for stop in the subarea ----
if (subarea_flag) {
offset_ptr = stop_offset.Get (stop_id);
if (offset_ptr == NULL) continue;
if (!In_Polygon (offset_ptr->X (), offset_ptr->Y (), &select_subarea.points)) continue;
}
//---- find the stop link ----
stop_ptr = stop_data.Get (stop_id);
if (stop_ptr == NULL) {
Warning ("Route %d Stop %d was Not Found", route, line_ptr->Stop (stop));
continue;
}
link_ptr = link_data.Get (stop_ptr->Link ());
if (link_ptr == NULL) {
Warning ("Stop Link %d was Not Found", stop_ptr->Link ());
continue;
}
if (stop_ptr->Dir () == 0) {
dir = link_ptr->AB_Dir ();
offset = stop_ptr->Offset ();
low = link_ptr->Aoffset ();
high = link_ptr->Boffset ();
} else {
dir = link_ptr->BA_Dir ();
offset = link_ptr->Length () - stop_ptr->Offset ();
low = link_ptr->Boffset ();
high = link_ptr->Aoffset ();
}
dir_ptr = dir_data [dir];
if (dir_ptr == NULL) {
Warning ("Stop Link %d Direction %d was Not Found", stop_ptr->Link (), stop_ptr->Dir ());
continue;
}
link_dir = stop_ptr->Link_Dir ();
lane = dir_ptr->Left () + dir_ptr->Thru ();
high = link_ptr->Length () - high;
length = stop_length;
offset -= length;
if (offset < low) {
offset = low;
if (offset + length > high) length = high - offset;
} else if (offset + length > high) {
offset = high - length;
if (offset < low) {
offset = low;
length = high - low;
}
}
//---- add a lane blockage for each run ----
for (run=1; run < runs; run++) {
time = Resolve (line_ptr->Schedule (run, stop));
period = transit_periods.In_Index (time);
if (period == 0) continue;
start = time - Resolve (stop_times [period]);
if (start < 0) start = 0;
ln = lane;
if (dir_ptr->TOD_List () > 0) {
for (num = dir_ptr->TOD_List (); num; num = use_ptr->TOD_List ()) {
use_ptr = link_use_data [num];
if (use_ptr->Length () > 0) continue;
if (use_ptr->Low_Lane () > lane || lane > use_ptr->High_Lane ()) continue;
if (Use_Permission (use_ptr->Use (), BUS)) continue;
if (use_ptr->End () < Round (start) || use_ptr->Start () > Round (time)) continue;
ln = use_ptr->Low_Lane () - 1;
break;
}
}
if (ln <= dir_ptr->Left ()) continue;
new_file->Link (stop_ptr->Link ());
new_file->Dir (stop_ptr->Dir ());
new_file->Lane (ln);
new_file->Use (Use_Code (Use_Code ("BUS")));
new_file->Type (Restrict_Code (ONLY));
new_file->Start (time_step.Format_Step (start));
new_file->End (time_step.Format_Step (time));
new_file->Offset (UnRound (offset));
new_file->Length (UnRound (length));
str_fmt (buffer, sizeof (buffer), "Route %d Stop %d Run %d", route, stop_id, run);
new_file->Notes (buffer);
if (!new_file->Write ()) {
Error ("Writing %s", new_file->File_Type ());
}
new_use++;
}
}
}
End_Progress ();
}
bool Data_Service::Get_Lane_Use_Data (Lane_Use_File &file, Lane_Use_Data &lane_use_rec)
{
int link, dir, lanes, offset, dir_index, low, high;
double rate;
Link_Data *link_ptr;
Int_Map_Itr map_itr;
//---- check/convert the link number and direction ----
link = file.Link ();
if (link <= 0) return (false);
dir = file.Dir ();
offset = Round (file.Offset ());
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 ("Lane Use %d Link %d Direction %s was Not Found") % Progress_Count () % link_ptr->Link () % ((dir) ? "BA" : "AB"));
return (false);
}
lane_use_rec.Dir_Index (dir_index);
//---- set the restriction type ----
lane_use_rec.Type (file.Type ());
lane_use_rec.Use (file.Use ());
//---- convert the vehicle type range ----
low = file.Min_Veh_Type ();
high = file.Max_Veh_Type ();
if (low > 0) {
map_itr = veh_type_map.find (low);
if (map_itr == veh_type_map.end ()) {
map_itr = veh_type_map.lower_bound (low);
if (map_itr == veh_type_map.end ()) {
Warning (String ("Lane Use %d Vehicle Type %d was Not Found") % Progress_Count () % low);
low = -1;
} else {
low = map_itr->second;
}
} else {
low = map_itr->second;
}
} else {
low = -1;
}
if (high > 0) {
map_itr = veh_type_map.find (high);
if (map_itr == veh_type_map.end ()) {
int h = high;
while (h > 0) {
map_itr = veh_type_map.find (--h);
if (map_itr != veh_type_map.end ()) break;
}
if (h >= 0) {
high = map_itr->second;
} else {
Warning (String ("Lane Use %d Vehicle Type %d was Not Found") % Progress_Count () % high);
high = -1;
}
} else {
high = map_itr->second;
}
if (high >= 0 && low < 0) low = 0;
} else {
high = -1;
}
if (low > high) {
if (high == -1) {
high = low;
} else {
Warning (String ("Lane Use %d Vehicle Type Range %d-%d is Illegal") % Progress_Count () % file.Min_Veh_Type () % file.Max_Veh_Type ());
high = low;
}
}
lane_use_rec.Min_Veh_Type (low);
lane_use_rec.Max_Veh_Type (high);
//---- convert the traveler type range ----
low = file.Min_Traveler ();
high = file.Max_Traveler ();
if (low <= 0) low = -1;
if (high > 0) {
if (low < 0) low = 0;
} else {
high = -1;
}
if (low > high) {
if (high == -1) {
high = low;
} else {
Warning (String ("Lane Use %d Traveler Type Range %d-%d is Illegal") % Progress_Count () % file.Min_Traveler () % file.Max_Traveler ());
high = low;
}
}
lane_use_rec.Min_Traveler (low);
lane_use_rec.Max_Traveler (high);
//----- length and offset ----
lane_use_rec.Length (file.Length ());
if (lane_use_rec.Length () > 0) {
if (offset > 0 || lane_use_rec.Length () < link_ptr->Length ()) {
lane_use_rec.Offset (offset);
} else {
lane_use_rec.Offset (0);
lane_use_rec.Length (0);
}
} else {
lane_use_rec.Offset (0);
}
//---- lane number ----
lanes = file.Lanes ();
if (file.Version () <= 40 && lanes > 0) {
low = high = lanes - 1;
} else {
Convert_Lane_Range (dir_index, lanes, low, high);
}
lane_use_rec.Low_Lane (low);
lane_use_rec.High_Lane (high);
//----- optional fields ----
lane_use_rec.Start (file.Start ());
lane_use_rec.End (file.End ());
if (lane_use_rec.End () == 0) lane_use_rec.End (Model_End_Time ());
lane_use_rec.Toll (Round (file.Toll ()));
lane_use_rec.Toll_Rate (file.Toll_Rate ());
if (lane_use_rec.Toll_Rate () > 0) {
rate = UnRound (lane_use_rec.Toll_Rate ());
if (Metric_Flag ()) {
rate /= 1000.0;
} else {
rate /= MILETOFEET;
}
lane_use_rec.Toll (lane_use_rec.Toll () + DTOI (rate * link_ptr->Length ()));
}
lane_use_rec.Min_Delay (file.Min_Delay ());
lane_use_rec.Max_Delay (file.Max_Delay ());
lane_use_rec.Speed (file.Speed ());
lane_use_rec.Spd_Fac (file.Speed_Factor ());
lane_use_rec.Capacity (file.Capacity ());
lane_use_rec.Cap_Fac (file.Cap_Factor ());
lane_use_rec.Notes (file.Notes ());
return (true);
}
