|
public GetStep ( int stepId ) : |
||
| stepId | int | |
| return | ||
/// <summary>
/// Calculates the current metrics for flowing and waiting vehicles
/// </summary>
/// <param name="wait"></param>
/// <param name="flow"></param>
/// <returns>true if the values could be calculated, false otherwise</returns>
public bool calcWaitFlow(out float wait, out float flow)
{
#if TRACE
Singleton <CodeProfiler> .instance.Start("TimedTrafficLightsStep.calcWaitFlow");
#endif
#if DEBUGMETRIC
bool debug = timedNode.NodeId == 3201;
#else
bool debug = false;
#endif
#if DEBUGMETRIC
if (debug)
{
Log.Warning($"TimedTrafficLightsStep.calcWaitFlow: ***START*** @ node {timedNode.NodeId}");
}
#endif
uint numFlows = 0;
uint numWaits = 0;
uint curMeanFlow = 0;
uint curMeanWait = 0;
// we are the master node. calculate traffic data
foreach (ushort timedNodeId in timedNode.NodeGroup)
{
TrafficLightSimulation sim = TrafficLightSimulation.GetNodeSimulation(timedNodeId);
if (sim == null || !sim.IsTimedLight())
{
continue;
}
TimedTrafficLights slaveTimedNode = sim.TimedLight;
if (slaveTimedNode.NumSteps() <= timedNode.CurrentStep)
{
for (int i = 0; i < slaveTimedNode.NumSteps(); ++i)
{
slaveTimedNode.GetStep(i).invalid = true;
}
continue;
}
TimedTrafficLightsStep slaveStep = slaveTimedNode.Steps[timedNode.CurrentStep];
//List<int> segmentIdsToDelete = new List<int>();
// minimum time reached. check traffic!
foreach (KeyValuePair <ushort, CustomSegmentLights> e in slaveStep.segmentLights)
{
var fromSegmentId = e.Key;
var segLights = e.Value;
// one of the traffic lights at this segment is green: count minimum traffic flowing through
SegmentEnd fromSeg = TrafficPriority.GetPrioritySegment(timedNodeId, fromSegmentId);
if (fromSeg == null)
{
#if DEBUGMETRIC
if (debug)
{
Log.Warning($"TimedTrafficLightsStep.calcWaitFlow: No priority segment @ seg. {fromSegmentId} found!");
}
#endif
//Log.Warning("stepDone(): prioSeg is null");
//segmentIdsToDelete.Add(fromSegmentId);
continue; // skip invalid segment
}
//bool startPhase = getCurrentFrame() <= startFrame + minTime + 2; // during start phase all vehicles on "green" segments are counted as flowing
ExtVehicleType validVehicleTypes = VehicleRestrictionsManager.GetAllowedVehicleTypes(fromSegmentId, timedNode.NodeId);
foreach (KeyValuePair <byte, ExtVehicleType> e2 in segLights.VehicleTypeByLaneIndex)
{
byte laneIndex = e2.Key;
ExtVehicleType vehicleType = e2.Value;
if (vehicleType != ExtVehicleType.None && (validVehicleTypes & vehicleType) == ExtVehicleType.None)
{
continue;
}
CustomSegmentLight segLight = segLights.GetCustomLight(laneIndex);
if (segLight == null)
{
Log.Warning($"Timed traffic light step: Failed to get custom light for vehicleType {vehicleType} @ seg. {fromSegmentId}, node {timedNode.NodeId}!");
continue;
}
#if DEBUGMETRIC
if (debug)
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: Checking lane {laneIndex} @ seg. {fromSegmentId}. Vehicle types: {vehicleType}");
}
#endif
Dictionary <ushort, uint> carsFlowingToSegmentMetric = null;
Dictionary <ushort, uint> allCarsToSegmentMetric = null;
try {
carsFlowingToSegmentMetric = fromSeg.GetVehicleMetricGoingToSegment(false, laneIndex, debug);
} catch (Exception ex) {
Log.Warning("calcWaitFlow (1): " + ex.ToString());
}
try {
allCarsToSegmentMetric = fromSeg.GetVehicleMetricGoingToSegment(true, laneIndex, debug);
} catch (Exception ex) {
Log.Warning("calcWaitFlow (2): " + ex.ToString());
}
if (carsFlowingToSegmentMetric == null)
{
continue;
}
// build directions from toSegment to fromSegment
Dictionary <ushort, Direction> directions = new Dictionary <ushort, Direction>();
foreach (KeyValuePair <ushort, uint> f in allCarsToSegmentMetric)
{
var toSegmentId = f.Key;
SegmentGeometry geometry = SegmentGeometry.Get(fromSegmentId);
Direction dir = geometry.GetDirection(toSegmentId, timedNodeId == geometry.StartNodeId());
directions[toSegmentId] = dir;
#if DEBUGMETRIC
if (debug)
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: Calculated direction for seg. {fromSegmentId} -> seg. {toSegmentId}: {dir}");
}
#endif
}
// calculate waiting/flowing traffic
foreach (KeyValuePair <ushort, uint> f in allCarsToSegmentMetric)
{
ushort toSegmentId = f.Key;
uint totalNormCarLength = f.Value;
uint totalFlowingNormCarLength = carsFlowingToSegmentMetric[f.Key];
#if DEBUGMETRIC
if (debug)
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: Total norm. car length of vehicles on lane {laneIndex} going to seg. {toSegmentId}: {totalNormCarLength}");
}
#endif
bool addToFlow = false;
switch (directions[toSegmentId])
{
case Direction.Turn:
addToFlow = TrafficPriority.IsLeftHandDrive() ? segLight.isRightGreen() : segLight.isLeftGreen();
break;
case Direction.Left:
addToFlow = segLight.isLeftGreen();
break;
case Direction.Right:
addToFlow = segLight.isRightGreen();
break;
case Direction.Forward:
default:
addToFlow = segLight.isForwardGreen();
break;
}
if (addToFlow)
{
++numFlows;
curMeanFlow += totalFlowingNormCarLength;
}
else
{
++numWaits;
curMeanWait += totalNormCarLength;
}
#if DEBUGMETRIC
if (debug)
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: Vehicles on lane {laneIndex} on seg. {fromSegmentId} going to seg. {toSegmentId} flowing? {addToFlow} curMeanFlow={curMeanFlow}, curMeanWait={curMeanWait}");
}
#endif
}
}
}
// delete invalid segments from step
/*foreach (int segmentId in segmentIdsToDelete) {
* slaveStep.segmentLightStates.Remove(segmentId);
* }*/
if (slaveStep.segmentLights.Count <= 0)
{
invalid = true;
flow = 0f;
wait = 0f;
#if TRACE
Singleton <CodeProfiler> .instance.Stop("TimedTrafficLightsStep.calcWaitFlow");
#endif
return(false);
}
}
#if DEBUGMETRIC
if (debug)
{
Log._Debug($"TimedTrafficLightsStep.calcWaitFlow: ### Calculation completed. numFlows={numFlows}, numWaits={numWaits}, curMeanFlow={curMeanFlow}, curMeanWait={curMeanWait}");
}
wait = curMeanWait;
flow = curMeanFlow;
#else
if (numFlows > 0)
{
curMeanFlow /= numFlows;
}
if (numWaits > 0)
{
curMeanWait /= numWaits;
}
float fCurMeanFlow = curMeanFlow;
fCurMeanFlow /= waitFlowBalance; // a value smaller than 1 rewards steady traffic currents
wait = (float)curMeanWait;
flow = fCurMeanFlow;
#endif
#if TRACE
Singleton <CodeProfiler> .instance.Stop("TimedTrafficLightsStep.calcWaitFlow");
#endif
return(true);
}
internal void Join(TimedTrafficLights otherTimedLight)
{
TrafficLightSimulationManager tlsMan = TrafficLightSimulationManager.Instance();
if (NumSteps() < otherTimedLight.NumSteps())
{
// increase the number of steps at our timed lights
for (int i = NumSteps(); i < otherTimedLight.NumSteps(); ++i)
{
TimedTrafficLightsStep otherStep = otherTimedLight.GetStep(i);
foreach (ushort slaveNodeId in NodeGroup)
{
TrafficLightSimulation ourSim = tlsMan.GetNodeSimulation(slaveNodeId);
if (ourSim == null || !ourSim.IsTimedLight())
{
continue;
}
TimedTrafficLights ourTimedLight = ourSim.TimedLight;
ourTimedLight.AddStep(otherStep.minTime, otherStep.maxTime, otherStep.waitFlowBalance, true);
}
}
}
else
{
// increase the number of steps at their timed lights
for (int i = otherTimedLight.NumSteps(); i < NumSteps(); ++i)
{
TimedTrafficLightsStep ourStep = GetStep(i);
foreach (ushort slaveNodeId in otherTimedLight.NodeGroup)
{
TrafficLightSimulation theirSim = tlsMan.GetNodeSimulation(slaveNodeId);
if (theirSim == null || !theirSim.IsTimedLight())
{
continue;
}
TimedTrafficLights theirTimedLight = theirSim.TimedLight;
theirTimedLight.AddStep(ourStep.minTime, ourStep.maxTime, ourStep.waitFlowBalance, true);
}
}
}
// join groups and re-defined master node, determine mean min/max times & mean wait-flow-balances
HashSet <ushort> newNodeGroupSet = new HashSet <ushort>();
newNodeGroupSet.UnionWith(NodeGroup);
newNodeGroupSet.UnionWith(otherTimedLight.NodeGroup);
List <ushort> newNodeGroup = new List <ushort>(newNodeGroupSet);
ushort newMasterNodeId = newNodeGroup[0];
int[] minTimes = new int[NumSteps()];
int[] maxTimes = new int[NumSteps()];
float[] waitFlowBalances = new float[NumSteps()];
foreach (ushort timedNodeId in newNodeGroup)
{
TrafficLightSimulation timedSim = tlsMan.GetNodeSimulation(timedNodeId);
if (timedSim == null || !timedSim.IsTimedLight())
{
continue;
}
TimedTrafficLights timedLight = timedSim.TimedLight;
for (int i = 0; i < NumSteps(); ++i)
{
minTimes[i] += timedLight.GetStep(i).minTime;
maxTimes[i] += timedLight.GetStep(i).maxTime;
waitFlowBalances[i] += timedLight.GetStep(i).waitFlowBalance;
}
timedLight.NodeGroup = newNodeGroup;
timedLight.masterNodeId = newMasterNodeId;
}
// build means
if (NumSteps() > 0)
{
for (int i = 0; i < NumSteps(); ++i)
{
minTimes[i] = Math.Max(1, minTimes[i] / newNodeGroup.Count);
maxTimes[i] = Math.Max(1, maxTimes[i] / newNodeGroup.Count);
waitFlowBalances[i] = Math.Max(0.001f, waitFlowBalances[i] / (float)newNodeGroup.Count);
}
}
// apply means & reset
foreach (ushort timedNodeId in newNodeGroup)
{
TrafficLightSimulation timedSim = tlsMan.GetNodeSimulation(timedNodeId);
if (timedSim == null || !timedSim.IsTimedLight())
{
continue;
}
TimedTrafficLights timedLight = timedSim.TimedLight;
timedLight.Stop();
timedLight.testMode = false;
timedLight.lastSimulationStep = 0;
for (int i = 0; i < NumSteps(); ++i)
{
timedLight.GetStep(i).minTime = minTimes[i];
timedLight.GetStep(i).maxTime = maxTimes[i];
timedLight.GetStep(i).waitFlowBalance = waitFlowBalances[i];
}
}
}
internal void Join(TimedTrafficLights otherTimedLight) {
if (NumSteps() < otherTimedLight.NumSteps()) {
// increase the number of steps at our timed lights
for (int i = NumSteps(); i < otherTimedLight.NumSteps(); ++i) {
TimedTrafficLightsStep otherStep = otherTimedLight.GetStep(i);
foreach (ushort slaveNodeId in NodeGroup) {
TrafficLightSimulation ourSim = TrafficLightSimulation.GetNodeSimulation(slaveNodeId);
if (ourSim == null || !ourSim.IsTimedLight())
continue;
TimedTrafficLights ourTimedLight = ourSim.TimedLight;
ourTimedLight.AddStep(otherStep.minTime, otherStep.maxTime, otherStep.waitFlowBalance, true);
}
}
} else {
// increase the number of steps at their timed lights
for (int i = otherTimedLight.NumSteps(); i < NumSteps(); ++i) {
TimedTrafficLightsStep ourStep = GetStep(i);
foreach (ushort slaveNodeId in otherTimedLight.NodeGroup) {
TrafficLightSimulation theirSim = TrafficLightSimulation.GetNodeSimulation(slaveNodeId);
if (theirSim == null || !theirSim.IsTimedLight())
continue;
TimedTrafficLights theirTimedLight = theirSim.TimedLight;
theirTimedLight.AddStep(ourStep.minTime, ourStep.maxTime, ourStep.waitFlowBalance, true);
}
}
}
// join groups and re-defined master node, determine mean min/max times & mean wait-flow-balances
HashSet<ushort> newNodeGroupSet = new HashSet<ushort>();
newNodeGroupSet.UnionWith(NodeGroup);
newNodeGroupSet.UnionWith(otherTimedLight.NodeGroup);
List<ushort> newNodeGroup = new List<ushort>(newNodeGroupSet);
ushort newMasterNodeId = newNodeGroup[0];
int[] minTimes = new int[NumSteps()];
int[] maxTimes = new int[NumSteps()];
float[] waitFlowBalances = new float[NumSteps()];
foreach (ushort timedNodeId in newNodeGroup) {
TrafficLightSimulation timedSim = TrafficLightSimulation.GetNodeSimulation(timedNodeId);
if (timedSim == null || !timedSim.IsTimedLight())
continue;
TimedTrafficLights timedLight = timedSim.TimedLight;
for (int i = 0; i < NumSteps(); ++i) {
minTimes[i] += timedLight.GetStep(i).minTime;
maxTimes[i] += timedLight.GetStep(i).maxTime;
waitFlowBalances[i] += timedLight.GetStep(i).waitFlowBalance;
}
timedLight.NodeGroup = newNodeGroup;
timedLight.masterNodeId = newMasterNodeId;
}
// build means
if (NumSteps() > 0) {
for (int i = 0; i < NumSteps(); ++i) {
minTimes[i] = Math.Max(1, minTimes[i] / newNodeGroup.Count);
maxTimes[i] = Math.Max(1, maxTimes[i] / newNodeGroup.Count);
waitFlowBalances[i] = Math.Max(0.001f, waitFlowBalances[i] / (float)newNodeGroup.Count);
}
}
// apply means & reset
foreach (ushort timedNodeId in newNodeGroup) {
TrafficLightSimulation timedSim = TrafficLightSimulation.GetNodeSimulation(timedNodeId);
if (timedSim == null || !timedSim.IsTimedLight())
continue;
TimedTrafficLights timedLight = timedSim.TimedLight;
timedLight.Stop();
timedLight.testMode = false;
timedLight.lastSimulationStep = 0;
for (int i = 0; i < NumSteps(); ++i) {
timedLight.GetStep(i).minTime = minTimes[i];
timedLight.GetStep(i).maxTime = maxTimes[i];
timedLight.GetStep(i).waitFlowBalance = waitFlowBalances[i];
}
}
}
/// <summary>
/// Calculates the current metrics for flowing and waiting vehicles
/// </summary>
/// <param name="wait"></param>
/// <param name="flow"></param>
/// <returns>true if the values could be calculated, false otherwise</returns>
public bool calcWaitFlow(out float wait, out float flow)
{
#if DEBUG
bool debug = timedNode.NodeId == 17857;
#else
bool debug = false;
#endif
uint numFlows = 0;
uint numWaits = 0;
uint curMeanFlow = 0;
uint curMeanWait = 0;
// we are the master node. calculate traffic data
foreach (ushort timedNodeId in groupNodeIds)
{
TrafficLightSimulation sim = TrafficLightSimulation.GetNodeSimulation(timedNodeId);
if (sim == null || !sim.IsTimedLight())
{
continue;
}
TimedTrafficLights slaveTimedNode = sim.TimedLight;
if (slaveTimedNode.NumSteps() <= timedNode.CurrentStep)
{
for (int i = 0; i < slaveTimedNode.NumSteps(); ++i)
{
slaveTimedNode.GetStep(i).invalid = true;
}
continue;
}
TimedTrafficLightsStep slaveStep = slaveTimedNode.Steps[timedNode.CurrentStep];
//List<int> segmentIdsToDelete = new List<int>();
// minimum time reached. check traffic!
foreach (KeyValuePair <ushort, CustomSegmentLights> e in slaveStep.segmentLights)
{
var fromSegmentId = e.Key;
var segLights = e.Value;
// one of the traffic lights at this segment is green: count minimum traffic flowing through
SegmentEnd fromSeg = TrafficPriority.GetPrioritySegment(timedNodeId, fromSegmentId);
if (fromSeg == null)
{
//Log.Warning("stepDone(): prioSeg is null");
//segmentIdsToDelete.Add(fromSegmentId);
continue; // skip invalid segment
}
bool startPhase = getCurrentFrame() <= startFrame + minTime + 2; // during start phase all vehicles on "green" segments are counted as flowing
ExtVehicleType validVehicleTypes = VehicleRestrictionsManager.GetAllowedVehicleTypes(fromSegmentId, timedNode.NodeId);
foreach (ExtVehicleType vehicleType in segLights.VehicleTypes)
{
if (vehicleType != ExtVehicleType.None && (validVehicleTypes & vehicleType) == ExtVehicleType.None)
{
continue;
}
CustomSegmentLight segLight = segLights.GetCustomLight(vehicleType);
if (segLight == null)
{
Log.Warning($"Timed traffic light step: Failed to get custom light for vehicleType {vehicleType} @ seg. {fromSegmentId}, node {timedNode.NodeId}!");
continue;
}
Dictionary <ushort, uint>[] carsToSegmentMetrics = new Dictionary <ushort, uint> [startPhase ? 1: 2];
try {
carsToSegmentMetrics[0] = fromSeg.GetVehicleMetricGoingToSegment(null, vehicleType, segLights.SeparateVehicleTypes, debug);
} catch (Exception ex) {
Log.Warning("calcWaitFlow: " + ex.ToString());
}
if (!startPhase)
{
try {
carsToSegmentMetrics[1] = fromSeg.GetVehicleMetricGoingToSegment(0.1f, vehicleType, segLights.SeparateVehicleTypes, debug);
} catch (Exception ex) {
Log.Warning("calcWaitFlow: " + ex.ToString());
}
}
if (carsToSegmentMetrics[0] == null)
{
continue;
}
// build directions from toSegment to fromSegment
Dictionary <ushort, Direction> directions = new Dictionary <ushort, Direction>();
foreach (KeyValuePair <ushort, uint> f in carsToSegmentMetrics[0])
{
var toSegmentId = f.Key;
SegmentGeometry geometry = CustomRoadAI.GetSegmentGeometry(fromSegmentId);
Direction dir = geometry.GetDirection(toSegmentId, timedNodeId);
directions[toSegmentId] = dir;
}
// calculate waiting/flowing traffic
for (int i = 0; i < carsToSegmentMetrics.Length; ++i)
{
if (carsToSegmentMetrics[i] == null)
{
continue;
}
foreach (KeyValuePair <ushort, uint> f in carsToSegmentMetrics[i])
{
ushort toSegmentId = f.Key;
uint totalNormCarLength = f.Value;
bool addToFlow = false;
switch (directions[toSegmentId])
{
case Direction.Left:
if (segLight.isLeftGreen())
{
addToFlow = true;
}
break;
case Direction.Right:
if (segLight.isRightGreen())
{
addToFlow = true;
}
break;
case Direction.Forward:
default:
if (segLight.isForwardGreen())
{
addToFlow = true;
}
break;
}
if (addToFlow)
{
if (i > 0 || startPhase)
{
++numFlows;
curMeanFlow += totalNormCarLength;
}
}
else if (i == 0)
{
++numWaits;
curMeanWait += totalNormCarLength;
}
}
}
}
}
// delete invalid segments from step
/*foreach (int segmentId in segmentIdsToDelete) {
* slaveStep.segmentLightStates.Remove(segmentId);
* }*/
if (slaveStep.segmentLights.Count <= 0)
{
invalid = true;
flow = 0f;
wait = 0f;
return(false);
}
}
if (numFlows > 0)
{
curMeanFlow /= numFlows;
}
if (numWaits > 0)
{
curMeanWait /= numWaits;
}
float fCurMeanFlow = curMeanFlow;
fCurMeanFlow /= 100f * waitFlowBalance; // a value smaller than 1 rewards steady traffic currents
wait = (float)curMeanWait / 100f;
flow = fCurMeanFlow;
return(true);
}
