コード例 #1
0
        public override List <string> CreateMetric()
        {
            base.CreateMetric();
            //EndDate = EndDate.AddSeconds(59);
            var returnString     = new List <string>();
            var sr               = SignalsRepositoryFactory.Create();
            var signal           = sr.GetVersionOfSignalByDate(SignalID, StartDate);
            var metricApproaches = signal.GetApproachesForSignalThatSupportMetric(MetricTypeID);

            if (metricApproaches.Count > 0)
            {
                //Parallel.ForEach(metricApproaches, approach =>
                foreach (Approach approach in metricApproaches)
                {
                    if (approach.ProtectedPhaseNumber > 0)
                    {
                        var splitFailPhase = new SplitFailPhase(approach, this, false);
                        var chartName      = CreateFileName();
                        GetChart(splitFailPhase, chartName, returnString, false, approach);
                    }
                    if (approach.PermissivePhaseNumber != null && approach.PermissivePhaseNumber > 0)
                    {
                        var splitFailPermissivePhase = new SplitFailPhase(approach, this, true);
                        var permChartName            = CreateFileName();
                        GetChart(splitFailPermissivePhase, permChartName, returnString, true, approach);
                    }
                }
            }
            //);
            return(returnString);
        }
コード例 #2
0
        public void SplitFailPhaseTest()
        {
            SplitFailOptions splitFailOptions = new SplitFailOptions {
                StartDate = new DateTime(2017, 10, 17, 17, 0, 0), EndDate = new DateTime(2017, 10, 17, 17, 11, 1), FirstSecondsOfRed = 5, SignalID = "7185", MetricTypeID = 12, ShowAvgLines = true, ShowPercentFailLines = true, ShowFailLines = true, Y2AxisMax = null, YAxisMin = 0, Y2AxisMin = 0, YAxisMax = null
            };
            var            signalRepository = SignalsRepositoryFactory.Create();
            var            signal           = signalRepository.GetLatestVersionOfSignalBySignalID("7185");
            var            approach         = signal.Approaches.Where(a => a.ApproachID == 5593).FirstOrDefault();
            SplitFailPhase splitFailPhase   = new SplitFailPhase(approach, splitFailOptions, true);

            Assert.IsTrue(splitFailPhase.Cycles[4].StartTime == new DateTime(2017, 10, 17, 17, 9, 33));
            Assert.IsTrue(splitFailPhase.Cycles[4].YellowEvent == new DateTime(2017, 10, 17, 17, 10, 09));
            Assert.IsTrue(splitFailPhase.Cycles[4].RedEvent == new DateTime(2017, 10, 17, 17, 10, 13));
            Assert.IsTrue(splitFailPhase.Cycles[4].ActivationsDuringGreen.Count == 2);
            DateTime date1 = new DateTime(2017, 10, 17, 17, 1, 59, 500);

            Assert.IsTrue(splitFailPhase.Cycles[4].ActivationsDuringGreen[0].DetectorOn == date1);
            Assert.IsTrue(splitFailPhase.Cycles[4].ActivationsDuringGreen[0].DetectorOff == new DateTime(2017, 10, 17, 17, 9, 43, 800));
            Assert.IsTrue(splitFailPhase.Cycles[4].ActivationsDuringGreen[0].DurationInMilliseconds == 464300);
            Assert.IsTrue(splitFailPhase.Cycles[4].ActivationsDuringGreen[1].DetectorOn == new DateTime(2017, 10, 17, 17, 9, 55, 400));
            Assert.IsTrue(splitFailPhase.Cycles[4].ActivationsDuringGreen[1].DetectorOff == new DateTime(2017, 10, 17, 17, 10, 6, 300));
            Assert.IsTrue(splitFailPhase.Cycles[4].ActivationsDuringGreen[1].DurationInMilliseconds == 10900);
            Assert.IsTrue(splitFailPhase.Cycles[4].ActivationsDuringRed.Count == 1);
            Assert.IsTrue(splitFailPhase.Cycles[4].ActivationsDuringRed[0].DetectorOn == new DateTime(2017, 10, 17, 17, 10, 9, 200));
            Assert.IsTrue(splitFailPhase.Cycles[4].ActivationsDuringRed[0].DetectorOff == new DateTime(2017, 10, 17, 17, 10, 13, 300));
            Assert.IsTrue(splitFailPhase.Cycles[4].ActivationsDuringRed[0].DurationInMilliseconds == 4100);
            Assert.IsTrue(splitFailPhase.Cycles[4].GreenOccupancyTimeInMilliseconds == 21700.0);
            Assert.IsTrue(splitFailPhase.Cycles[4].TotalGreenTimeMilliseconds == 36000.0);
            Assert.IsTrue(splitFailPhase.Cycles[4].RedOccupancyTimeInMilliseconds == 300.0);
            Assert.IsTrue(splitFailPhase.Cycles[4].RedOccupancyPercent == 6.0);
            Assert.IsTrue(splitFailPhase.Cycles[4].FirstSecondsOfRed == 5);
            Assert.IsTrue(Math.Round(splitFailPhase.Cycles[4].GreenOccupancyPercent) == 60.0);
        }
