protected override List <BinsContainer> GetBinsContainersByDirection(DirectionType directionType,
Models.Signal signal)
{
var detectorAggregationBySignal =
new DetectorAggregationBySignal(this, signal, directionType);
return(detectorAggregationBySignal.BinsContainers);
}
protected override List <BinsContainer> GetBinsContainersByDirection(DirectionType directionType,
Models.Signal signal)
{
var splitFailAggregationBySignal =
new CycleAggregationBySignal(this, signal, directionType);
return(splitFailAggregationBySignal.BinsContainers);
}
public SignalModelHelper(String SignalID)
{
MOE.Common.Models.Repositories.ISignalsRepository signals = MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
Signal = signals.GetSignalBySignalID(SignalID);
Approaches = GetApproachesForSignal();
LaneGroups = GetLaneGroupsForSignal();
Detectors = GetDetectorsForSignal();
}
protected override void LoadBins(SignalAggregationMetricOptions options, Models.Signal signal)
{
var signalEventCountAggregationRepository = SignalEventCountAggregationRepositoryFactory
.Create();
var signalEventCounts =
signalEventCountAggregationRepository.GetSignalEventCountAggregationBySignalIdAndDateRange(
signal.SignalID, BinsContainers.Min(b => b.Start), BinsContainers.Max(b => b.End));
if (signalEventCounts != null)
{
var concurrentBinContainers = new ConcurrentBag <BinsContainer>();
//foreach (var binsContainer in binsContainers)
Parallel.ForEach(BinsContainers, binsContainer =>
{
var tempBinsContainer =
new BinsContainer(binsContainer.Start, binsContainer.End);
var concurrentBins = new ConcurrentBag <Bin>();
//foreach (var bin in binsContainer.Bins)
Parallel.ForEach(binsContainer.Bins, bin =>
{
if (signalEventCounts.Any(s => s.BinStartTime >= bin.Start && s.BinStartTime < bin.End))
{
var signalEventCountSum = 0;
switch (options.SelectedAggregatedDataType.DataName)
{
case "EventCount":
signalEventCountSum = signalEventCounts.Where(s =>
s.BinStartTime >= bin.Start && s.BinStartTime < bin.End)
.Sum(s => s.EventCount);
break;
}
Bin newBin = new Bin
{
Start = bin.Start,
End = bin.End,
Sum = signalEventCountSum,
Average = signalEventCountSum
};
concurrentBins.Add(newBin);
}
else
{
concurrentBins.Add(new Bin
{
Start = bin.Start,
End = bin.End,
Sum = 0,
Average = 0
});
}
});
tempBinsContainer.Bins = concurrentBins.OrderBy(c => c.Start).ToList();
concurrentBinContainers.Add(tempBinsContainer);
});
BinsContainers = concurrentBinContainers.OrderBy(b => b.Start).ToList();
}
}
public virtual void SetApproachXAxisSignalSeriesForEventCount(Chart chart, Models.Signal signal)
{
var eventCountOptions = new SignalEventCountAggregationOptions(this);
Series series = eventCountOptions.GetSignalsXAxisSignalSeries(new List <Models.Signal> {
signal
}, signal.SignalDescription);
chart.Series.Add(SetEventCountSeries(series));
}
public static Models.Approach CreateNewApproachWithDefaultValues(Models.Signal signal, Models.DirectionType dir, MOE.Common.Models.SPM db)
{
Models.Approach appr = new Models.Approach();
appr.Description = signal.SignalID + dir.Abbreviation;
appr.DirectionTypeID = dir.DirectionTypeID;
appr.SignalID = signal.SignalID;
appr.MPH = 0;
return(appr);
}
protected void GetTimeXAxisDirectionSeriesChart(Models.Signal signal, Chart chart)
{
var i = 1;
foreach (var directionType in signal.GetAvailableDirections())
{
GetDirectionSeries(chart, i, directionType, signal);
i++;
}
}
protected void GetTimeXAxisApproachSeriesChart(Models.Signal signal, Chart chart, List <int> availablePhaseNumbers)
{
var i = 1;
foreach (var phase in availablePhaseNumbers)
{
GetPhaseTimeSeries(chart, i, phase, signal);
i++;
}
}
CheckForLowDetectorHits(Models.Signal signal)
{
var detectors = signal.GetDetectorsForSignalThatSupportAMetric(6);
//Parallel.ForEach(detectors, options, detector =>
foreach (var detector in detectors)
{
try
{
if (detector.DetectionTypes != null && detector.DetectionTypes.Any(d => d.DetectionTypeID == 2))
{
var channel = detector.DetChannel;
var direction = detector.Approach.DirectionType.Description;
var start = new DateTime();
var end = new DateTime();
if (Settings.WeekdayOnly && ScanDate.DayOfWeek == DayOfWeek.Monday)
{
start = ScanDate.AddDays(-3).Date.AddHours(Settings.PreviousDayPMPeakStart);
end = ScanDate.AddDays(-3).Date.AddHours(Settings.PreviousDayPMPeakEnd);
}
else
{
start = ScanDate.AddDays(-1).Date.AddHours(Settings.PreviousDayPMPeakStart);
end = ScanDate.AddDays(-1).Date.AddHours(Settings.PreviousDayPMPeakEnd);
}
var currentVolume = detector.GetVolumeForPeriod(start, end);
//Compare collected hits to low hit threshold,
if (currentVolume < Convert.ToInt32(Settings.LowHitThreshold))
{
var error = new SPMWatchDogErrorEvent();
error.SignalID = signal.SignalID;
error.DetectorID = detector.DetectorID;
error.Phase = detector.Approach.ProtectedPhaseNumber;
error.TimeStamp = ScanDate;
error.Direction = detector.Approach.DirectionType.Description;
error.Message = "CH: " + channel.ToString() + " - Count: " + currentVolume.ToString();
error.ErrorCode = 2;
if (!LowHitCountErrors.Contains(error))
{
LowHitCountErrors.Add(error);
}
}
}
}
catch (Exception ex)
{
var er =
ApplicationEventRepositoryFactory.Create();
er.QuickAdd("SPMWatchDog", "Program", "CheckForLowDetectorHits",
ApplicationEvent.SeverityLevels.Medium, detector.DetectorID + "-" + ex.Message);
}
}
//);
}
private void GetPhasePedAggregationContainersForAllPhases(
PhasePedAggregationOptions options, Models.Signal signal)
{
List <int> availablePhases = GetAvailablePhasesForSignal(options, signal);
foreach (var phaseNumber in availablePhases)
{
PedAggregations.Add(
new PhasePedAggregationBySignal(options, signal, phaseNumber));
}
}
private void SetTimeofDayAxisSignalSeriesForEventCount(Models.Signal signal, Chart chart)
{
var eventCountOptions = new ApproachEventCountAggregationOptions(this);
var binsContainers = eventCountOptions.GetBinsContainersByRoute(new List <Models.Signal> {
signal
});
Series series = CreateEventCountSeries();
eventCountOptions.SetTimeAggregateSeries(series, binsContainers);
chart.Series.Add(series);
}
private void GetPhaseTerminationAggregationContainersForAllPhases(
PhaseTerminationAggregationOptions options, Models.Signal signal)
{
List <int> availablePhases = GetAvailablePhasesForSignal(options, signal);
foreach (var phaseNumber in availablePhases)
{
PhaseTerminations.Add(
new PhaseTerminationAggregationByPhase(signal, phaseNumber, options,
options.SelectedAggregatedDataType));
}
}
private void GetApproachDetectorVolumeAggregationContainersForAllApporaches(
DetectorVolumeAggregationOptions options, Models.Signal signal)
{
foreach (var approach in signal.Approaches)
{
ApproachDetectorVolumes.Add(
new DetectorAggregationByApproach(approach, options, true));
if (approach.PermissivePhaseNumber != null)
{
ApproachDetectorVolumes.Add(
new DetectorAggregationByApproach(approach, options, false));
}
}
}
public string GetSignalLocation(string SignalID)
{
Models.Signal signal = (from r in db.Signals
where r.SignalID == SignalID
select r).FirstOrDefault();
string location = string.Empty;
if (signal != null)
{
location = signal.PrimaryName + " @ " + signal.SecondaryName;
}
return(location);
}
private Models.Approach GetApproachToAnalyze(Models.Signal signal, string direction)
{
Models.Approach approachToAnalyze = null;
var approaches = signal.Approaches.Where(a => a.DirectionType.Description == direction).ToList();
foreach (var approach in approaches)
{
if (approach.GetDetectorsForMetricType(6).Count > 0)
{
approachToAnalyze = approach;
}
}
return(approachToAnalyze);
}
public AggregationByPhase(Models.Signal signal, int phaseNumber, PhaseAggregationMetricOptions options, AggregatedDataType dataType)
{
BinsContainers = BinFactory.GetBins(options.TimeOptions);
PhaseNumber = phaseNumber;
//if (options.ShowEventCount)
//{
// ApproachEventCountAggregations = GetApproachEventCountAggregations(options, approach, true);
// if (approach.PermissivePhaseNumber != null)
// {
// ApproachEventCountAggregations.AddRange(GetApproachEventCountAggregations(options, approach, false));
// }
//}
LoadBins(signal, phaseNumber, options, dataType);
}
public Signal(string signalID, DateTime startDate, DateTime endDate,
List <int> eventCodes, int startOfCycle)
{
_SignalID = signalID;
_StartDate = startDate;
_EndDate = endDate;
_EventCodes = eventCodes;
MOE.Common.Models.Repositories.ISignalsRepository repository =
MOE.Common.Models.Repositories.SignalsRepositoryFactory.Create();
SignalModel = repository.GetSignalBySignalID(signalID);
_Detectors = SignalModel.GetDetectorsForSignal();
_Plans = new PlansBase(signalID, startDate, endDate);
GetPhases(startOfCycle);
}
protected override void LoadBins(ApproachAggregationMetricOptions options, Models.Signal signal)
{
for (var i = 0; i < BinsContainers.Count; i++)
{
for (var binIndex = 0; binIndex < BinsContainers[i].Bins.Count; binIndex++)
{
var bin = BinsContainers[i].Bins[binIndex];
foreach (var approachSplitFailAggregationContainer in ApproachSplitFailures)
{
bin.Sum += approachSplitFailAggregationContainer.BinsContainers[i].Bins[binIndex].Sum;
}
bin.Average = ApproachSplitFailures.Count > 0 ? bin.Sum / ApproachSplitFailures.Count : 0;
}
}
}
protected void GetTimeXAxisApproachSeriesChart(Models.Signal signal, Chart chart)
{
var i = 1;
foreach (var approach in signal.Approaches)
{
GetApproachTimeSeriesByProtectedPermissive(chart, i, approach, true);
i++;
if (approach.PermissivePhaseNumber != null)
{
GetApproachTimeSeriesByProtectedPermissive(chart, i, approach, false);
i++;
}
}
}
protected override void LoadBins(ApproachAggregationMetricOptions options, Models.Signal signal)
{
for (var i = 0; i < BinsContainers.Count; i++)
{
for (var binIndex = 0; binIndex < BinsContainers[i].Bins.Count; binIndex++)
{
var bin = BinsContainers[i].Bins[binIndex];
foreach (var speedAggregationByApproach in ApproachSpeedEvents)
{
bin.Sum += speedAggregationByApproach.BinsContainers[i].Bins[binIndex].Sum;
}
bin.Average = ApproachSpeedEvents.Count > 0 ? bin.Sum / ApproachSpeedEvents.Count : 0;
}
}
}
private static string FindDetector(Models.Signal Signal, int Channel)
{
try
{
var gd = Signal.GetDetectorForSignalByChannel(Channel);
if (gd != null)
{
return(gd.DetectorID);
}
return("0");
}
catch
{
return("0");
}
}
private void RemoveApproachesFromSignalByDirection(Models.Signal signal)
{
var approachesToRemove = new List <Approach>();
foreach (var approach in signal.Approaches)
{
if (FilterDirections.Where(f => !f.Include).Select(f => f.DirectionTypeId).ToList()
.Contains(approach.DirectionTypeID))
{
approachesToRemove.Add(approach);
}
}
foreach (var approach in approachesToRemove)
{
signal.Approaches.Remove(approach);
}
}
public Series GetTimeXAxisSignalSeries(Models.Signal signal)
{
var series = CreateSeries(-1, signal.SignalDescription);
var binsContainers = GetBinsContainersBySignal(signal);
foreach (var container in binsContainers)
{
if (binsContainers.Count > 1)
{
DataPoint dataPoint;
if (container != null)
{
if (this.SelectedAggregationType == AggregationType.Sum)
{
dataPoint = GetContainerDataPointForSum(container);
}
else
{
dataPoint = GetContainerDataPointForAverage(container);
}
series.Points.Add(dataPoint);
}
}
else
{
foreach (var bin in container.Bins)
{
DataPoint dataPoint;
if (bin != null)
{
if (this.SelectedAggregationType == AggregationType.Sum)
{
dataPoint = GetDataPointForSum(bin);
}
else
{
dataPoint = GetDataPointForAverage(bin);
}
series.Points.Add(dataPoint);
}
}
}
}
return(series);
}
public static MOE.Common.Models.Signal CopySignal(MOE.Common.Models.Signal incommingSignal, string newSignalID)
{
Models.SPM db = new SPM();
MOE.Common.Models.Signal newSignal = new Models.Signal();
newSignal.IPAddress = "10.10.10.10";
newSignal.PrimaryName = incommingSignal.PrimaryName;
newSignal.SecondaryName = incommingSignal.SecondaryName;
newSignal.Longitude = incommingSignal.Longitude;
newSignal.Latitude = incommingSignal.Latitude;
newSignal.RegionID = incommingSignal.RegionID;
newSignal.ControllerTypeID = incommingSignal.ControllerTypeID;
newSignal.Enabled = incommingSignal.Enabled;
newSignal.Approaches = new List <Models.Approach>();
//Models.Repositories.ISignalsRepository signalRepository =
// Models.Repositories.SignalsRepositoryFactory.Create();
//signalRepository.AddOrUpdate(newSignal);
//Models.Repositories.IApproachRepository approachRepository =
// Models.Repositories.ApproachRepositoryFactory.Create();
foreach (Models.Approach a in incommingSignal.Approaches)
{
Approach aForNewSignal = Models.Approach.CopyApproachForSignal(a.ApproachID); //this does the db.Save inside.
newSignal.Approaches.Add(aForNewSignal);
//approachRepository.AddOrUpdate(aForNewSignal);
}
newSignal.SignalID = newSignalID;
//try
//{
// db.SaveChanges();
//}
//catch (Exception ex)
//{
// Models.Repositories.IApplicationEventRepository eventRepository =
// Models.Repositories.ApplicationEventRepositoryFactory.Create();
// ApplicationEvent error = new ApplicationEvent();
// error.ApplicationName = "MOE.Common";
// error.Class = "Models.Signal.cs";
// error.Function = "CopySignal";
// error.Description = ex.Message;
// error.SeverityLevel = ApplicationEvent.SeverityLevels.Medium;
// error.Timestamp = DateTime.Now;
// eventRepository.Add(error);
// throw;
//}
return(newSignal);
}
private void GetApproachSplitFailAggregationContainersForAllApporaches(
ApproachSplitFailAggregationOptions options, Models.Signal signal)
{
foreach (var approach in signal.Approaches)
{
ApproachSplitFailures.Add(
new SplitFailAggregationByApproach(approach, options, options.TimeOptions.Start,
options.TimeOptions.End,
true, options.SelectedAggregatedDataType));
if (approach.PermissivePhaseNumber != null)
{
ApproachSplitFailures.Add(
new SplitFailAggregationByApproach(approach, options, options.StartDate,
options.EndDate,
false, options.SelectedAggregatedDataType));
}
}
}
public DetectorAggregationBySignal(DetectorVolumeAggregationOptions options, Models.Signal signal,
int phaseNumber) : base(options, signal)
{
ApproachDetectorVolumes = new List <DetectorAggregationByApproach>();
foreach (var approach in signal.Approaches)
{
if (approach.ProtectedPhaseNumber == phaseNumber)
{
ApproachDetectorVolumes.Add(
new DetectorAggregationByApproach(approach, options, true));
if (approach.PermissivePhaseNumber != null && approach.PermissivePhaseNumber == phaseNumber)
{
ApproachDetectorVolumes.Add(new DetectorAggregationByApproach(approach, options, false));
}
}
}
LoadBins(null, null);
}
private void CheckForForceOff(AnalysisPhase phase, Models.Signal signal)
{
if (phase.PercentForceOffs > Settings.PercentThreshold &&
phase.TerminationEvents.Where(t => t.EventCode != 7).Count() > Settings.MinPhaseTerminations)
{
var error = new SPMWatchDogErrorEvent();
error.SignalID = signal.SignalID;
error.Phase = phase.PhaseNumber;
error.TimeStamp = ScanDate;
error.Direction = phase.Direction ?? "";
error.Message = "Force Offs " + Math.Round(phase.PercentForceOffs * 100, 1) + "%";
error.ErrorCode = 4;
if (!ForceOffErrors.Contains(error))
{
ForceOffErrors.Add(error);
}
}
}
private Series GetApproachXAxisApproachSeries(Models.Signal signal, int colorCode)
{
var series = CreateSeries(0, signal.SignalDescription);
var i = 1;
foreach (var approach in signal.Approaches)
{
var binsContainers = GetBinsContainersByApproach(approach, true);
var dataPoint = new DataPoint();
dataPoint.XValue = i;
dataPoint.Color = GetSeriesColorByNumber(i);
if (SelectedAggregationType == AggregationType.Sum)
{
dataPoint.SetValueY(binsContainers.FirstOrDefault().SumValue);
}
else
{
dataPoint.SetValueY(binsContainers.FirstOrDefault().AverageValue);
}
dataPoint.AxisLabel = approach.Description;
series.Points.Add(dataPoint);
i++;
if (approach.PermissivePhaseNumber != null)
{
var binsContainers2 = GetBinsContainersByApproach(approach, false);
var dataPoint2 = new DataPoint();
dataPoint2.XValue = i;
dataPoint2.Color = GetSeriesColorByNumber(i);
if (SelectedAggregationType == AggregationType.Sum)
{
dataPoint2.SetValueY(binsContainers2.FirstOrDefault().SumValue);
}
else
{
dataPoint2.SetValueY(binsContainers2.FirstOrDefault().AverageValue);
}
dataPoint2.AxisLabel = approach.Description;
series.Points.Add(dataPoint2);
i++;
}
}
return(series);
}
public DetectorAggregationBySignal(DetectorVolumeAggregationOptions options, Models.Signal signal,
DirectionType direction) : base(options, signal)
{
ApproachDetectorVolumes = new List <DetectorAggregationByApproach>();
foreach (var approach in signal.Approaches)
{
if (approach.DirectionType.DirectionTypeID == direction.DirectionTypeID)
{
ApproachDetectorVolumes.Add(
new DetectorAggregationByApproach(approach, options, true));
if (approach.PermissivePhaseNumber != null)
{
ApproachDetectorVolumes.Add(
new DetectorAggregationByApproach(approach, options, false));
}
}
}
LoadBins(null, null);
}
protected void GetTimeOfDayXAxisApproachSeriesChart(Models.Signal signal, Chart chart)
{
if (TimeOptions.TimeOfDayStartHour != null && TimeOptions.TimeOfDayStartMinute.Value != null)
{
chart.ChartAreas.FirstOrDefault().AxisX.Minimum =
new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day,
TimeOptions.TimeOfDayStartHour.Value, TimeOptions.TimeOfDayStartMinute.Value, 0)
.AddHours(-1).ToOADate();
}
var seriesList = new ConcurrentBag <Series>();
var approaches = signal.Approaches.ToList();
try
{
Parallel.For(0, approaches.Count, i =>
{
var phaseDescription = GetPhaseDescription(approaches[i], true);
var binsContainers = GetBinsContainersByApproach(approaches[i], true);
var series = CreateSeries(i, approaches[i].Description + phaseDescription);
SetTimeAggregateSeries(series, binsContainers);
seriesList.Add(series);
if (approaches[i].PermissivePhaseNumber != null)
{
var permissivePhaseDescription = GetPhaseDescription(approaches[i], false);
var permissiveBinsContainers = GetBinsContainersByApproach(approaches[i], false);
var permissiveSeries = CreateSeries(i, approaches[i].Description + permissivePhaseDescription);
SetTimeAggregateSeries(permissiveSeries, permissiveBinsContainers);
seriesList.Add(permissiveSeries);
i++;
}
});
}
catch (Exception e)
{
throw;
}
var orderedSeries = seriesList.OrderBy(s => s.Name).ToList();
foreach (var series in orderedSeries)
{
chart.Series.Add(series);
}
}
