public static GetNodeSimulation ( ushort nodeId ) : |
||
nodeId | ushort | |
return |
public void SkipStep(bool setLights = true) { if (!isMasterNode()) { return; } var newCurrentStep = (CurrentStep + 1) % NumSteps(); foreach (ushort slaveNodeId in NodeGroup) { TrafficLightSimulation slaveSim = TrafficLightSimulation.GetNodeSimulation(slaveNodeId); if (slaveSim == null || !slaveSim.IsTimedLight()) { continue; } slaveSim.TimedLight.Steps[CurrentStep].SetStepDone(); slaveSim.TimedLight.CurrentStep = newCurrentStep; slaveSim.TimedLight.Steps[newCurrentStep].Start(); if (setLights) { slaveSim.TimedLight.Steps[newCurrentStep].SetLights(); } } }
internal TimedTrafficLights MasterLights() { TrafficLightSimulation masterSim = TrafficLightSimulation.GetNodeSimulation(masterNodeId); if (masterSim == null || !masterSim.IsTimedLight()) { return(null); } return(masterSim.TimedLight); }
public void SetLights() { // set lights foreach (ushort slaveNodeId in NodeGroup) { TrafficLightSimulation slaveSim = TrafficLightSimulation.GetNodeSimulation(slaveNodeId); if (slaveSim == null || !slaveSim.IsTimedLight()) { //TrafficLightSimulation.RemoveNodeFromSimulation(slaveNodeId, false); // we iterate over NodeGroup!! continue; } slaveSim.TimedLight.Steps[CurrentStep].SetLights(); } }
/// <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); }
/// <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); }
public bool StepDone(bool updateValues) { if (timedNode.IsInTestMode()) { return(false); } if (stepDone) { return(true); } if (getCurrentFrame() >= startFrame + maxTime) { // maximum time reached. switch! #if DEBUG //Log.Message("step finished @ " + nodeId); #endif stepDone = true; endTransitionStart = getCurrentFrame(); return(stepDone); } if (getCurrentFrame() >= startFrame + minTime) { if (timedNode.masterNodeId != timedNode.NodeId) { TrafficLightSimulation masterSim = TrafficLightSimulation.GetNodeSimulation(timedNode.masterNodeId); if (masterSim == null || !masterSim.IsTimedLight()) { invalid = true; stepDone = true; endTransitionStart = getCurrentFrame(); return(true); } TimedTrafficLights masterTimedNode = masterSim.TimedLight; bool done = masterTimedNode.Steps[masterTimedNode.CurrentStep].StepDone(updateValues); #if DEBUG //Log.Message("step finished (1) @ " + nodeId); #endif stepDone = done; if (stepDone) { endTransitionStart = getCurrentFrame(); } return(stepDone); } else { // we are the master node float wait, flow; uint curFrame = getCurrentFrame(); if (lastFlowWaitCalc < curFrame) { if (!calcWaitFlow(out wait, out flow)) { stepDone = true; endTransitionStart = getCurrentFrame(); return(stepDone); } else { lastFlowWaitCalc = curFrame; } } else { flow = minFlow; wait = maxWait; } float newFlow = minFlow; float newWait = maxWait; if (Single.IsNaN(newFlow)) { newFlow = flow; } else { newFlow = 0.1f * newFlow + 0.9f * flow; // some smoothing } if (Single.IsNaN(newWait)) { newWait = 0; } else { newWait = 0.1f * newWait + 0.9f * wait; // some smoothing } // if more cars are waiting than flowing, we change the step bool done = newWait > 0 && newFlow < newWait; if (updateValues) { minFlow = newFlow; maxWait = newWait; } #if DEBUG //Log.Message("step finished (2) @ " + nodeId); #endif if (updateValues) { stepDone = done; } if (stepDone) { endTransitionStart = getCurrentFrame(); } return(stepDone); } } return(false); }
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]; } } }
public void SimulationStep() { var currentFrame = Singleton <SimulationManager> .instance.m_currentFrameIndex >> 5; #if DEBUGTTL Log._Debug($"TTL SimStep: currentFrame={currentFrame} lastSimulationStep={lastSimulationStep}"); #endif if (lastSimulationStep >= currentFrame) { #if DEBUGTTL Log._Debug($"TTL SimStep: *STOP* lastSimulationStep >= currentFrame"); #endif return; } lastSimulationStep = currentFrame; if (!isMasterNode() || !IsStarted()) { #if DEBUGTTL Log._Debug($"TTL SimStep: *STOP* isMasterNode={isMasterNode()} IsStarted={IsStarted()}"); #endif return; } if (!housekeeping(false)) { #if DEBUGTTL Log.Warning($"TTL SimStep: *STOP* Housekeeping detected that this timed traffic light has become invalid: {NodeId}."); #endif Stop(); return; } if (!Steps[CurrentStep].isValid()) { #if DEBUGTTL Log._Debug($"TTL SimStep: *STOP* current step ({CurrentStep}) is not valid."); #endif TrafficLightSimulation.RemoveNodeFromSimulation(NodeId, false); return; } #if DEBUGTTL Log._Debug($"TTL SimStep: Setting lights (1)"); #endif SetLights(); if (!Steps[CurrentStep].StepDone(true)) { #if DEBUGTTL Log._Debug($"TTL SimStep: *STOP* current step ({CurrentStep}) is not done."); #endif return; } // step is done #if DEBUGTTL Log._Debug($"TTL SimStep: Setting lights (2)"); #endif SetLights(); if (!Steps[CurrentStep].isEndTransitionDone()) { #if DEBUGTTL Log._Debug($"TTL SimStep: *STOP* current step ({CurrentStep}): end transition is not done."); #endif return; } // ending transition (yellow) finished #if DEBUGTTL Log._Debug($"TTL SimStep: ending transition done. NodeGroup={string.Join(", ", NodeGroup.Select(x => x.ToString()).ToArray())}, nodeId={NodeId}, NumSteps={NumSteps()}"); #endif // change step var newCurrentStep = (CurrentStep + 1) % NumSteps(); foreach (ushort slaveNodeId in NodeGroup) { TrafficLightSimulation slaveSim = TrafficLightSimulation.GetNodeSimulation(slaveNodeId); if (slaveSim == null || !slaveSim.IsTimedLight()) { continue; } slaveSim.TimedLight.CurrentStep = newCurrentStep; slaveSim.TimedLight.Steps[newCurrentStep].Start(); slaveSim.TimedLight.Steps[newCurrentStep].SetLights(); } }