コード例 #3
0
        public RLMSignalPhaseCollection(DateTime startDate, DateTime endDate, string signalID,
                                        int binSize, double srlvSeconds)
        {
            var metricTypeID = 11;
            var repository   =
                SignalsRepositoryFactory.Create();
            var signal = repository.GetVersionOfSignalByDate(signalID, startDate);

            SevereRedLightViolationsSeconds = srlvSeconds;
            var approachesForMetric = signal.GetApproachesForSignalThatSupportMetric(metricTypeID);

            //If there are phases in the database add the charts
            if (approachesForMetric.Any())
            {
                foreach (var approach in approachesForMetric)
                {
                    SignalPhaseList.Add(new RLMSignalPhase(
                                            startDate, endDate, binSize, SevereRedLightViolationsSeconds, approach, false));

                    if (approach.PermissivePhaseNumber != null && approach.PermissivePhaseNumber > 0)
                    {
                        SignalPhaseList.Add(new RLMSignalPhase(
                                                startDate, endDate, binSize, SevereRedLightViolationsSeconds, approach, true));
                    }
                }
            }
        }
コード例 #4
0
        public double GetTmcVolume(DateTime startDate, DateTime endDate, string signalId, int phase)
        {
            ISignalsRepository repository =
                SignalsRepositoryFactory.Create();
            var             signal         = repository.GetVersionOfSignalByDate(signalId, startDate);
            List <Detector> graphDetectors = signal.GetDetectorsForSignalByPhaseNumber(phase);

            List <int> tmcChannels = new List <int>();

            foreach (Detector gd in graphDetectors)
            {
                foreach (DetectionType dt in gd.DetectionTypes)
                {
                    if (dt.DetectionTypeID == 4)
                    {
                        tmcChannels.Add(gd.DetChannel);
                    }
                }
            }



            double count = (from cel in _db.Controller_Event_Log
                            where cel.Timestamp >= startDate &&
                            cel.Timestamp < endDate &&
                            cel.SignalID == signalId &&
                            tmcChannels.Contains(cel.EventParam) &&
                            cel.EventCode == 82
                            select cel).Count();

            return(count);
        }
コード例 #5
0
        public override List <string> CreateMetric()
        {
            base.CreateMetric();
            var sr              = SignalsRepositoryFactory.Create();
            var signal          = sr.GetVersionOfSignalByDate(SignalID, StartDate);
            var speedApproaches = signal.GetApproachesForSignalThatSupportMetric(10);

            if (speedApproaches.Count > 0)
            {
                foreach (var approach in speedApproaches)
                {
                    var speedDets = approach.GetDetectorsForMetricType(10);
                    foreach (var det in speedDets)
                    {
                        var chart = GetNewSpeedChart(det);
                        AddSpeedDataToChart(chart, det, StartDate, EndDate, SelectedBinSize);
                        var chartName = CreateFileName();
                        chart.ImageLocation = MetricFileLocation + chartName;
                        chart.SaveImage(MetricFileLocation + chartName, ChartImageFormat.Jpeg);
                        ReturnList.Add(MetricWebPath + chartName);
                    }
                }
            }
            return(ReturnList);
        }
コード例 #6
0
ファイル: FillSignalsViewModel.cs プロジェクト: gmonk/ATSPM
        public void SetPagedList()
        {
            var repository =
                SignalsRepositoryFactory.Create();
            //MOE.Common.Models.Repositories.SignalsRepositoryTest repository =
            //    new MOE.Common.Models.Repositories.SignalsRepositoryTest();
            var queryable = repository.GetAllEnabledSignals().AsQueryable();

            if (SelectedFilterID != null)
            {
                if (SelectedFilterID == 1)
                {
                    queryable = queryable.Where(q => q.SignalID.Contains(FilterCriteria)).Select(q => q);
                }
                else if (SelectedFilterID == 2)
                {
                    queryable = queryable.Where(q => q.PrimaryName.ToUpper().Contains(FilterCriteria.ToUpper()))
                                .Select(q => q);
                }
                else if (SelectedFilterID == 3)
                {
                    queryable = queryable.Where(q => q.SecondaryName.ToUpper().Contains(FilterCriteria.ToUpper()))
                                .Select(q => q);
                }
            }
            Signals = queryable.ToPagedList(Page, 5, OrderField, OrderDirection);
        }
コード例 #7
0
        private void GetMetricsForSignal(string signalID)
        {
            var repository =
                SignalsRepositoryFactory.Create();
            var signal = repository.GetLatestVersionOfSignalBySignalID(signalID);

            MetricsList = new List <SelectListItem>();
            var availableMetrics = signal.GetAvailableMetricsVisibleToWebsite().Where(m => m.ShowOnWebsite).OrderBy(m => m.DisplayOrder);

            if (signal != null)
            {
                foreach (var m in availableMetrics)
                {
                    if (SelectedMetricID != null && SelectedMetricID == m.MetricID)
                    {
                        MetricsList.Add(new SelectListItem
                        {
                            Value    = m.MetricID.ToString(),
                            Text     = m.ChartName,
                            Selected = true
                        });
                    }
                    else
                    {
                        MetricsList.Add(new SelectListItem {
                            Value = m.MetricID.ToString(), Text = m.ChartName
                        });
                    }
                }
            }
        }
