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); } }