1 | /************************************************************************************ |
---|
2 | * Copyright (C) 2008 by Politehnica University of Bucharest and Rutgers University |
---|
3 | * All rights reserved. |
---|
4 | * Refer to LICENSE for terms and conditions of use. |
---|
5 | ***********************************************************************************/ |
---|
6 | package vnsim.applications.adaptiveTL; |
---|
7 | |
---|
8 | |
---|
9 | import java.lang.ref.PhantomReference; |
---|
10 | import java.util.LinkedList; |
---|
11 | import java.util.ListIterator; |
---|
12 | |
---|
13 | import vnsim.applications.trafficview.SimulatedCarInfo; |
---|
14 | import vnsim.core.*; |
---|
15 | import vnsim.map.object.*; |
---|
16 | import vnsim.vehicular.simulator.CarInstance; |
---|
17 | import vnsim.vehicular.simulator.intersections.*; |
---|
18 | |
---|
19 | |
---|
20 | |
---|
21 | |
---|
22 | public class IntersectionPath { |
---|
23 | |
---|
24 | Intersection intersection; |
---|
25 | DirectedRoadSegment roadIn; |
---|
26 | DirectedRoadSegment roadout; |
---|
27 | |
---|
28 | public LinkedList<IntersectionPhaseStatistics> lastHourHistory = new LinkedList<IntersectionPhaseStatistics>(); |
---|
29 | public int analysisPeriod; |
---|
30 | |
---|
31 | public int demand, volume; |
---|
32 | public double avgNoOfStops; |
---|
33 | |
---|
34 | |
---|
35 | public IntersectionPath(Intersection intersection, DirectedRoadSegment roadIn, DirectedRoadSegment roadout){ |
---|
36 | this.intersection = intersection; |
---|
37 | this.roadIn = roadIn; |
---|
38 | this.roadout = roadout; |
---|
39 | |
---|
40 | lastHourHistory.add(new IntersectionPhaseStatistics(0, Globals.YELLOW)); |
---|
41 | } |
---|
42 | |
---|
43 | /** |
---|
44 | * Constructor used for vector lookup |
---|
45 | */ |
---|
46 | public IntersectionPath(DirectedRoadSegment roadIn, DirectedRoadSegment roadout){ |
---|
47 | this.roadIn = roadIn; |
---|
48 | this.roadout = roadout; |
---|
49 | } |
---|
50 | |
---|
51 | public boolean equals(Object arg0) { |
---|
52 | IntersectionPath ip = (IntersectionPath)arg0; |
---|
53 | return (this.roadIn.equals(ip.roadIn) && this.roadout.equals(ip.roadout)); |
---|
54 | } |
---|
55 | |
---|
56 | public void changePhase(int crtTime, int color){ |
---|
57 | IntersectionPhaseStatistics ips = lastHourHistory.getLast(); |
---|
58 | ips.setPhaseEndFrame(crtTime - 1); |
---|
59 | if (ips.getCarsNo() != 0){ |
---|
60 | ips.avgGap = (double)(ips.phaseEndFrame - ips.phaseStartFrame) / (Globals.SECOND * ips.carsNo); |
---|
61 | } |
---|
62 | if (roadIn.segmentIndex == 2){ |
---|
63 | int k = 0; |
---|
64 | k ++; |
---|
65 | } |
---|
66 | double avg = 0; |
---|
67 | Point px = roadIn.road.points.get(roadIn.pointIndex); |
---|
68 | for (int i = 1; i < roadIn.endOfQueue.length; i++){ |
---|
69 | if (roadIn.endOfQueue[i].car != null){ |
---|
70 | Point p = roadIn.road.points.get(roadIn.endOfQueue[i].getCar().getPointIdx()); |
---|
71 | avg += Math.abs(p.getDistance() - px.getDistance()); |
---|
72 | } |
---|
73 | } |
---|
74 | avg /= roadIn.endOfQueue.length - 1; |
---|
75 | ips.setQueueSize((ips.getQueueSize() + avg) / 2); |
---|
76 | |
---|
77 | lastHourHistory.add((ips = new IntersectionPhaseStatistics(crtTime, color))); |
---|
78 | ips.setQueueSize(avg); |
---|
79 | IntersectionPhaseStatistics first = lastHourHistory.getFirst(); |
---|
80 | if (crtTime - first.getPhaseEndFrame() > Globals.executionFPS * 3600){ |
---|
81 | lastHourHistory.removeFirst(); |
---|
82 | } |
---|
83 | } |
---|
84 | |
---|
85 | public void demand(IntersectionCarRecord icr){ |
---|
86 | SimulatedCarInfo sc = icr.getCar(); |
---|
87 | |
---|
88 | IntersectionPhaseStatistics ips = lastHourHistory.getLast(); |
---|
89 | ips.demandCarsNo ++; |
---|
90 | if (sc.getSignal() == 1){ |
---|
91 | ips.leftDemandCarsNo ++; |
---|
92 | } |
---|
93 | } |
---|
94 | |
---|
95 | public int computeDemand(int period){ |
---|
96 | demand = 0; |
---|
97 | ListIterator<IntersectionPhaseStatistics> it = lastHourHistory.listIterator(lastHourHistory.size() - 1); |
---|
98 | boolean skip = true; |
---|
99 | analysisPeriod = 0; |
---|
100 | while (it.hasPrevious()){ |
---|
101 | IntersectionPhaseStatistics x = it.previous(); |
---|
102 | if (skip){ |
---|
103 | if (x.color == Globals.GREEN){ |
---|
104 | skip = false; |
---|
105 | }else{ |
---|
106 | continue; |
---|
107 | } |
---|
108 | } |
---|
109 | |
---|
110 | if (x.phaseEndFrame < Globals.engine.crtTime - period){ |
---|
111 | break; |
---|
112 | } |
---|
113 | demand += x.demandCarsNo; |
---|
114 | analysisPeriod += x.phaseEndFrame - x.phaseStartFrame; |
---|
115 | } |
---|
116 | return demand; |
---|
117 | } |
---|
118 | |
---|
119 | public double computeLastCycleQueueSize(){ |
---|
120 | double sum = 0; |
---|
121 | int count = 0; |
---|
122 | ListIterator<IntersectionPhaseStatistics> it = lastHourHistory.listIterator(lastHourHistory.size() - 1); |
---|
123 | boolean first = true; |
---|
124 | int color = 0; |
---|
125 | while (it.hasPrevious()){ |
---|
126 | IntersectionPhaseStatistics x = it.previous(); |
---|
127 | if (!first && x.getColor() == color) |
---|
128 | break; |
---|
129 | if (first){ |
---|
130 | first = false; |
---|
131 | color = x.getColor(); |
---|
132 | } |
---|
133 | sum += x.queueSize * (x.phaseEndFrame - x.phaseStartFrame); |
---|
134 | count = x.phaseEndFrame - x.phaseStartFrame; |
---|
135 | } |
---|
136 | if (count == 0) |
---|
137 | return 0; |
---|
138 | return sum / count; |
---|
139 | } |
---|
140 | |
---|
141 | public int computeLeftDemand(int period){ |
---|
142 | int sum = 0; |
---|
143 | ListIterator<IntersectionPhaseStatistics> it = lastHourHistory.listIterator(lastHourHistory.size() - 1); |
---|
144 | while (it.hasPrevious()){ |
---|
145 | IntersectionPhaseStatistics x = it.previous(); |
---|
146 | if (x.phaseEndFrame < Globals.engine.crtTime - period) |
---|
147 | break; |
---|
148 | sum += x.leftDemandCarsNo; |
---|
149 | } |
---|
150 | return sum; |
---|
151 | } |
---|
152 | |
---|
153 | public int computeVolume(int period){ |
---|
154 | int sum = 0; |
---|
155 | ListIterator<IntersectionPhaseStatistics> it = lastHourHistory.listIterator(lastHourHistory.size() - 1); |
---|
156 | analysisPeriod = 0; |
---|
157 | while (it.hasPrevious()){ |
---|
158 | IntersectionPhaseStatistics x = it.previous(); |
---|
159 | if (x.phaseEndFrame < Globals.engine.crtTime - period) |
---|
160 | break; |
---|
161 | sum += x.carsNo; |
---|
162 | analysisPeriod += x.phaseEndFrame - x.phaseStartFrame; |
---|
163 | } |
---|
164 | return sum; |
---|
165 | } |
---|
166 | |
---|
167 | public double computeAvgNoOfStops(int period){ |
---|
168 | int sum = 0; |
---|
169 | double no = 0; |
---|
170 | ListIterator<IntersectionPhaseStatistics> it = lastHourHistory.listIterator(lastHourHistory.size() - 1); |
---|
171 | |
---|
172 | while (it.hasPrevious()){ |
---|
173 | IntersectionPhaseStatistics x = it.previous(); |
---|
174 | if (x.phaseEndFrame < Globals.engine.crtTime - period) |
---|
175 | break; |
---|
176 | sum += x.carsNo; |
---|
177 | no += x.carsNo * x.avgNoOfStops; |
---|
178 | } |
---|
179 | if (sum == 0) |
---|
180 | return 0; |
---|
181 | else |
---|
182 | return (double)no/sum; |
---|
183 | } |
---|
184 | |
---|
185 | public void recordCar(IntersectionCarRecord icr){ |
---|
186 | SimulatedCarInfo sc = icr.getCar(); |
---|
187 | |
---|
188 | IntersectionPhaseStatistics ips = lastHourHistory.getLast(); |
---|
189 | int idx = lastHourHistory.size() - 1; |
---|
190 | |
---|
191 | if (sc.getTimestamp() < ips.phaseStartFrame ){ |
---|
192 | idx -- ; |
---|
193 | ips = lastHourHistory.get(idx); |
---|
194 | } |
---|
195 | |
---|
196 | // compute number of cars |
---|
197 | int reds = 0; |
---|
198 | if (icr.getQueuedTime() == -1){ |
---|
199 | reds = 0; |
---|
200 | }else{ |
---|
201 | if (ips.phaseStartFrame > icr.getQueuedTime()){ |
---|
202 | ListIterator<IntersectionPhaseStatistics> it = lastHourHistory.listIterator(idx); |
---|
203 | while (it.hasPrevious()){ |
---|
204 | IntersectionPhaseStatistics x = it.previous(); |
---|
205 | if (x.phaseEndFrame < icr.getQueuedTime()) |
---|
206 | break; |
---|
207 | if (x.getColor() == Globals.RED) |
---|
208 | reds ++; |
---|
209 | } |
---|
210 | } |
---|
211 | } |
---|
212 | |
---|
213 | //compute delay at the simulation layer |
---|
214 | Road r = Globals.map.roads.get(roadout.roadIndex); |
---|
215 | CarInstance ci = new CarInstance((short)roadout.roadIndex, (short)roadout.pointIndex, null); |
---|
216 | ci.ID = icr.getCar().getVehicleId(); |
---|
217 | ci = r.carsOnThisRoad.get(ci, roadout.direction); |
---|
218 | if (ci != null) |
---|
219 | ips.avgControlDelay = (int)((double)(ips.avgControlDelay * ips.carsNo + ci.controlDelay )/ (ips.carsNo + 1)); |
---|
220 | |
---|
221 | ips.avgSpeed = (ips.avgSpeed * ips.carsNo + sc.getSpeed() )/ (ips.carsNo + 1) ; |
---|
222 | |
---|
223 | ips.avgNoOfStops = (double)(ips.getAvgNoOfStops() * ips.carsNo + reds )/ (ips.carsNo + 1); |
---|
224 | |
---|
225 | ips.carsNo ++; |
---|
226 | } |
---|
227 | |
---|
228 | public IntersectionPhaseStatistics getLastGreenPhase(){ |
---|
229 | ListIterator<IntersectionPhaseStatistics> it = lastHourHistory.listIterator(lastHourHistory.size() - 1); |
---|
230 | while (it.hasPrevious()){ |
---|
231 | IntersectionPhaseStatistics x = it.previous(); |
---|
232 | if (x.phaseEndFrame != -1 && x.color == Globals.GREEN){ |
---|
233 | return x; |
---|
234 | } |
---|
235 | } |
---|
236 | return null; |
---|
237 | } |
---|
238 | |
---|
239 | } |
---|