コード例 #8
0
ファイル: TMCOptions.cs プロジェクト: gmonk/ATSPM
        public TMCInfo CreateMetric()
        {
            base.CreateMetric();

            var repository =
                SignalsRepositoryFactory.Create();
            var signal = repository.GetVersionOfSignalByDate(SignalID, StartDate);

            TmcInfo = new TMCInfo();
            var plans = PlanFactory.GetBasicPlans(StartDate, EndDate, SignalID);


            var ltr       = LaneTypeRepositoryFactory.Create();
            var laneTypes = ltr.GetAllLaneTypes();

            var mtr           = MovementTypeRepositoryFactory.Create();
            var movementTypes = mtr.GetAllMovementTypes();

            var dtr        = DirectionTypeRepositoryFactory.Create();
            var directions = dtr.GetAllDirections();


            CreateLaneTypeCharts(signal, "Vehicle", laneTypes, movementTypes, directions, plans, TmcInfo);
            CreateLaneTypeCharts(signal, "Exit", laneTypes, movementTypes, directions, plans, TmcInfo);
            CreateLaneTypeCharts(signal, "Bike", laneTypes, movementTypes, directions, plans, TmcInfo);


            return(TmcInfo);
        }
コード例 #9
0
ファイル: ChartFactoryTests.cs プロジェクト: dhan206/ATSPM
        public void Initialize()
        {
            Db.ClearTables();
            Db.PopulateSignal();
            Db.PopulateSignalsWithApproaches();
            Db.PopulateApproachesWithDetectors();
            var signals = Db.Signals;

            foreach (var signal in signals)
            {
                Db.PopulatePreemptAggregations(Convert.ToDateTime("1/1/2016"), Convert.ToDateTime("1/1/2018"), signal.SignalID, signal.VersionID);
            }

            ApproachRepositoryFactory.SetApproachRepository(new InMemoryApproachRepository(Db));
            PreemptAggregationDatasRepositoryFactory.SetArchivedMetricsRepository(
                new InMemoryPreemptAggregationDatasRepository(Db));
            MOE.Common.Models.Repositories.SignalsRepositoryFactory.SetSignalsRepository(
                new InMemorySignalsRepository(Db));
            MetricTypeRepositoryFactory.SetMetricsRepository(new InMemoryMetricTypeRepository(Db));
            ApplicationEventRepositoryFactory.SetApplicationEventRepository(new InMemoryApplicationEventRepository(Db));
            DetectorAggregationsRepositoryFactory.SetDetectorAggregationRepository(new InMemoryDetectorAggregationsRepository(Db));

            Models.Repositories.DirectionTypeRepositoryFactory.SetDirectionsRepository(
                new InMemoryDirectionTypeRepository());

            SignalsRepository = SignalsRepositoryFactory.Create();

            PreemptAggregationDatasRepositoryFactory.SetArchivedMetricsRepository(new InMemoryPreemptAggregationDatasRepository(Db));
        }
        public void Initialize()
        {
            Db.ClearTables();
            Db.PopulateSignal();
            Db.PopulateSignalsWithApproaches();
            Db.PopulateApproachesWithDetectors();
            var signals = Db.Signals;

            foreach (var signal in signals)
            {
                foreach (var approach in signal.Approaches)
                {
                    Db.PopulateApproachSplitFailAggregationsWithRandomRecords(Convert.ToDateTime("1/1/2016"),
                                                                              Convert.ToDateTime("1/1/2018"), approach);
                }
            }
            ApproachSplitFailAggregationRepositoryFactory.SetApplicationEventRepository(
                new InMemoryApproachSplitFailAggregationRepository(Db));
            MOE.Common.Models.Repositories.SignalsRepositoryFactory.SetSignalsRepository(
                new InMemorySignalsRepository(Db));
            MetricTypeRepositoryFactory.SetMetricsRepository(new InMemoryMetricTypeRepository(Db));
            ApplicationEventRepositoryFactory.SetApplicationEventRepository(new InMemoryApplicationEventRepository(Db));
            Models.Repositories.DirectionTypeRepositoryFactory.SetDirectionsRepository(
                new InMemoryDirectionTypeRepository());
            SignalsRepository = SignalsRepositoryFactory.Create();
        }
コード例 #11
0
ファイル: SplitFailOptions.cs プロジェクト: MDimitroff/ATSPM
        public override List <string> CreateMetric()
        {
            base.CreateMetric();
            //EndDate = EndDate.AddSeconds(59);
            var returnString     = new List <string>();
            var sr               = SignalsRepositoryFactory.Create();
            var signal           = sr.GetVersionOfSignalByDate(SignalID, StartDate);
            var metricApproaches = signal.GetApproachesForSignalThatSupportMetric(MetricTypeID);

            if (metricApproaches.Count > 0)
            {
                List <SplitFailPhase> splitFailPhases = new List <SplitFailPhase>();
                foreach (Approach approach in metricApproaches)
                {
                    if (approach.PermissivePhaseNumber != null && approach.PermissivePhaseNumber > 0)
                    {
                        splitFailPhases.Add(new SplitFailPhase(approach, this, true));
                    }
                    if (approach.ProtectedPhaseNumber > 0)
                    {
                        splitFailPhases.Add(new SplitFailPhase(approach, this, false));
                    }
                }
                splitFailPhases = splitFailPhases.OrderBy(s => s.PhaseNumberSort).ToList();
                foreach (var splitFailPhase in splitFailPhases)
                {
                    GetChart(splitFailPhase, returnString);
                }
            }
            return(returnString);
        }
