public PMUDataStructure(DateTime dateTime, float[] value, DataQuality quality = DataQuality.Good, DataQualityReason qualityReason = DataQualityReason.None)
{
TimeStamp = dateTime;
Value = value;
Quality = quality;
QualityReason = qualityReason;
}
public void Obs_21_Create()
{
Observation originalObj = new Observation(new Item_Measurement(null))
{
Name = "Some name",
Description = "Some description",
FeatureOfInterest = "somefeature",
ObservedProperty = "someproperty",
PhenomenonTime = ParseDateTimeInUtc("2018-02-23T10:00:00Z"),
Procedure = "someprocedure",
ResultTime = ParseDateTimeInUtc("2018-02-23T10:00:00Z"),
ResultQuality = DataQuality.CreateGood()
};
// Serializing and validating the XML document
Observation parsedObj = SerialiseAndReadResultObj(originalObj);
// Checking string values
Assert.AreEqual("Some description", parsedObj.Description);
Assert.AreEqual("Some name", parsedObj.Name);
// Checking reference values
Assert.AreEqual("somefeature", parsedObj.FeatureOfInterest.TrimEnd('/'));
Assert.AreEqual("someproperty", parsedObj.ObservedProperty.TrimEnd('/'));
Assert.AreEqual("someprocedure", parsedObj.Procedure.TrimEnd('/'));
// Checking result time
TestCommon.TestHelper.AssertDateTime(ParseDateTimeInUtc("2018-02-23T10:00:00Z"), parsedObj.ResultTime);
// Comparing phenomenon time
TestCommon.TestHelper.AssertDateTime(ParseDateTimeInUtc("2018-02-23T10:00:00Z"), parsedObj.PhenomenonTime);
// Asserting good data quality
Assert.IsTrue(parsedObj.ResultQuality.IsGood);
}
public static void FetchAndFlushData(AdapterParams prms)
{
// get measurement id from command line arguments
string measId = prms.MeasId;
// get the start and end times
DateTime startTime = prms.FromTime;
DateTime endTime = prms.ToTime;
// This Configuration data varaible Config_ can be handy here while dealing application secrets or configurations...
ConfigurationManager Config_ = new ConfigurationManager();
Config_.Initialize();
// Create output data string
string outStr = "";
List <object> fetchResult = new List <object>();
Random rand = new Random();
for (DateTime dt = startTime; dt <= endTime; dt = dt.AddSeconds(1))
{
double ts = TimeUtils.ToMillisSinceUnixEpoch(dt);
fetchResult.Add(ts);
fetchResult.Add(rand.Next(-50, 50));
if (prms.IncludeQuality)
{
DataQuality qual = DataQuality.GOOD;
fetchResult.Add((int)qual);
}
}
outStr = String.Join(",", fetchResult);
// send the output data to console
ConsoleUtils.FlushChunks(outStr);
}
public DataPoint(TX x, TY y, bool emphasis, DataQuality quality = DataQuality.GoodPoint)
{
this.emphasis = emphasis;
this.quality = quality;
this.x = x;
this.y = y;
}
public static byte[] toBytes(this DataQuality inp)
{
byte[] res = new byte[2];
if ((inp & DataQuality.VALIDITY0) == DataQuality.VALIDITY0)
{
res[0] |= Scsm_MMS.DatQualValidity0;
}
if ((inp & DataQuality.VALIDITY1) == DataQuality.VALIDITY1)
{
res[0] |= Scsm_MMS.DatQualValidity1;
}
if ((inp & DataQuality.OVERFLOW) == DataQuality.OVERFLOW)
{
res[0] |= Scsm_MMS.DatQualOverflow;
}
if ((inp & DataQuality.OUT_OF_RANGE) == DataQuality.OUT_OF_RANGE)
{
res[0] |= Scsm_MMS.DatQualOutOfRange;
}
if ((inp & DataQuality.BAD_REFERENCE) == DataQuality.BAD_REFERENCE)
{
res[0] |= Scsm_MMS.DatQualBadReference;
}
if ((inp & DataQuality.OSCILLATORY) == DataQuality.OSCILLATORY)
{
res[0] |= Scsm_MMS.DatQualOscillatory;
}
if ((inp & DataQuality.FAILURE) == DataQuality.FAILURE)
{
res[0] |= Scsm_MMS.DatQualFailure;
}
if ((inp & DataQuality.OLD_DATA) == DataQuality.OLD_DATA)
{
res[0] |= Scsm_MMS.DatQualOldData;
}
if ((inp & DataQuality.INCONSISTENT) == DataQuality.INCONSISTENT)
{
res[1] |= Scsm_MMS.DatQualInconsistent;
}
if ((inp & DataQuality.INACCURATE) == DataQuality.INACCURATE)
{
res[1] |= Scsm_MMS.DatQualInaccurate;
}
if ((inp & DataQuality.SOURCE) == DataQuality.SOURCE)
{
res[1] |= Scsm_MMS.DatQualSource;
}
if ((inp & DataQuality.TEST) == DataQuality.TEST)
{
res[1] |= Scsm_MMS.DatQualTest;
}
if ((inp & DataQuality.OPERATOR_BLOCKED) == DataQuality.OPERATOR_BLOCKED)
{
res[1] |= Scsm_MMS.DatQualOperatorBlocked;
}
return(res);
}
public PowerValue(DateTime datetime, float value) : base(datetime)
{
Value = value;
Confidence = 1;
Accuracy = (float)1.0;
DataQuality = DataQuality.qualityGoodNonSpecific;
}
public void Dq_20_CustomBad()
{
// Test bad qualities with a custom reason
DataQuality customBad1 = DataQuality.CreateBad("myreason");
DataQuality customBad2 = DataQuality.CreateBad("myreason/subreason");
Assert.IsFalse(customBad1.IsGood);
Assert.IsFalse(customBad2.IsGood);
}
public void Dq_10_BasicGoodness()
{
// Test basic good and bad qualities
DataQuality good = DataQuality.CreateGood();
DataQuality bad = DataQuality.CreateBad();
Assert.IsTrue(good.IsGood);
Assert.IsFalse(bad.IsGood);
}
public void Dq_25_CustomBad_Errors()
{
// Test bad qualities with a custom reason (with errors)
var myAction = new Action(() =>
{
DataQuality.CreateBad("myreaso n");
});
TestCommon.TestHelper.AssertArgumentException(myAction, ERR_WHITESPACES_START);
}
public void Obs_22_Create_BadQuality()
{
Observation originalObj = new Observation(new Item_Measurement(null))
{
// Populating the object
ResultQuality = DataQuality.CreateBad()
};
// Serializing and validating the XML document
Observation parsedObj = SerialiseAndReadResultObj(originalObj);
// Asserting bad data quality
Assert.IsFalse(parsedObj.ResultQuality.IsGood);
}
public void Dq_30_Parse()
{
// Test creation for a raw string
var value1 = "good";
var value2 = "bad";
var value3 = "bad/justreason";
DataQuality fromStr1 = new DataQuality(value1);
DataQuality fromStr2 = new DataQuality(value2);
DataQuality fromStr3 = new DataQuality(value3);
Assert.IsTrue(fromStr1.IsGood);
Assert.IsFalse(fromStr2.IsGood);
Assert.IsFalse(fromStr3.IsGood);
}
public static List <double> FetchHistData(string pnt, DateTime startTime, DateTime endTime, int secs, string type, bool includeQuality)
{
int nret = 0;
List <double> historyResults = new List <double>();
try
{
uint s = 0;
double dval = 0;
DateTime timestamp = DateTime.Now;
string status = "";
TimeSpan period = TimeSpan.FromSeconds(secs);
// history request initiation
if (type == "snap")
{
nret = History.DnaGetHistSnap(pnt, startTime, endTime, period, out s);
}
else if (type == "average")
{
nret = History.DnaGetHistAvg(pnt, startTime, endTime, period, out s);
}
else if (type == "min")
{
nret = History.DnaGetHistMin(pnt, startTime, endTime, period, out s);
}
else if (type == "max")
{
nret = History.DnaGetHistMax(pnt, startTime, endTime, period, out s);
}
else
{
nret = History.DnaGetHistRaw(pnt, startTime, endTime, out s);
}
while (nret == 0)
{
nret = History.DnaGetNextHist(s, out dval, out timestamp, out status);
if (status != null)
{
historyResults.Add(TimeUtils.ToMillisSinceUnixEpoch(timestamp));
historyResults.Add(dval);
if (includeQuality)
{
DataQuality qual = DataQuality.GOOD;
if (status == "GOOD" || status == "OK")
{
qual = DataQuality.GOOD;
}
else if (status == "BAD")
{
qual = DataQuality.BAD;
}
else if (status == "SUSPECT")
{
qual = DataQuality.SUSPECT;
}
else if (status == "REPLACED")
{
qual = DataQuality.REPLACED;
}
historyResults.Add((int)qual);
}
}
}
}
catch (Exception ex)
{
// Console.WriteLine("Error while fetching history results " + ex.Message);
historyResults = new List <double>();
}
return(historyResults);
}
public void Upsert(DataQuality.ChannelDataQualitySummaryRow dataRow)
{
UpsertQuery(dataRow.ChannelID, dataRow.Date, dataRow.ExpectedPoints, dataRow.GoodPoints, dataRow.LatchedPoints, dataRow.UnreasonablePoints, dataRow.NoncongruentPoints, dataRow.DuplicatePoints);
}
private void _read()
{
_header = new Header(m_io, this, m_root);
switch (header.MessageType)
{
case Header.EMessageType.EState: {
__raw_content = m_io.ReadBytes(header.ContentLength);
var io___raw_content = new KaitaiStream(__raw_content);
_content = new State(io___raw_content, this, m_root);
break;
}
case Header.EMessageType.ESequenceData: {
__raw_content = m_io.ReadBytes(header.ContentLength);
var io___raw_content = new KaitaiStream(__raw_content);
_content = new SequenceData(io___raw_content, this, m_root);
break;
}
case Header.EMessageType.EDebug: {
__raw_content = m_io.ReadBytes(header.ContentLength);
var io___raw_content = new KaitaiStream(__raw_content);
_content = new Debug(io___raw_content, this, m_root);
break;
}
case Header.EMessageType.ESync: {
__raw_content = m_io.ReadBytes(header.ContentLength);
var io___raw_content = new KaitaiStream(__raw_content);
_content = new Sync(io___raw_content, this, m_root);
break;
}
case Header.EMessageType.EAuxSequenceData: {
__raw_content = m_io.ReadBytes(header.ContentLength);
var io___raw_content = new KaitaiStream(__raw_content);
_content = new AuxSequenceData(io___raw_content, this, m_root);
break;
}
case Header.EMessageType.EPackage: {
__raw_content = m_io.ReadBytes(header.ContentLength);
var io___raw_content = new KaitaiStream(__raw_content);
_content = new Package(io___raw_content, this, m_root);
break;
}
case Header.EMessageType.EDataQuality: {
__raw_content = m_io.ReadBytes(header.ContentLength);
var io___raw_content = new KaitaiStream(__raw_content);
_content = new DataQuality(io___raw_content, this, m_root);
break;
}
case Header.EMessageType.ENode: {
__raw_content = m_io.ReadBytes(header.ContentLength);
var io___raw_content = new KaitaiStream(__raw_content);
_content = new Node(io___raw_content, this, m_root);
break;
}
case Header.EMessageType.EStatus: {
__raw_content = m_io.ReadBytes(header.ContentLength);
var io___raw_content = new KaitaiStream(__raw_content);
_content = new Status(io___raw_content, this, m_root);
break;
}
case Header.EMessageType.ETrigger: {
__raw_content = m_io.ReadBytes(header.ContentLength);
var io___raw_content = new KaitaiStream(__raw_content);
_content = new Trigger(io___raw_content, this, m_root);
break;
}
default: {
_content = m_io.ReadBytes(header.ContentLength);
break;
}
}
}
public FakeFileLoader(DataQuality dataQuality)
{
quality = dataQuality;
}
public static DataQuality fromBytes(this DataQuality res, byte[] value)
{
res = DataQuality.NONE;
if (value == null || value.Length < 1)
{
return(res);
}
if ((value[0] & Scsm_MMS.DatQualValidity0) == Scsm_MMS.DatQualValidity0)
{
res |= DataQuality.VALIDITY0;
}
if ((value[0] & Scsm_MMS.DatQualValidity1) == Scsm_MMS.DatQualValidity1)
{
res |= DataQuality.VALIDITY1;
}
if ((value[0] & Scsm_MMS.DatQualOverflow) == Scsm_MMS.DatQualOverflow)
{
res |= DataQuality.OVERFLOW;
}
if ((value[0] & Scsm_MMS.DatQualOutOfRange) == Scsm_MMS.DatQualOutOfRange)
{
res |= DataQuality.OUT_OF_RANGE;
}
if ((value[0] & Scsm_MMS.DatQualBadReference) == Scsm_MMS.DatQualBadReference)
{
res |= DataQuality.BAD_REFERENCE;
}
if ((value[0] & Scsm_MMS.DatQualOscillatory) == Scsm_MMS.DatQualOscillatory)
{
res |= DataQuality.OSCILLATORY;
}
if ((value[0] & Scsm_MMS.DatQualFailure) == Scsm_MMS.DatQualFailure)
{
res |= DataQuality.FAILURE;
}
if ((value[0] & Scsm_MMS.DatQualOldData) == Scsm_MMS.DatQualOldData)
{
res |= DataQuality.OLD_DATA;
}
if (value.Length < 2)
{
return(res);
}
if ((value[1] & Scsm_MMS.DatQualInconsistent) == Scsm_MMS.DatQualInconsistent)
{
res |= DataQuality.INCONSISTENT;
}
if ((value[1] & Scsm_MMS.DatQualInaccurate) == Scsm_MMS.DatQualInaccurate)
{
res |= DataQuality.INACCURATE;
}
if ((value[1] & Scsm_MMS.DatQualSource) == Scsm_MMS.DatQualSource)
{
res |= DataQuality.SOURCE;
}
if ((value[1] & Scsm_MMS.DatQualTest) == Scsm_MMS.DatQualTest)
{
res |= DataQuality.TEST;
}
if ((value[1] & Scsm_MMS.DatQualOperatorBlocked) == Scsm_MMS.DatQualOperatorBlocked)
{
res |= DataQuality.OPERATOR_BLOCKED;
}
return(res);
}
