private static void StartAllRedInterval(int timeIndex, double timeStep, PhaseTimingData Phase)
{
Phase.Display[timeIndex] = ControlDisplayIndication.Red;
Phase.Display[timeIndex + 1] = ControlDisplayIndication.Red;
Phase.ActiveInterval[timeIndex] = PhaseInterval.AllRed;
Phase.ActiveInterval[timeIndex + 1] = PhaseInterval.AllRed;
//initialize elapsed all-red time
Phase.AllRedTimeElapsed = (float)timeStep;
Phase.IntervalTimeRemaining[timeIndex + 1] = Phase.AllRedTime;
foreach (VehicleControlPointData ControlPoint in Phase.AssociatedControlPoints)
{
ControlPoint.DisplayIndication = ControlDisplayIndication.Red;
}
}
public void SetPhaseIntervalTimes(byte[] includedPhases, Single[,] phaseIntervalTimes)
{
int PhaseIndex = -1;
_phases.Clear();
foreach (byte phaseNum in includedPhases)
{
//if (phaseNum == 0)
// break;
//PhaseIndex = phaseNum - (4 * (ringNum - 1));
PhaseIndex++;
PhaseTimingData newPhase = new PhaseTimingData(phaseNum, phaseIntervalTimes[PhaseIndex, 0], phaseIntervalTimes[PhaseIndex, 1], phaseIntervalTimes[PhaseIndex, 2], phaseIntervalTimes[PhaseIndex, 3]);
_phases.Add(newPhase);
if (phaseIntervalTimes[PhaseIndex, 0] > 0)
{
_phaseSequence.Add(phaseNum);
}
}
}
public static void SetPhaseTimes(TimingPlanData timingPlan)
{
bool[] IsPhaseInPreviousStage = new bool[9];
timingPlan.TimingRings[0].Phases.Clear();
timingPlan.TimingRings[1].Phases.Clear();
timingPlan.TimingRings[0].PhaseSequence.Clear();
timingPlan.TimingRings[1].PhaseSequence.Clear();
PhaseTimingData newPhase;
newPhase = new PhaseTimingData();
timingPlan.TimingRings[0].Phases.Add(newPhase); //phase 0 is dummy phase
newPhase = new PhaseTimingData();
timingPlan.TimingRings[1].Phases.Add(newPhase);
for (int StageNum = 1; StageNum < timingPlan.TimingStages.Count; StageNum++)
{
foreach (byte phaseNum in timingPlan.TimingStages[StageNum].IncludedPhases)
{
if (phaseNum < 5)
{
bool PhaseAlreadyInTimingRing = timingPlan.TimingRings[0].Phases.Exists(Phase => Phase.Id.Equals(phaseNum));
//byte value = Array.Find(timingPlan.TimingRings[0].Phases, element => element.Equals(phaseNum)); //see if phase # already exists in ring
if (PhaseAlreadyInTimingRing == false)
{
timingPlan.TimingRings[0].PhaseSequence.Add(phaseNum);
}
if (IsPhaseInPreviousStage[phaseNum] == false)
{
newPhase = new PhaseTimingData(phaseNum, timingPlan.TimingStages[StageNum].GreenMin, timingPlan.TimingStages[StageNum].GreenMax, timingPlan.TimingStages[StageNum].YellowTime, timingPlan.TimingStages[StageNum].AllRedTime);
timingPlan.TimingRings[0].Phases.Add(newPhase);
IsPhaseInPreviousStage[phaseNum] = true;
}
else
{
int PhaseIndex = timingPlan.TimingRings[0].Phases.Count - 1;
//for overlapping phase, also include yellow+all-red time from previous timing stage in green time calc
float AddedTime = timingPlan.TimingStages[StageNum - 1].YellowTime + timingPlan.TimingStages[StageNum - 1].AllRedTime + timingPlan.TimingStages[StageNum].GreenMax;
timingPlan.TimingRings[0].Phases[PhaseIndex].GreenMax += AddedTime;
IsPhaseInPreviousStage[phaseNum] = false;
}
}
else
{
bool PhaseAlreadyInTimingRing = timingPlan.TimingRings[1].Phases.Exists(Phase => Phase.Id.Equals(phaseNum));
//byte value = Array.Find(timingPlan.TimingRings[1].Phases, element => element.Equals(phaseNum)); //see if phase # already exists in ring
if (PhaseAlreadyInTimingRing == false)
{
timingPlan.TimingRings[1].PhaseSequence.Add(phaseNum);
}
if (IsPhaseInPreviousStage[phaseNum] == false)
{
newPhase = new PhaseTimingData(phaseNum, timingPlan.TimingStages[StageNum].GreenMin, timingPlan.TimingStages[StageNum].GreenMax, timingPlan.TimingStages[StageNum].YellowTime, timingPlan.TimingStages[StageNum].AllRedTime);
timingPlan.TimingRings[1].Phases.Add(newPhase);
IsPhaseInPreviousStage[phaseNum] = true;
}
else
{
int PhaseIndex = timingPlan.TimingRings[1].Phases.Count - 1;
//for overlapping phase, also include yellow+all-red time from previous timing stage in green time calc
float AddedTime = timingPlan.TimingStages[StageNum - 1].YellowTime + timingPlan.TimingStages[StageNum - 1].AllRedTime + timingPlan.TimingStages[StageNum].GreenMax;
timingPlan.TimingRings[1].Phases[PhaseIndex].GreenMax += AddedTime;
IsPhaseInPreviousStage[phaseNum] = false;
}
}
}
}
}
//Create virtual conflict monitor (MMU), i.e., a matrix of what movements can/cannot move together?
public static void UpdateSignalDisplays(SignalControllerPretimed sigController, int timeIndex, double timeStep) //, List<VehicleControlPointData> controlPoints)
{
int NextPhaseIndex = 0;
int TimingPlanNum = 0;
foreach (TimingRingData TimingRing in sigController.TimingPlans[TimingPlanNum].TimingRings)
{
int TimingRingIndex = TimingRing.Id - 1;
foreach (byte PhaseNum in sigController.TimingPlans[TimingPlanNum].TimingRings[TimingRingIndex].PhaseSequence)
{
//int PhaseIndex = (PhaseNum / TimingRing.Id);
int PhaseIndex = sigController.TimingPlans[TimingPlanNum].TimingRings[TimingRingIndex].PhaseSequence.FindIndex(item => item == PhaseNum) + 1;
PhaseTimingData Phase = sigController.TimingPlans[TimingPlanNum].TimingRings[TimingRingIndex].Phases[PhaseIndex];
if (Phase.ActiveInterval[timeIndex] == PhaseInterval.MaxGreen)
{
if (Phase.GreenTimeElapsed < Phase.GreenMax)
{
Phase.GreenTimeElapsed = (float)Math.Round(Phase.GreenTimeElapsed + timeStep, 1);
Phase.IntervalTimeRemaining[timeIndex + 1] = Phase.GreenMax - Phase.GreenTimeElapsed;
Phase.Display[timeIndex + 1] = ControlDisplayIndication.Green;
Phase.ActiveInterval[timeIndex + 1] = PhaseInterval.MaxGreen;
//foreach (VehicleControlPointData ControlPoint in Phase.AssociatedControlPoints)
//ControlPoint.DisplayIndication = PhaseDisplay.Green;
}
else if (Phase.GreenTimeElapsed == Phase.GreenMax)
{
//reset elapsed green time
Phase.GreenTimeElapsed = (float)timeStep;
if (Phase.YellowTime > 0)
{
Phase.Display[timeIndex] = ControlDisplayIndication.Yellow;
Phase.Display[timeIndex + 1] = ControlDisplayIndication.Yellow;
Phase.ActiveInterval[timeIndex] = PhaseInterval.Yellow;
Phase.ActiveInterval[timeIndex + 1] = PhaseInterval.Yellow;
//initialize elapsed yellow time
Phase.YellowTimeElapsed = (float)timeStep;
Phase.IntervalTimeRemaining[timeIndex + 1] = Phase.YellowTime;
foreach (VehicleControlPointData ControlPoint in Phase.AssociatedControlPoints)
{
ControlPoint.DisplayIndication = ControlDisplayIndication.Yellow;
}
}
else //for situation such as ramp metering in which yellow interval may not be used
{
StartAllRedInterval(timeIndex, timeStep, Phase);
}
//SetControlPointStatus(sigController, controlPoints, sigController.TimingPlans[TimingPlanNum].TimingRings[TimingRingIndex].Phases[PhaseIndex].AssociatedControlPointIds, PhaseDisplay.Yellow);
}
}
else if (Phase.ActiveInterval[timeIndex] == PhaseInterval.Yellow)
{
if (Phase.YellowTimeElapsed < Phase.YellowTime)
{
Phase.YellowTimeElapsed = (float)Math.Round(Phase.YellowTimeElapsed + timeStep, 1);
Phase.IntervalTimeRemaining[timeIndex + 1] = Phase.YellowTime - Phase.YellowTimeElapsed;
Phase.Display[timeIndex + 1] = ControlDisplayIndication.Yellow;
Phase.ActiveInterval[timeIndex + 1] = PhaseInterval.Yellow;
}
else if (Phase.YellowTimeElapsed == Phase.YellowTime)
{
//reset elapsed yellow time
Phase.YellowTimeElapsed = (float)timeStep;
StartAllRedInterval(timeIndex, timeStep, Phase);
//SetControlPointStatus(sigController, controlPoints, sigController.TimingPlans[TimingPlanNum].TimingRings[TimingRingIndex].Phases[PhaseIndex].AssociatedControlPointIds, PhaseDisplay.Red);
}
}
else if (Phase.ActiveInterval[timeIndex] == PhaseInterval.AllRed)
{
//Phase.Display[timeIndex + 1] = PhaseDisplay.Red;
if (Phase.AllRedTimeElapsed < Phase.AllRedTime)
{
Phase.AllRedTimeElapsed = (float)Math.Round(Phase.AllRedTimeElapsed + timeStep, 1);
Phase.IntervalTimeRemaining[timeIndex + 1] = Phase.AllRedTime - Phase.AllRedTimeElapsed;
Phase.Display[timeIndex + 1] = ControlDisplayIndication.Red;
Phase.ActiveInterval[timeIndex + 1] = PhaseInterval.AllRed;
}
else if (Phase.AllRedTimeElapsed == Phase.AllRedTime || Phase.AllRedTime == 0)
{
//reset elapsed all-red time
Phase.AllRedTimeElapsed = (float)timeStep;
Phase.Display[timeIndex] = ControlDisplayIndication.Red;
Phase.Display[timeIndex + 1] = ControlDisplayIndication.Red;
Phase.ActiveInterval[timeIndex + 1] = PhaseInterval.Red;
if (sigController.TimingPlans[TimingPlanNum].TimingRings[TimingRingIndex].ActivePhaseIndex == sigController.TimingPlans[TimingPlanNum].TimingRings[TimingRingIndex].PhaseSequence.Count)
{
sigController.TimingPlans[TimingPlanNum].TimingRings[TimingRingIndex].ActivePhaseIndex = 1;
//------------------------- Cycle and Phase Metrics --------------------------
CycleData newCycle = new CycleData();
newCycle.Id++;
PhaseMetricsData newPhaseMetrics = new PhaseMetricsData();
newPhaseMetrics.PhaseId = sigController.TimingPlans[TimingPlanNum].TimingRings[TimingRingIndex].Phases[NextPhaseIndex].Id;
newPhaseMetrics.EndGreen = (int)(timeIndex / timeStep);
newCycle.PhaseMetrics.Add(newPhaseMetrics);
sigController.CycleInfo.Add(newCycle);
}
else
{
sigController.TimingPlans[TimingPlanNum].TimingRings[TimingRingIndex].ActivePhaseIndex++;
}
NextPhaseIndex = sigController.TimingPlans[TimingPlanNum].TimingRings[TimingRingIndex].ActivePhaseIndex;
PhaseTimingData NextPhase = sigController.TimingPlans[TimingPlanNum].TimingRings[TimingRingIndex].Phases[NextPhaseIndex];
//change signal indications for next phase(s) in sequence to green
NextPhase.ActiveInterval[timeIndex] = PhaseInterval.MaxGreen;
NextPhase.ActiveInterval[timeIndex + 1] = PhaseInterval.MaxGreen;
NextPhase.Display[timeIndex] = ControlDisplayIndication.Green;
NextPhase.Display[timeIndex + 1] = ControlDisplayIndication.Green;
NextPhase.GreenTimeElapsed = 0;
foreach (VehicleControlPointData ControlPoint in NextPhase.AssociatedControlPoints)
{
ControlPoint.DisplayIndication = ControlDisplayIndication.Green;
}
//SetControlPointStatus(sigController, controlPoints, sigController.TimingPlans[TimingPlanNum].TimingRings[TimingRingIndex].Phases[NextPhaseIndex].AssociatedControlPointIds, PhaseDisplay.Green);
}
}
else if (Phase.ActiveInterval[timeIndex] == PhaseInterval.Red)
{
Phase.Display[timeIndex + 1] = ControlDisplayIndication.Red;
Phase.ActiveInterval[timeIndex + 1] = PhaseInterval.Red;
foreach (VehicleControlPointData ControlPoint in Phase.AssociatedControlPoints)
{
ControlPoint.DisplayIndication = ControlDisplayIndication.Red;
}
}
}
}
}
public override void LoadTimingPlan()
{
base.LoadTimingPlan();
for (int i = 0; i < ActiveTimingPlan.Phases.Length; i++)
{
PhaseTimingData phaseParameters = ActiveTimingPlan.Phases[i];
if (!phaseParameters.PhaseOmit)
{
ControllerPhase tempCPhase = new ControllerPhase((uint)phaseParameters.Id, phaseParameters); //, Detectors);
this.Phases.Add(tempCPhase);
}
}
for (int i = 0; i < ActiveTimingPlan.Rings.Count; i++)
{
Ring newRing = new Ring((uint)i + 1, ref _phases);
for (int j = 0; j < ActiveTimingPlan.Rings[i].Count; j++)
{
if (ActiveTimingPlan.Rings[i][j] != 0)
{
newRing.Phases.Add(ActiveTimingPlan.Rings[i][j]);
}
}
this._rings.Add(newRing);
}
//Create barrier objects
List <BarrierInRing> barriers = new List <BarrierInRing>();
for (int i = 0; i < ActiveTimingPlan.Rings.Count(); i++)
{
uint barrierID = 0;
List <BarrierInRing> barriersInRing = new List <BarrierInRing>();
for (int j = 0; j < ActiveTimingPlan.Rings[i].Count(); j++)
{
if (ActiveTimingPlan.Rings[i][j] == 0)
{
barrierID++;
BarrierInRing newBarrierInRing;
if (j == 0)
{
newBarrierInRing = new BarrierInRing(Convert.ToUInt16(i + 1), barrierID, Convert.ToUInt16(ActiveTimingPlan.Rings[i][ActiveTimingPlan.Rings[i].Count - 1]), Convert.ToUInt16(ActiveTimingPlan.Rings[i][j + 1]));
}
else if (j == ActiveTimingPlan.Rings[i].Count - 1)
{
newBarrierInRing = new BarrierInRing(Convert.ToUInt16(i + 1), barrierID, Convert.ToUInt16(ActiveTimingPlan.Rings[i][j - 1]), Convert.ToUInt16(ActiveTimingPlan.Rings[i][0]));
}
else
{
newBarrierInRing = new BarrierInRing(Convert.ToUInt16(i + 1), barrierID, Convert.ToUInt16(ActiveTimingPlan.Rings[i][j - 1]), Convert.ToUInt16(ActiveTimingPlan.Rings[i][j + 1]));
}
barriers.Add(newBarrierInRing);
}
}
}
List <uint> barrierIDs = new List <uint>();
foreach (BarrierInRing barrierInRing in barriers)
{
if (!barrierIDs.Contains(barrierInRing.BarrierID))
{
barrierIDs.Add(barrierInRing.BarrierID);
}
}
foreach (uint barrierID in barrierIDs)
{
Barrier newBarrier = new Barrier(barrierID);
foreach (BarrierInRing barrierInRing in barriers)
{
if (barrierInRing.BarrierID == barrierID)
{
newBarrier.Add(barrierInRing);
}
}
this._barriers.Add(newBarrier);
}
foreach (Ring thisring in _rings)
{
foreach (BarrierInRing barrierInRing in barriers)
{
if (barrierInRing.RingID == thisring.ID)
{
thisring.BarrierInRings.Add(barrierInRing);
}
}
foreach (uint phaseID in thisring.Phases)
{
if (Phases.GetByID(phaseID).TimingPlanParameters.SoftRecall)
{
thisring.SoftRecallPhaseID = phaseID;
}
}
}
foreach (ControllerPhase phaseFrom in this.Phases)
{
foreach (ControllerPhase phaseTo in this.Phases)
{
if (phaseFrom.ID != phaseTo.ID)
{
this.InterGreens.Add(new InterGreen(phaseFrom.ID, phaseTo.ID, phaseFrom.TimingPlanParameters.YellowTime + phaseFrom.TimingPlanParameters.AllRedTime));
}
}
}
}