コード例 #12
0
 protected void GetSignalObjects()
 {
     try
     {
         if (Signals == null)
         {
             Signals = new List <Models.Signal>();
         }
         if (Signals.Count == 0)
         {
             var signalRepository = SignalsRepositoryFactory.Create();
             foreach (var filterSignal in FilterSignals)
             {
                 if (!filterSignal.Exclude)
                 {
                     var signals =
                         signalRepository.GetSignalsBetweenDates(filterSignal.SignalId, StartDate, EndDate);
                     foreach (var signal in signals)
                     {
                         RemoveApproachesByFilter(filterSignal, signal);
                         signal.Approaches = signal.Approaches.OrderBy(a => a.ProtectedPhaseNumber).ToList();
                     }
                     Signals.AddRange(signals);
                 }
             }
         }
     }
     catch (Exception e)
     {
         var errorLog = ApplicationEventRepositoryFactory.Create();
         errorLog.QuickAdd(Assembly.GetExecutingAssembly().GetName().ToString(),
                           GetType().DisplayName(), e.TargetSite.ToString(), ApplicationEvent.SeverityLevels.High, e.Message);
         throw new Exception("Unable to apply signal filter");
     }
 }
コード例 #13
0
        public SpeedExportApproachDirectionCollection(DateTime startDate, DateTime endDate, string signalID,
                                                      int binSize)
        {
            var signalRepository =
                SignalsRepositoryFactory.Create();
            var signal         = signalRepository.GetLatestVersionOfSignalBySignalID(signalID);
            var distinctPhases = signal.GetDetectorsForSignalThatSupportAMetric(10);


            //If there are phases in the database add the charts
            if (distinctPhases.Count > 0)
            {
                foreach (var detector in distinctPhases)
                {
                    //Get the phase
                    var phase          = detector.Approach.ProtectedPhaseNumber;
                    var direction      = detector.Approach.DirectionType.Description;
                    var movementDelay  = detector.MovementDelay.Value;
                    var Decision_Point = detector.DecisionPoint.Value;
                    var MPH            = detector.Approach.MPH.Value;

                    var approachDirection =
                        new SpeedExportApproachDirection(
                            startDate, endDate, signalID, phase, detector.DetectorID
                            , direction, MPH, movementDelay, Decision_Point,
                            binSize, detector.MinSpeedFilter.Value,
                            detector.DistanceFromStopBar.Value);
                    List.Add(approachDirection);
                }
            }
        }
コード例 #14
0
ファイル: SignalPhaseCollection.cs プロジェクト: gmonk/ATSPM
        public SignalPhaseCollection(DateTime startDate, DateTime endDate, string signalID,
                                     bool showVolume, int binSize, int metricTypeId)
        {
            var repository = SignalsRepositoryFactory.Create();
            var signal     = repository.GetVersionOfSignalByDate(signalID, startDate);
            var approaches = signal.GetApproachesForSignalThatSupportMetric(metricTypeId);

            if (signal.Approaches != null && approaches.Count > 0)
            {
                //Parallel.ForEach(approaches, approach =>
                foreach (Models.Approach approach in approaches)
                {
                    var protectedSignalPhase = new SignalPhase(startDate, endDate, approach, showVolume, binSize,
                                                               metricTypeId, false);
                    SignalPhaseList.Add(protectedSignalPhase);
                    if (approach.PermissivePhaseNumber.HasValue)
                    {
                        var permissiveSignalPhase = new SignalPhase(startDate, endDate, approach, showVolume, binSize,
                                                                    metricTypeId, true);
                        SignalPhaseList.Add(permissiveSignalPhase);
                    }
                }//);
                //TODO: Should we remove phases with no cycles?
                SignalPhaseList = SignalPhaseList.OrderBy(s => s.Approach.ProtectedPhaseNumber).ToList();
            }
        }
コード例 #15
0
        public override List <string> CreateMetric()
        {
            base.CreateMetric();
            var signalRepository = SignalsRepositoryFactory.Create();

            Signal       = signalRepository.GetVersionOfSignalByDate(SignalID, StartDate);
            MetricTypeID = 6;
            var chart            = new Chart();
            var metricApproaches = Signal.GetApproachesForSignalThatSupportMetric(MetricTypeID);

            if (metricApproaches.Count > 0)
            {
                foreach (var approach in metricApproaches)
                {
                    var signalPhase = new SignalPhase(StartDate, EndDate, approach, ShowVolumes, SelectedBinSize,
                                                      MetricTypeID, false);
                    chart = GetNewChart();
                    AddDataToChart(chart, signalPhase);
                    var chartName = CreateFileName();
                    chart.ImageLocation = MetricFileLocation + chartName;
                    chart.SaveImage(MetricFileLocation + chartName, ChartImageFormat.Jpeg);
                    ReturnList.Add(MetricWebPath + chartName);
                }
            }

            return(ReturnList);
        }
