private static Channel ParseSeries(SeriesInstance seriesInstance)
{
Channel channel = ParseSeries(seriesInstance.Definition);
channel.HarmonicGroup = seriesInstance.Channel.ChannelGroupID;
return(channel);
}
private void ParseSeries(GSF.PQDIF.Logical.ChannelInstance channelInstance, PQds.Model.Channel channel, PQds.Model.Event evt)
{
PQds.Model.DataSeries dataSeries = new DataSeries();
dataSeries.EventID = evt.ID;
dataSeries.ChannelID = channel.ID;
Guid quantityType = channelInstance.Definition.QuantityTypeID;
SeriesInstance timeSeries = null;
SeriesInstance valuesSeries = null;
if (isPOW(quantityType))
{
timeSeries = channelInstance.SeriesInstances.Single(series => series.Definition.ValueTypeID == SeriesValueType.Time);
valuesSeries = channelInstance.SeriesInstances.Single(series => series.Definition.ValueTypeID == SeriesValueType.Val);
}
else
{
return;
}
List <double> values = valuesSeries.OriginalValues.Select(val => Convert.ToDouble(val)).ToList();
List <DateTime> timeStamps = new List <DateTime>();
if (timeSeries.Definition.QuantityUnits == QuantityUnits.Seconds)
{
// If time series is in seconds from start time of the observation record,
// TimeValues must be calculated by adding values to start time
timeStamps = timeSeries.OriginalValues
.Select(Convert.ToDouble)
.Select(seconds => (long)(seconds * TimeSpan.TicksPerSecond))
.Select(TimeSpan.FromTicks)
.Select(timeSpan => channelInstance.ObservationRecord.StartTime + timeSpan)
.ToList();
}
else if (timeSeries.Definition.QuantityUnits == QuantityUnits.Timestamp)
{
// If time series is a collection of absolute time, seconds from start time
// must be calculated by subtracting the start time of the observation record
timeStamps = timeSeries.OriginalValues.Cast <DateTime>().ToList();
}
dataSeries.Series = timeStamps.Select((item, index) => new PQds.Model.DataPoint()
{
Time = item,
Value = values[index]
}).ToList();
using (AdoDataConnection connection = new AdoDataConnection("systemSettings"))
{
GSF.Data.Model.TableOperations <PQds.Model.DataSeries> dataSeriesTable = new GSF.Data.Model.TableOperations <PQds.Model.DataSeries>(connection);
dataSeriesTable.AddNewRecord(dataSeries);
}
}
private static double[] ParseValueData(SeriesInstance seriesInstance)
{
try
{
return(seriesInstance.OriginalValues.Select(Convert.ToDouble).ToArray());
}
catch
{
return(null);
}
}
private static DateTime[] ParseTimeData(ChannelInstance channelInstance, double systemFrequency)
{
SeriesInstance timeSeries = channelInstance.SeriesInstances
.FirstOrDefault(seriesInstance => seriesInstance.Definition.ValueTypeID == SeriesValueType.Time);
if ((object)timeSeries == null)
{
return(null);
}
return(ParseTimeData(timeSeries, systemFrequency));
}
private static DateTime[] ParseTimeData(SeriesInstance seriesInstance, double systemFrequency)
{
DateTime[] timeData;
SeriesDefinition timeSeriesDefinition = seriesInstance.Definition;
if (timeSeriesDefinition.ValueTypeID != SeriesValueType.Time)
{
return(null);
}
VectorElement seriesValues = seriesInstance.SeriesValues;
if (seriesValues.TypeOfValue == PhysicalType.Timestamp)
{
timeData = seriesInstance.OriginalValues
.Select(Convert.ToDateTime)
.ToArray();
}
else if (timeSeriesDefinition.QuantityUnits == QuantityUnits.Cycles)
{
ChannelInstance channelInstance = seriesInstance.Channel;
DateTime startTime = channelInstance.ObservationRecord.StartTime;
double nominalFrequency = channelInstance.ObservationRecord?.Settings.NominalFrequency ?? systemFrequency;
timeData = seriesInstance.OriginalValues
.Select(Convert.ToDouble)
.Select(cycles => cycles / nominalFrequency)
.Select(seconds => (long)(seconds * TimeSpan.TicksPerSecond))
.Select(TimeSpan.FromTicks)
.Select(timeSpan => startTime + timeSpan)
.ToArray();
}
else
{
ChannelInstance channelInstance = seriesInstance.Channel;
DateTime startTime = channelInstance.ObservationRecord.StartTime;
timeData = seriesInstance.OriginalValues
.Select(Convert.ToDouble)
.Select(seconds => (long)(seconds * TimeSpan.TicksPerSecond))
.Select(TimeSpan.FromTicks)
.Select(timeSpan => startTime + timeSpan)
.ToArray();
}
return(timeData);
}
// Takes a PQDIF time series and converts it to an array of 64-bit integer values in ticks.
private static long[] ToTicks(SeriesInstance timeSeries)
{
ObservationRecord observation = timeSeries.Channel.ObservationRecord;
long startTime;
double nominalFrequency;
if (timeSeries.Definition.QuantityUnits == QuantityUnits.Seconds)
{
startTime = observation.StartTime.Ticks;
// The time series contains values in seconds,
// relative to the start time of the observation record
return(timeSeries.OriginalValues
.Select(Convert.ToDouble)
.Select(Ticks.FromSeconds)
.Select(timeOffset => startTime + (long)timeOffset)
.ToArray());
}
else if (timeSeries.Definition.QuantityUnits == QuantityUnits.Timestamp)
{
// The time series contains values in absolute time
return(timeSeries.OriginalValues
.Cast <DateTime>()
.Select(time => time.Ticks)
.ToArray());
}
else if (timeSeries.Definition.QuantityUnits == QuantityUnits.Cycles)
{
startTime = observation.StartTime.Ticks;
nominalFrequency = observation.Settings.NominalFrequency;
// TODO: Is this correct (dividing by nominal frequency)?
// The time series contains values in cycles,
// relative to the start time of the observation record
return(timeSeries.OriginalValues
.Select(Convert.ToDouble)
.Select(cycles => cycles / nominalFrequency)
.Select(Ticks.FromSeconds)
.Select(timeOffset => startTime + (long)timeOffset)
.ToArray());
}
// The time series does not contain timestamps...?
return(null);
}
private static Channel ParseSeries(SeriesInstance seriesInstance)
{
Channel channel = new Channel();
Series series = new Series();
ChannelInstance channelInstance = seriesInstance.Channel;
ChannelDefinition channelDefinition = channelInstance.Definition;
SeriesDefinition seriesDefinition = seriesInstance.Definition;
QuantityMeasured quantityMeasured = channelDefinition.QuantityMeasured;
Phase phase = channelDefinition.Phase;
// Populate channel properties
channel.Name = channelDefinition.ChannelName;
channel.HarmonicGroup = channelInstance.ChannelGroupID;
channel.MeasurementType = new MeasurementType();
channel.MeasurementCharacteristic = new MeasurementCharacteristic();
channel.Phase = new Database.Phase();
if (seriesInstance.Definition.HasElement(SeriesDefinition.SeriesNominalQuantityTag))
{
channel.PerUnitValue = seriesInstance.Definition.SeriesNominalQuantity;
}
// Populate series properties
series.SeriesType = new SeriesType();
series.Channel = channel;
series.SourceIndexes = string.Empty;
// Populate measurement type properties
channel.MeasurementType.Name = quantityMeasured.ToString();
// Populate characteristic properties
channel.MeasurementCharacteristic.Name = QuantityCharacteristic.ToName(seriesDefinition.QuantityCharacteristicID) ?? seriesDefinition.QuantityCharacteristicID.ToString();
channel.MeasurementCharacteristic.Description = QuantityCharacteristic.ToString(seriesDefinition.QuantityCharacteristicID);
// Popuplate phase properties
channel.Phase.Name = phase.ToString();
// Populate series type properties
series.SeriesType.Name = SeriesValueType.ToString(seriesDefinition.ValueTypeID) ?? seriesDefinition.ValueTypeName ?? seriesDefinition.ValueTypeID.ToString();
series.SeriesType.Description = seriesDefinition.ValueTypeName;
return(channel);
}
private ParsedChannel MakeParsedChannel(ChannelInstance channel)
{
// Get the time series and value series for the given channel
SeriesInstance timeSeries = channel.SeriesInstances.Single(series => series.Definition.ValueTypeID == SeriesValueType.Time);
SeriesInstance valuesSeries = channel.SeriesInstances.Single(series => series.Definition.ValueTypeID == SeriesValueType.Val);
// Set up parsed channel to be returned
ParsedChannel parsedChannel = new ParsedChannel()
{
Name = channel.Definition.ChannelName,
YValues = valuesSeries.OriginalValues
};
if (timeSeries.Definition.QuantityUnits == QuantityUnits.Seconds)
{
// If time series is in seconds from start time of the observation record,
// TimeValues must be calculated by adding values to start time
parsedChannel.TimeValues = timeSeries.OriginalValues
.Select(Convert.ToDouble)
.Select(seconds => (long)(seconds * TimeSpan.TicksPerSecond))
.Select(TimeSpan.FromTicks)
.Select(timeSpan => channel.ObservationRecord.StartTime + timeSpan)
.ToList();
parsedChannel.XValues = timeSeries.OriginalValues;
}
else if (timeSeries.Definition.QuantityUnits == QuantityUnits.Timestamp)
{
// If time series is a collection of absolute time, seconds from start time
// must be calculated by subtracting the start time of the observation record
parsedChannel.TimeValues = timeSeries.OriginalValues.Cast <DateTime>().ToList();
parsedChannel.XValues = timeSeries.OriginalValues
.Cast <DateTime>()
.Select(time => time - channel.ObservationRecord.StartTime)
.Select(timeSpan => timeSpan.TotalSeconds)
.Cast <object>()
.ToList();
}
return(parsedChannel);
}
private static double[] ParseValueData(SeriesInstance seriesInstance)
{
try
{
return seriesInstance.OriginalValues.Select(Convert.ToDouble).ToArray();
}
catch
{
return null;
}
}
private static Channel ParseSeries(SeriesInstance seriesInstance)
{
Channel channel = ParseSeries(seriesInstance.Definition);
channel.HarmonicGroup = seriesInstance.Channel.ChannelGroupID;
return channel;
}
