public Task <ITimeSeriesValue[]> Run(IFrame frame, IFrame[] futureFrames) { NProcessed++; if (m_nextTimeStamp == Gemstone.Ticks.MinValue) { m_nextTimeStamp = frame.Timestamp; } if (m_nextTimeStamp <= frame.Timestamp) { IFrame input = RouteInput(frame); IFrame[] forwardFrames = futureFrames.Skip(futureFrames.Length - NFutureFrames).Select(f => RouteInput(f)).ToArray(); m_nextTimeStamp = m_nextTimeStamp + (long)(Gemstone.Ticks.PerSecond * 1.0 / ((double)m_instance.FramesPerSecond)); Task <ITimeSeriesValue[]> task = m_instance.Run(input, m_pastPoints.ToArray(), forwardFrames); if (m_instance.PrevFrames > 0) { m_pastPoints.Enqueue(input); if (m_pastPoints.Count > m_instance.PrevFrames) { m_pastPoints.Dequeue(); } } return(task); } else { return(Task <ITimeSeriesValue[]> .FromResult(new ITimeSeriesValue[0])); } }
private ITimeSeriesValue[] ProcessLastEvent(Gemstone.Ticks ticks) { if (!m_isOver) { return(new ITimeSeriesValue[0]); } double length = ticks - m_lastCrossing; return(new ITimeSeriesValue[] { new AdaptEvent("Ringdown Event Detected", m_lastCrossing, length) }); }
public AnalyticProcessor(Analytic analytic, Dictionary <string, int> framesPerSecond) { m_nextTimeStamp = Gemstone.Ticks.MinValue; m_analytic = analytic; m_instance = CreateAnalytic(m_analytic, framesPerSecond); InputNames = m_instance.InputNames().ToList(); m_pastPoints = new Queue <IFrame>(m_instance.PrevFrames); NProcessed = 0; }
private List <AdaptEvent> GetPoints(string root, DateTime start, DateTime end) { List <AdaptEvent> results = new List <AdaptEvent>(); byte[] data = File.ReadAllBytes(root); EventSummary pt = new EventSummary(data); if (pt.Tmin > end) { return(new List <AdaptEvent>()); } if (pt.Tmax < start) { return(new List <AdaptEvent>()); } int index = EventSummary.NSize; while (index < data.Length) { long ts = BitConverter.ToInt64(data, index); double value = BitConverter.ToDouble(data, index + 8); double[] parameters = new double[m_parameters.Count()]; for (int i = 0; i < parameters.Count(); i++) { parameters[i] = BitConverter.ToDouble(data, index + 8 + 8 + i * 8); } Gemstone.Ticks ticks = new Gemstone.Ticks(ts); index = index + 8 + 8 + parameters.Count() * 8; if (ticks.Value < start.Ticks || ticks.Value > end.Ticks) { continue; } AdaptEvent point = new AdaptEvent(m_guid, ticks, value, m_parameters.Select((key, i) => new KeyValuePair <string, double>(key, parameters[i])).ToArray()); point.Parameters = parameters; results.Add(point); } return(results); }
public override ITimeSeriesValue[] Compute(IFrame frame, IFrame[] previousFrames, IFrame[] future) { List <ITimeSeriesValue> result = new List <ITimeSeriesValue>(); double Nrms = previousFrames.Sum(v => (!double.IsNaN(v.Measurements["Input Signal"].Value) ? 0.0D : 1.0D)); double rms = previousFrames.Sum(v => (!double.IsNaN(v.Measurements["Input Signal"].Value)? 0.0D : v.Measurements[""].Value / Nrms)); rms = Math.Sqrt(rms); m_RMSmed.Enqueue(rms); int NfilterOrder = m_settings.FilterOrder * m_fps; NfilterOrder = NfilterOrder + 1 - NfilterOrder % 2; if (m_RMSmed.Count > NfilterOrder) { m_RMSmed.Dequeue(); } double threshold = m_settings.Threshold * m_RMSmed.ToArray().OrderBy(o => o).ToList()[((NfilterOrder - 1) / 2)]; // Apply median filter to RMS to establish the threshold result.Add(new AdaptValue("RMS Threshold", threshold, frame.Timestamp)); result.Add(new AdaptValue("RMS Value", rms, frame.Timestamp)); if (rms > threshold && !m_isOver) { m_isOver = true; m_lastCrossing = frame.Timestamp; } if (m_isOver && rms < threshold) { double length = frame.Timestamp - m_lastCrossing; result.Add(new AdaptEvent("Ringdown Event Detected", m_lastCrossing, length)); m_isOver = false; } return(result.ToArray()); }
private ITimeSeriesValue[] CheckLastPoint(Gemstone.Ticks ticks) { List <AdaptEvent> result = new List <AdaptEvent>(); if (m_currentExcursion == ExcursionType.UpperAndLower) { return(result.ToArray()); } double length = ticks - m_lastCrossing; if (m_currentExcursion == ExcursionType.Upper && length > m_settings.minDur * Gemstone.Ticks.PerSecond) { result.Add(new AdaptEvent("Excursion Detected", m_lastCrossing, length, new KeyValuePair <string, double>("Deviation", m_settings.upper + m_differenceUpper))); } if (m_currentExcursion == ExcursionType.Lower && length > m_settings.minDur * Gemstone.Ticks.PerSecond) { result.Add(new AdaptEvent("Excursion Detected", m_lastCrossing, length, new KeyValuePair <string, double>("Deviation", m_settings.lower - m_differenceLower))); } return(result.ToArray()); }
private ITimeSeriesValue[] CheckLastPoint(Gemstone.Ticks ticks) { List <AdaptEvent> result = new List <AdaptEvent>(); return(result.ToArray()); }
public override Task <ITimeSeriesValue[]> CompleteComputation(Gemstone.Ticks ticks) { return(Task.Run(() => CheckLastPoint(ticks))); }
public override Task <ITimeSeriesValue[]> CompleteComputation(Gemstone.Ticks ticks) { return(Task.Run(() => ProcessLastEvent(ticks))); }
private List <GraphPoint> GetPoints(string root, int depth, int currentLevel, DateTime start, DateTime end) { List <GraphPoint> results = new List <GraphPoint>(); // If we grab Summary points from .bin files (1 second of Data) if (currentLevel == NLevels) { foreach (string file in Directory.GetFiles(root, "*.bin").OrderBy(item => item)) { byte[] data = File.ReadAllBytes(file); GraphPoint pt = new GraphPoint(data); if (pt.Tmin > end) { continue; } if (pt.Tmax < start) { continue; } if ((pt.Tmin >= start && pt.Tmax <= end) && depth == NLevels) { results.Add(pt); } else if (depth == NLevels) { results.Add(Aggregate(GetPoints(file, NLevels + 1, NLevels + 1, start, end))); } else { results.AddRange(GetPoints(file, depth, currentLevel + 1, start, end)); } } return(results); } //If we grab actual points from .bin File if (currentLevel > NLevels) { byte[] data = File.ReadAllBytes(root); GraphPoint pt = new GraphPoint(data); if (pt.Tmin > end) { return(new List <GraphPoint>()); } if (pt.Tmax < start) { return(new List <GraphPoint>()); } int index = GraphPoint.NSize; while (index < data.Length) { long ts = BitConverter.ToInt64(data, index); double value = BitConverter.ToDouble(data, index + 8); Gemstone.Ticks ticks = new Gemstone.Ticks(ts); index = index + 8 + 8; if (ticks.Value < start.Ticks || ticks.Value > end.Ticks) { continue; } GraphPoint point = new GraphPoint(); point.N = 1; point.Max = value; point.Min = value; point.Sum = value; point.SquaredSum = value * value; point.Tmax = ticks; point.Tmin = ticks; results.Add(point); } return(results); } // if we grab summary points from .summary files int nextLevel = currentLevel + 1; foreach (string folder in Directory.GetDirectories(root).OrderBy(item => item)) { byte[] data = File.ReadAllBytes(folder + Path.DirectorySeparatorChar + "summary.node"); GraphPoint pt = new GraphPoint(data); if (pt.Tmin > end) { continue; } if (pt.Tmax < start) { continue; } if ((pt.Tmin >= start && pt.Tmax <= end) && currentLevel == depth) { results.Add(pt); } else if (currentLevel >= depth) { results.Add(Aggregate(GetPoints(folder, NLevels + 1, nextLevel, start, end))); } else { results.AddRange(GetPoints(folder, depth, nextLevel, start, end)); } } return(results); }
public override ITimeSeriesValue[] Compute(IFrame frame, IFrame[] previousFrames, IFrame[] future) { List <AdaptEvent> result = new List <AdaptEvent>(); double value = frame.Measurements["Signal"].Value; double prevValue = previousFrames.FirstOrDefault()?.Measurements["Signal"].Value ?? double.NaN; if (double.IsNaN(value)) { return(result.ToArray()); } if (m_settings.excursionType == ExcursionType.Lower || m_settings.excursionType == ExcursionType.UpperAndLower) { // On switch from Ok to in Alarm if (value < m_settings.lower && (prevValue >= m_settings.lower || double.IsNaN(prevValue))) { m_lastCrossing = frame.Timestamp; m_differenceLower = m_settings.lower - value; m_currentExcursion = ExcursionType.Lower; } // On switch from in Alarm to OK else if (value > m_settings.lower && (prevValue <= m_settings.lower)) { double length = frame.Timestamp - m_lastCrossing; if (length > m_settings.minDur * Gemstone.Ticks.PerSecond) { result.Add(new AdaptEvent("Excursion Detected", m_lastCrossing, length, new KeyValuePair <string, double>("Deviation", m_settings.lower - m_differenceLower))); } m_currentExcursion = ExcursionType.UpperAndLower; } if ((m_settings.lower - value) > m_differenceLower) { m_differenceLower = (m_settings.lower - value); } } if (m_settings.excursionType == ExcursionType.Upper || m_settings.excursionType == ExcursionType.UpperAndLower) { // On switch from Ok to in Alarm if (value > m_settings.upper && (prevValue <= m_settings.upper || double.IsNaN(prevValue))) { m_lastCrossing = frame.Timestamp; m_differenceUpper = value - m_settings.upper; m_currentExcursion = ExcursionType.Upper; } // On switch from in Alarm to OK else if (value < m_settings.upper && (prevValue >= m_settings.upper)) { double length = frame.Timestamp - m_lastCrossing; if (length > m_settings.minDur * Gemstone.Ticks.PerSecond) { result.Add(new AdaptEvent("Excursion Detected", m_lastCrossing, length, new KeyValuePair <string, double>("Deviation", m_settings.upper + m_differenceUpper))); } m_currentExcursion = ExcursionType.UpperAndLower; } if ((value - m_settings.upper) > m_differenceUpper) { m_differenceUpper = (value - m_settings.upper); } } return(result.ToArray()); }
public Task <ITimeSeriesValue[]> RunCleanup(Gemstone.Ticks ticks) { return(m_instance.CompleteComputation(ticks)); }
public virtual Task <ITimeSeriesValue[]> CompleteComputation(Gemstone.Ticks ticks) { return(Task.FromResult(new ITimeSeriesValue[0])); }