コード例 #16
0
ファイル: Program.cs プロジェクト: gmonk/ATSPM
        static void Main(string[] args)
        {
            IApplicationEventRepository errorRepository  = ApplicationEventRepositoryFactory.Create();
            SignalFtpOptions            signalFtpOptions = new SignalFtpOptions(
                Convert.ToInt32(ConfigurationManager.AppSettings["SNMPTimeout"]),
                Convert.ToInt32(ConfigurationManager.AppSettings["SNMPRetry"]),
                Convert.ToInt32(ConfigurationManager.AppSettings["SNMPPort"]),
                Convert.ToBoolean(ConfigurationManager.AppSettings["DeleteFilesAfterFTP"]),
                ConfigurationManager.AppSettings["LocalDirectory"],
                Convert.ToInt32(ConfigurationManager.AppSettings["FTPConnectionTimeoutInSeconds"]),
                Convert.ToInt32(ConfigurationManager.AppSettings["FTPReadTimeoutInSeconds"]),
                Convert.ToBoolean(ConfigurationManager.AppSettings["skipCurrentLog"]),
                Convert.ToBoolean(ConfigurationManager.AppSettings["RenameDuplicateFiles"]),
                Convert.ToInt32(ConfigurationManager.AppSettings["waitBetweenFileDownloadMilliseconds"])
                );
            int maxThreads = Convert.ToInt32(ConfigurationManager.AppSettings["MaxThreads"]);


            MOE.Common.Models.SPM db = new MOE.Common.Models.SPM();
            ISignalsRepository    signalsRepository = SignalsRepositoryFactory.Create(db);
            var signals = signalsRepository.GetLatestVersionOfAllSignalsForFtp();
            var options = new ParallelOptions {
                MaxDegreeOfParallelism = maxThreads
            };

            Parallel.ForEach(signals.AsEnumerable(), options, signal =>
                             //foreach (var signal in signals)
            {
                try
                {
                    MOE.Common.Business.SignalFtp signalFtp = new MOE.Common.Business.SignalFtp(signal, signalFtpOptions);

                    if (!Directory.Exists(signalFtpOptions.LocalDirectory + signal.SignalID))
                    {
                        Directory.CreateDirectory(signalFtpOptions.LocalDirectory + signal.SignalID);
                    }

                    //Get the records over FTP
                    if (CheckIfIPAddressIsValid(signal))
                    {
                        try
                        {
                            signalFtp.GetCurrentRecords();
                        }
                        catch (AggregateException ex)
                        {
                            Console.WriteLine("Error At Highest Level for signal " + ex.Message);
                            errorRepository.QuickAdd("FTPFromAllControllers", "Main", "Main Loop", MOE.Common.Models.ApplicationEvent.SeverityLevels.Medium, "Error At Highest Level for signal " + signal.SignalID);
                        }
                    }
                }
                catch (AggregateException ex)
                {
                    Console.WriteLine("Error At Highest Level for signal " + ex.Message);
                    errorRepository.QuickAdd("FTPFromAllControllers", "Main", "Main Loop", MOE.Common.Models.ApplicationEvent.SeverityLevels.Medium, "Error At Highest Level for signal " + signal.SignalID);
                }
            }
                             );
        }
コード例 #17
0
ファイル: PreemptServiceMetric.cs プロジェクト: gmonk/ATSPM
        private string GetSignalLcation(string SignalID)
        {
            var sr = SignalsRepositoryFactory.Create();

            var location = sr.GetSignalLocation(SignalID);

            return(location);
        }
