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