/// <summary>
/// Finds the best match for the target.
/// </summary>
public ProcessedDataSetType FindBestMatch(string rawDataSetName, ProcessedDataSetType target)
{
if (target != null && this.ProcessedDataSets != null)
{
// try for match on name.
foreach (ProcessedDataSetType dataset in this.ProcessedDataSets)
{
if (dataset.DataSetName == rawDataSetName)
{
if (target.Name == dataset.Name)
{
return(dataset);
}
}
}
// try for match on aggregate.
foreach (ProcessedDataSetType dataset in this.ProcessedDataSets)
{
if (dataset.DataSetName == rawDataSetName)
{
if (target.AggregateName == dataset.AggregateName)
{
return(dataset);
}
}
}
}
// nothing found.
return(null);
}
/// <summary>
/// Returns the values in the specified processed dataset.
/// </summary>
public SortedDictionary <DateTime, DataValue> GetProcessedValues(ProcessedDataSetType dataset)
{
if (dataset != null)
{
return(ToDataValues(dataset.Values));
}
return(new SortedDictionary <DateTime, DataValue>());
}
/// <summary>
/// Adds or updates a values in the specified processed dataset.
/// </summary>
public void UpdateProcessedValues(ProcessedDataSetType dataset, params DataValue[] newValues)
{
SortedDictionary <DateTime, DataValue> existingValues = ToDataValues(dataset.Values);
if (newValues != null)
{
foreach (DataValue newValue in newValues)
{
existingValues[newValue.SourceTimestamp] = newValue;
}
}
dataset.Values = ToValueTypes(existingValues);
}
/// <summary>
/// Sets the values for the specified processed dataset.
/// </summary>
public void SetProcessedValues(ProcessedDataSetType dataset, IList <DataValue> newValues)
{
SortedDictionary <DateTime, DataValue> values = new SortedDictionary <DateTime, DataValue>();
if (newValues != null)
{
foreach (DataValue newValue in newValues)
{
values[newValue.SourceTimestamp] = newValue;
}
}
dataset.Values = ToValueTypes(values);
}
/// <summary>
/// Removes a dataset.
/// </summary>
/// <param name="dataset"></param>
public void RemoveDataSet(ProcessedDataSetType dataset)
{
if (dataset != null)
{
List <ProcessedDataSetType> datasets = new List <ProcessedDataSetType>();
if (this.ProcessedDataSets != null)
{
datasets.AddRange(this.ProcessedDataSets);
}
int index = datasets.IndexOf(dataset);
if (index >= 0)
{
datasets.RemoveAt(index);
this.ProcessedDataSets = datasets.ToArray();
}
}
}
/// <summary>
/// Adds a new dataset.
/// </summary>
public void AddDataSet(ProcessedDataSetType dataset)
{
List <ProcessedDataSetType> datasets = new List <ProcessedDataSetType>();
if (this.ProcessedDataSets != null)
{
datasets.AddRange(this.ProcessedDataSets);
}
// check for duplicates.
if (datasets.Contains(dataset))
{
return;
}
dataset.Name = GetName(dataset);
datasets.Add(dataset);
this.ProcessedDataSets = datasets.ToArray();
}
/// <summary>
/// Constructs a name for the processed dataset.
/// </summary>
public static string GetName(ProcessedDataSetType dataset)
{
StringBuilder buffer = new StringBuilder();
buffer.Append(dataset.AggregateName);
buffer.Append(" [");
buffer.Append(dataset.ProcessingInterval);
buffer.Append(':');
buffer.Append((dataset.Stepped) ? "Stepped" : "Sloped");
buffer.Append('/');
buffer.Append((dataset.UseSlopedExtrapolation) ? "Sloped" : "Stepped");
buffer.Append(':');
buffer.Append((dataset.TreatUncertainAsBad)?"AsBad":"AsUncertain");
buffer.Append(':');
buffer.Append(dataset.PercentBad);
buffer.Append('/');
buffer.Append(dataset.PercentGood);
buffer.Append("]");
return(buffer.ToString());
}
/// <summary>
/// Adds or updates a values in the specified processed dataset.
/// </summary>
public void UpdateProcessedValues(ProcessedDataSetType dataset, params DataValue[] newValues)
{
SortedDictionary<DateTime,DataValue> existingValues = ToDataValues(dataset.Values);
if (newValues != null)
{
foreach (DataValue newValue in newValues)
{
existingValues[newValue.SourceTimestamp] = newValue;
}
}
dataset.Values = ToValueTypes(existingValues);
}
/// <summary>
/// Returns the values in the specified processed dataset.
/// </summary>
public SortedDictionary<DateTime, DataValue> GetProcessedValues(ProcessedDataSetType dataset)
{
if (dataset != null)
{
return ToDataValues(dataset.Values);
}
return new SortedDictionary<DateTime,DataValue>();
}
/// <summary>
/// Removes a dataset.
/// </summary>
/// <param name="dataset"></param>
public void RemoveDataSet(ProcessedDataSetType dataset)
{
if (dataset != null)
{
List<ProcessedDataSetType> datasets = new List<ProcessedDataSetType>();
if (this.ProcessedDataSets != null)
{
datasets.AddRange(this.ProcessedDataSets);
}
int index = datasets.IndexOf(dataset);
if (index >= 0)
{
datasets.RemoveAt(index);
this.ProcessedDataSets = datasets.ToArray();
}
}
}
/// <summary>
/// Adds a new dataset.
/// </summary>
public void AddDataSet(ProcessedDataSetType dataset)
{
List<ProcessedDataSetType> datasets = new List<ProcessedDataSetType>();
if (this.ProcessedDataSets != null)
{
datasets.AddRange(this.ProcessedDataSets);
}
// check for duplicates.
if (datasets.Contains(dataset))
{
return;
}
dataset.Name = GetName(dataset);
datasets.Add(dataset);
this.ProcessedDataSets = datasets.ToArray();
}
/// <summary>
/// Constructs a name for the processed dataset.
/// </summary>
public static string GetName(ProcessedDataSetType dataset)
{
StringBuilder buffer = new StringBuilder();
buffer.Append(dataset.AggregateName);
buffer.Append(" [");
buffer.Append(dataset.ProcessingInterval);
buffer.Append(':');
buffer.Append((dataset.Stepped) ? "Stepped" : "Sloped");
buffer.Append('/');
buffer.Append((dataset.UseSlopedExtrapolation) ? "Sloped" : "Stepped");
buffer.Append(':');
buffer.Append((dataset.TreatUncertainAsBad)?"AsBad":"AsUncertain");
buffer.Append(':');
buffer.Append(dataset.PercentBad);
buffer.Append('/');
buffer.Append(dataset.PercentGood);
buffer.Append("]");
return buffer.ToString();
}
private void CopyTestBTN_Click(object sender, EventArgs e)
{
try
{
m_currentDataSet = new ProcessedDataSetType();
m_dataset.AcceptChanges();
SaveData(m_testData);
m_testData.AddDataSet(m_currentDataSet);
TestNameCB.Items.Add(m_currentDataSet);
TestNameCB.SelectedItem = m_currentDataSet;
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
private void TestNameCB_SelectedIndexChanged(object sender, EventArgs e)
{
m_loading = true;
try
{
m_dataset.Tables[0].Clear();
m_currentDataSet = TestNameCB.SelectedItem as ProcessedDataSetType;
if (m_currentDataSet == null)
{
return;
}
AggregateCB.SelectedItem = m_currentDataSet.AggregateName;
ProcessingIntervalNP.Value = m_currentDataSet.ProcessingInterval;
SteppedCK.Checked = m_currentDataSet.Stepped;
TreatUncertainAsBadCK.Checked = m_currentDataSet.TreatUncertainAsBad;
PercentGoodNP.Value = m_currentDataSet.PercentGood;
PercentBadNP.Value = m_currentDataSet.PercentBad;
UseSlopedExtrapolationCK.Checked = m_currentDataSet.UseSlopedExtrapolation;
AddDataSetToGrid(m_testData.GetRawValues(m_currentDataSet.DataSetName), true);
AddDataSetToGrid(m_testData.GetProcessedValues(m_currentDataSet), false);
UpdatesComplete();
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
finally
{
m_loading = false;
}
}
/// <summary>
/// Sets the values for the specified processed dataset.
/// </summary>
public void SetProcessedValues(ProcessedDataSetType dataset, IList<DataValue> newValues)
{
SortedDictionary<DateTime, DataValue> values = new SortedDictionary<DateTime, DataValue>();
if (newValues != null)
{
foreach (DataValue newValue in newValues)
{
values[newValue.SourceTimestamp] = newValue;
}
}
dataset.Values = ToValueTypes(values);
}
private void GenerateData(string historianName, string aggregateName, double processingInterval, AggregateConfiguration configuration, bool stepped)
{
DateTime startTime = new DateTime(DateTime.UtcNow.Year, 1, 1, 0, 0, 0, DateTimeKind.Utc);
IAggregateCalculator calculator = Aggregators.CreateStandardCalculator(
Aggregators.GetIdForStandardAggregate(aggregateName),
startTime.AddSeconds(0),
startTime.AddSeconds(100),
processingInterval,
stepped,
configuration);
SortedDictionary<DateTime, TestData.DataValue> rawValues = m_testData.GetRawValues(historianName);
List<TestData.DataValue> processedValues = new List<TestData.DataValue>();
foreach (TestData.DataValue rawValue in rawValues.Values)
{
if (!calculator.QueueRawValue((Opc.Ua.DataValue)rawValue))
{
break;
}
DataValue processedValue = calculator.GetProcessedValue(false);
if (processedValue != null)
{
processedValues.Add(new TestData.DataValue(processedValue));
}
}
for (DataValue processedValue = calculator.GetProcessedValue(true); processedValue != null; processedValue = calculator.GetProcessedValue(true))
{
processedValues.Add(new TestData.DataValue(processedValue));
}
ProcessedDataSetType dataset = new ProcessedDataSetType();
dataset.DataSetName = historianName;
dataset.AggregateName = aggregateName;
dataset.Stepped = stepped;
dataset.UseSlopedExtrapolation = configuration.UseSlopedExtrapolation;
dataset.TreatUncertainAsBad = configuration.TreatUncertainAsBad;
dataset.ProcessingInterval = (uint)processingInterval;
dataset.PercentBad = configuration.PercentDataBad;
dataset.PercentGood = configuration.PercentDataGood;
m_testData.AddDataSet(dataset);
m_testData.UpdateProcessedValues(dataset, processedValues.ToArray());
}
private void GenerateReportTable(StringBuilder buffer, ProcessedDataSetType dataset)
{
buffer.Append("<table border='1'>");
buffer.Append("<tr>");
buffer.Append("<th colspan='4'><b>");
buffer.Append(dataset.DataSetName);
buffer.Append("</b></th>");
buffer.Append("</tr>");
buffer.Append("<th><b>Timestamp</b></td>");
buffer.Append("<th><b>Value</b></th>");
buffer.Append("<th><b>StatusCode</b></th>");
buffer.Append("<th><b>Notes</b></th>");
buffer.Append("</tr>");
m_dataset.AcceptChanges();
ResetRowState();
foreach (ValueType value in dataset.Values)
{
buffer.Append("<tr>");
buffer.Append("<td>");
buffer.Append(value.Timestamp);
buffer.Append("</td>");
buffer.Append("<td>");
Variant result = TestData.ValidateValue(value.Value);
if (result.TypeInfo != null)
{
if (result.TypeInfo.BuiltInType == BuiltInType.Double)
{
if (Math.Truncate((double)result.Value) == (double)result.Value)
{
buffer.AppendFormat("{0}", (long)(double)result.Value);
}
else
{
buffer.AppendFormat("{0:F3}", result.Value);
}
}
else
{
buffer.Append(result);
}
}
buffer.Append("</td>");
buffer.Append("<td>");
buffer.Append(value.Quality);
buffer.Append("</td>");
buffer.Append("<td>");
buffer.Append(value.Comment);
buffer.Append("</td>");
buffer.Append("</tr>");
}
buffer.Append("</table>");
buffer.Append("<br/>");
buffer.Append("<br/>");
}
/// <summary>
/// Finds the best match for the target.
/// </summary>
public ProcessedDataSetType FindBestMatch(string rawDataSetName, ProcessedDataSetType target)
{
if (target != null && this.ProcessedDataSets != null)
{
// try for match on name.
foreach (ProcessedDataSetType dataset in this.ProcessedDataSets)
{
if (dataset.DataSetName == rawDataSetName)
{
if (target.Name == dataset.Name)
{
return dataset;
}
}
}
// try for match on aggregate.
foreach (ProcessedDataSetType dataset in this.ProcessedDataSets)
{
if (dataset.DataSetName == rawDataSetName)
{
if (target.AggregateName == dataset.AggregateName)
{
return dataset;
}
}
}
}
// nothing found.
return null;
}
private void HistorianCB_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
m_dataset.AcceptChanges();
string rawDataSetName = HistorianCB.SelectedItem as string;
m_currentDataSet = m_testData.FindBestMatch(rawDataSetName, m_currentDataSet);
if (m_currentDataSet == null)
{
if (AggregateCB.SelectedIndex == -1)
{
ProcessedDataSetType[] datasets = m_testData.GetProcessedDataSets(rawDataSetName);
if (datasets != null && datasets.Length > 0)
{
m_currentDataSet = datasets[0];
}
}
if (m_currentDataSet == null)
{
m_currentDataSet = new ProcessedDataSetType();
SaveData(m_testData);
m_currentDataSet.DataSetName = rawDataSetName;
m_testData.AddDataSet(m_currentDataSet);
}
}
TestNameCB.Items.Clear();
TestNameCB.Items.AddRange(m_testData.GetProcessedDataSets(rawDataSetName));
TestNameCB.SelectedItem = m_currentDataSet;
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