コード例 #18
0
        public void TestMetric24HrVs15Min()
        {
            //5030 has 8 phases, with 6 to 8 detectors per phase.  There is Stop Bar, Lane-by-Lane Count,
            // Lane-by-Lane with Speed Restriction, Advanced Count, Advanced Spped as the detectin types for he different
            // detectors.  THis signals has everything and is a good one to test for everything UDOT uses for a signal.

            var signalId        = "5030";
            int metricTypeId    = 6;
            var stringstartTime = "10/24/2018 3:30 PM";

            var startTime        = DateTime.Parse(stringstartTime, System.Globalization.CultureInfo.InvariantCulture);
            var endTime24Hrs     = startTime.AddDays(1);
            var endTime15Mins    = startTime.AddMinutes(15);
            var signalRepository = SignalsRepositoryFactory.Create();
            var signal           = signalRepository.GetVersionOfSignalByDate(signalId, startTime);
            var metricApproaches = signal.GetApproachesForSignalThatSupportMetric(metricTypeId);

            if (metricApproaches.Count > 0)
            {
                foreach (var approach in metricApproaches)
                {
                    var signalPhase24Hrs  = new Common.Business.SignalPhase(startTime, endTime24Hrs, approach, true, 15, metricTypeId, false);
                    var signalPhase15Mins = new Common.Business.SignalPhase(startTime, endTime15Mins, approach, true, 15, metricTypeId, false);
                    Assert.IsTrue(signalPhase24Hrs.Cycles.Count > signalPhase15Mins.Cycles.Count);
                    for (int i = 0; i < signalPhase15Mins.Cycles.Count; i++)
                    {
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].EndTime == signalPhase15Mins.Cycles[i].EndTime);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].GreenEvent == signalPhase15Mins.Cycles[i].GreenEvent);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].GreenLineY == signalPhase15Mins.Cycles[i].GreenLineY);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].RedLineY == signalPhase15Mins.Cycles[i].RedLineY);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].StartTime == signalPhase15Mins.Cycles[i].StartTime);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].TotalArrivalOnGreen == signalPhase15Mins.Cycles[i].TotalArrivalOnGreen);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].TotalArrivalOnRed == signalPhase15Mins.Cycles[i].TotalArrivalOnRed);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].TotalArrivalOnYellow == signalPhase15Mins.Cycles[i].TotalArrivalOnYellow);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].TotalDelay == signalPhase15Mins.Cycles[i].TotalDelay);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].TotalGreenTime == signalPhase15Mins.Cycles[i].TotalGreenTime);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].TotalGreenTimeMilliseconds == signalPhase15Mins.Cycles[i].TotalGreenTimeMilliseconds);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].TotalRedTime == signalPhase15Mins.Cycles[i].TotalRedTime);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].TotalRedTimeMilliseconds == signalPhase15Mins.Cycles[i].TotalRedTimeMilliseconds);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].TotalTime == signalPhase15Mins.Cycles[i].TotalTime);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].TotalTimeMilliseconds == signalPhase15Mins.Cycles[i].TotalTimeMilliseconds);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].TotalVolume == signalPhase15Mins.Cycles[i].TotalVolume);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].TotalYellowTime == signalPhase15Mins.Cycles[i].TotalYellowTime);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].TotalYellowTimeMilliseconds == signalPhase15Mins.Cycles[i].TotalYellowTimeMilliseconds);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].YellowEvent == signalPhase15Mins.Cycles[i].YellowEvent);
                        Assert.IsTrue(signalPhase24Hrs.Cycles[i].YellowLineY == signalPhase15Mins.Cycles[i].YellowLineY);
                        for (int j = 0; j < signalPhase15Mins.Cycles[i].DetectorEvents.Count; j++)
                        {
                            Assert.IsTrue(signalPhase24Hrs.Cycles[i].DetectorEvents[j].ArrivalType == signalPhase15Mins.Cycles[i].DetectorEvents[j].ArrivalType);
                            Assert.IsTrue(signalPhase24Hrs.Cycles[i].DetectorEvents[j].Delay == signalPhase15Mins.Cycles[i].DetectorEvents[j].Delay);
                            Assert.IsTrue(signalPhase24Hrs.Cycles[i].DetectorEvents[j].TimeStamp == signalPhase15Mins.Cycles[i].DetectorEvents[j].TimeStamp);
                            Assert.IsTrue(signalPhase24Hrs.Cycles[i].DetectorEvents[j].YPoint == signalPhase15Mins.Cycles[i].DetectorEvents[j].YPoint);
                        }
                    }
                }
            }
        }
コード例 #19
0
        public void CopyVersionTest()
        {
            var               signalsRepository = SignalsRepositoryFactory.Create();
            Signal            signal            = signalsRepository.GetLatestVersionOfSignalBySignalID("7185");
            SignalsController signalsController = new SignalsController();
            var               actionResult      = signalsController.CopyVersion(signal);

            Assert.IsNotNull(actionResult);
        }
コード例 #20
0
ファイル: SignalInfoBoxViewModel.cs プロジェクト: gmonk/ATSPM
        public SignalInfoBoxViewModel(string signalID)
        {
            var repository =
                SignalsRepositoryFactory.Create();
            var signal = repository.GetLatestVersionOfSignalBySignalID(signalID);

            SetTitle(signal);
            SetDescription(signal);
            SetMetrics(signal);
            SignalID = signalID;
        }
コード例 #21
0
        private void GetMetricsForSignal(string signalID)
        {
            var repository =
                SignalsRepositoryFactory.Create();
            var signal = repository.GetLatestVersionOfSignalBySignalID(signalID);

            MetricsList = new List <SelectListItem>();
            //var availableMetrics = signal.GetAvailableMetricsVisibleToWebsite().Where(m => m.ShowOnWebsite);
            var availableMetrics = signal.GetAvailableMetricsVisibleToWebsite().Where(m => m.ShowOnWebsite).OrderBy(m => m.DisplayOrder);

            if (signal != null)
            {
                foreach (var m in availableMetrics)
                {
                    if (SelectedMetricID != null && SelectedMetricID == m.MetricID)
                    {
                        // Andre -- Commented out parts added to try to get this to make the Pudue Phase Tremination hte default chart.
                        // this is for bug 894.  This will select it, but not get the options showing for it.  Bug 896 is higher on the list for Mark Taylor.
                        //if (m.ChartName.Contains("Purdue Phase Termination"))
                        //{
                        MetricsList.Add(new SelectListItem
                        {
                            Value    = m.MetricID.ToString(),
                            Text     = m.ChartName,
                            Selected = true
                        });
                        //}
                        //else
                        //{
                        //MetricsList.Add(new SelectListItem
                        //{
                        //    Value = m.MetricID.ToString(),
                        //    Text = m.ChartName
                        //    //Selected = true
                        //});
                        //}
                    }
                    else
                    {
                        //if (m.ChartName.Contains("Purdue Phase Termination"))
                        //{
                        //    MetricsList.Add(new SelectListItem {Value = m.MetricID.ToString(), Text = m.ChartName, Selected = true});
                        //}
                        //else
                        //{
                        MetricsList.Add(new SelectListItem {
                            Value = m.MetricID.ToString(), Text = m.ChartName
                        });
                        //}
                    }
                }
            }
        }
コード例 #22
0
        private static int FindChannel(string SignalID, int Phase)
        {
            var smh  = SignalsRepositoryFactory.Create();
            var sig  = smh.GetLatestVersionOfSignalBySignalID(SignalID);
            var dets = sig.GetDetectorsForSignalByPhaseNumber(Phase);

            if (dets.Count() > 0)
            {
                return(dets.FirstOrDefault().DetChannel);
            }
            return(0);
        }
コード例 #23
0
        /// <summary>
        ///     Alternate Constructor for PCD type data.
        /// </summary>
        /// <param name="signalid"></param>
        /// <param name="approach"></param>
        public DetectorCollection(Approach approach)
        {
            SignalId = approach.SignalID;
            var repository =
                SignalsRepositoryFactory.Create();


            var PCDDetectors = approach.GetDetectorsForMetricType(6);

            foreach (var row in PCDDetectors)
            {
                var Detector = new Detector(row);
                Items.Add(Detector);
            }
        }
コード例 #24
0
 //public List<SPMWatchDogErrorEvent> ErrorMessages = new List<SPMWatchDogErrorEvent>();
 public void StartScan()
 {
     if (!Settings.WeekdayOnly || Settings.WeekdayOnly && ScanDate.DayOfWeek != DayOfWeek.Saturday &&
         ScanDate.DayOfWeek != DayOfWeek.Sunday)
     {
         var watchDogErrorEventRepository = SPMWatchDogErrorEventRepositoryFactory.Create();
         var signalRepository             = SignalsRepositoryFactory.Create();
         var signals = signalRepository.EagerLoadAllSignals();
         CheckForRecords(signals);
         CheckAllSignals(signals);
         CheckSignalsWithData();
         CheckApplicationEvents(signals);
         CreateAndSendEmail();
     }
 }
コード例 #25
0
        public ActionResult AddSignal(string id)
        {
            var signalRepository = SignalsRepositoryFactory.Create();

            if (!String.IsNullOrEmpty(id) && !signalRepository.Exists(id))
            {
                DatabaseArchiveExcludedSignal databaseArchiveExcludedSignal = new DatabaseArchiveExcludedSignal();
                databaseArchiveExcludedSignal.SignalId          = id;
                databaseArchiveExcludedSignal.SignalDescription = signalRepository.GetSignalDescription(id);
                var excludedSignalRepository = DatabaseArchiveExcludedSignalsRepositoryFactory.Create();
                excludedSignalRepository.AddToExcludedList(id);
                return(PartialView("EditorTemplates/DatabaseArchiveExcludedSignal", databaseArchiveExcludedSignal));
            }
            return(Content("Unable to load signal"));
        }
コード例 #26
0
ファイル: Signal.cs プロジェクト: gmonk/ATSPM
        public Signal(string signalID, DateTime startDate, DateTime endDate,
                      List <int> eventCodes, int startOfCycle)
        {
            SignalID   = signalID;
            StartDate  = startDate;
            EndDate    = endDate;
            EventCodes = eventCodes;
            var repository =
                SignalsRepositoryFactory.Create();

            SignalModel = repository.GetLatestVersionOfSignalBySignalID(signalID);
            Detectors   = SignalModel.GetDetectorsForSignal();
            Plans       = new PlansBase(signalID, startDate, endDate);

            GetPhases(startOfCycle);
        }
コード例 #27
0
        /// <summary>
        ///     Constructor Used for Split monitor
        /// </summary>
        /// <param name="phasenumber"></param>
        /// <param name="signalID"></param>
        /// <param name="CycleEventsTable"></param>
        public AnalysisPhase(int phasenumber, string signalID, List <Controller_Event_Log> CycleEventsTable)
        {
            var repository =
                SignalsRepositoryFactory.Create();
            var signal = repository.GetLatestVersionOfSignalBySignalID(signalID);

            PhaseNumber = phasenumber;
            SignalID    = signalID;
            IsOverlap   = false;
            var pedEvents   = FindPedEvents(CycleEventsTable, phasenumber);
            var phaseEvents = FindPhaseEvents(CycleEventsTable, phasenumber);

            Cycles = new AnalysisPhaseCycleCollection(phasenumber, SignalID, phaseEvents, pedEvents);
            var approach = signal.Approaches.FirstOrDefault(a => a.ProtectedPhaseNumber == phasenumber);

            Direction = approach != null ? approach.DirectionType.Description : "Unknown";
        }
コード例 #28
0
        public override List <string> CreateMetric()
        {
            base.CreateMetric();
            var signalsRepository = SignalsRepositoryFactory.Create();
            var signal            = signalsRepository.GetVersionOfSignalByDate(SignalID, StartDate);

            CreateLegend();

            var eventLogs = new ControllerEventLogs(SignalID, StartDate, EndDate,
                                                    new List <int> {
                EVENT_DET, EVENT_GREEN, EVENT_RED
            });

            //Get phase + check for opposing phase before creating chart
            var ebPhase = signal.Approaches.FirstOrDefault(x => x.ProtectedPhaseNumber == 6);

            if (ebPhase != null && signal.Approaches.Any(x => x.ProtectedPhaseNumber == 2))
            {
                CreateChart(ebPhase, eventLogs, signal);
            }

            var nbPhase = signal.Approaches.FirstOrDefault(x => x.ProtectedPhaseNumber == 8);

            if (nbPhase != null && signal.Approaches.Any(x => x.ProtectedPhaseNumber == 4))
            {
                CreateChart(nbPhase, eventLogs, signal);
            }

            var wbPhase = signal.Approaches.FirstOrDefault(x => x.ProtectedPhaseNumber == 2);

            if (wbPhase != null && signal.Approaches.Any(x => x.ProtectedPhaseNumber == 6))
            {
                CreateChart(wbPhase, eventLogs, signal);
            }

            var sbPhase = signal.Approaches.FirstOrDefault(x => x.ProtectedPhaseNumber == 4);

            if (sbPhase != null && signal.Approaches.Any(x => x.ProtectedPhaseNumber == 8))
            {
                CreateChart(sbPhase, eventLogs, signal);
            }

            return(ReturnList);
        }
コード例 #29
0
ファイル: LinkPivotPCDDisplay.cs プロジェクト: gmonk/ATSPM
        //Total arrival on green after adjustments

        //Total percent arrival on green after adjustments

        //Total volume after adjustments

        //File location of the upstream after adjustment pcd

        //File location of the upstream before pcd

        /// <summary>
        ///     Generates PCD charts for upstream and downstream detectors based on
        ///     a Link Pivot Link
        /// </summary>
        /// <param name="upstreamSignalId"></param>
        /// <param name="upstreamDirection"></param>
        /// <param name="downstreamSignalId"></param>
        /// <param name="downstreamDirection"></param>
        /// <param name="delta"></param>
        /// <param name="startDate"></param>
        /// <param name="endDate"></param>
        /// <param name="maxYAxis"></param>
        public LinkPivotPCDDisplay(string upstreamSignalId, string upstreamDirection,
                                   string downstreamSignalId, string downstreamDirection, int delta,
                                   DateTime startDate, DateTime endDate, int maxYAxis)
        {
            var signalRepository      = SignalsRepositoryFactory.Create();
            var upstreamSignal        = signalRepository.GetVersionOfSignalByDate(upstreamSignalId, startDate);
            var downstreamSignal      = signalRepository.GetVersionOfSignalByDate(downstreamSignalId, startDate);
            var upApproachToAnalyze   = GetApproachToAnalyze(upstreamSignal, upstreamDirection);
            var downApproachToAnalyze = GetApproachToAnalyze(downstreamSignal, downstreamDirection);

            if (upApproachToAnalyze != null)
            {
                GeneratePcd(upApproachToAnalyze, delta, startDate, endDate, true, maxYAxis);
            }
            if (downApproachToAnalyze != null)
            {
                GeneratePcd(downApproachToAnalyze, delta, startDate, endDate, false, maxYAxis);
            }
        }
コード例 #30
0
        public AdvancedSpeedDataExport(string signalId, string location, DateTime startDate, DateTime endDate,
                                       int binSize, List <string> DayOfweek)
        {
            var repository =
                SignalsRepositoryFactory.Create();
            var signal = repository.GetLatestVersionOfSignalBySignalID(signalId);
            //Get the dates that match the daytype for the given period
            var dtList   = new List <DateTime>();
            var tempDate = startDate;

            while (tempDate <= endDate)
            {
                if (DayOfweek.Contains(tempDate.DayOfWeek.ToString()))
                {
                    dtList.Add(tempDate);
                }
                tempDate = tempDate.AddDays(1);
            }
            var table = signal.GetDetectorsForSignalThatSupportAMetric(10);

            foreach (var row in table)
            {
                var direction = row.Approach.DirectionType.Description;
                Approaches.Add(direction, new List <SpeedExportAvgSpeed>());
            }
            //Create approach direction collections for each date in the list
            foreach (var dt in dtList)
            {
                var dtEnd = new DateTime(dt.Year, dt.Month, dt.Day,
                                         endDate.Hour, endDate.Minute, endDate.Second);
                var approachDirectioncollection =
                    new SpeedExportApproachDirectionCollection(dt,
                                                               dtEnd, signalId, binSize);
                foreach (var sad in approachDirectioncollection.List)
                {
                    foreach (var sea in sad.AvgSpeeds.Items)
                    {
                        Approaches[sad.Direction].Add(sea);
                    }
                }
            }
        }