Joseph Doherty
8a0032bfdf
When the data starts inside an interval (no start bound) and its first value is
Uncertain, the frozen 1.5.378.182 AverageAggregateCalculator integrated the
uncovered span as a ramp from 0 and divided TimeAverage by the whole interval:
GetRegionsInValueSet (ignoreBadData, sloped) overwrites the BadNoData start
region's status with UncertainDataSubNormal in its one branch without a not-Bad
guard. Live AggregateFilter therefore disagreed with HistoryRead and Part 13
§5.4.3.6/§5.4.3.8 ("No Start Bound: Calculate Partial Interval"); QP: Total
188.96 vs 163.96, TimeAverage 9.448 vs 10.931. SDK 2.0.1 stock does the same.
Owner-approved 2026-11-11.
- New app-owned CoveredTimeAverageAggregateCalculator subclasses the baseline
and recomputes only TimeAverage/Total, restoring the Bad status of a region
that starts at a Bad point (only the start bound can). Only such an interval's
value changes; status, timestamps, type and bits are the baseline's. Stepped
and TreatUncertainAsBad=true never reached the defect. CompatibilityAggregate-
Factory routes exactly those two IDs; copied SDK files untouched.
- Golden test: 0 fixture vectors change (every data set has a usable value at
-10 s), asserted. New sweep over late-start variants of every data set (cut
+5 s / +25 s, first non-Bad sample Uncertain, all directions/stepping/configs/
incremental): 150 / 142 of 384 change, each pinned to a baseline-derived
oracle (untouched baseline's value with that sample Good, its status/bits on
the variant itself) - never our calculator. Plus a hand-computed case.
- Live-vs-HistoryRead parity (TimeWeightedAggregator) forward + reverse, no
masks, with discrimination against the pre-#821 baseline; QualityMix now
compares QP's TimeAverage/Total with the live oracle on both SQL backends;
booted-runtime facts test expects 163.96 / 10.93.
- README recorded decision, ServerAggregateConfiguration remarks, oracle
remarks, docs/Historian.md and .claude/rules/historian.md updated.
Claude-Session: https://claude.ai/code/session_01GT67AD99zQQqpLCVm3p7xk
60 lines
3.4 KiB
C#
60 lines
3.4 KiB
C#
using Opc.Ua;
|
|
using Shouldly;
|
|
using Xunit;
|
|
|
|
namespace ZB.MOM.WW.OtOpcUa.OpcUaServer.IntegrationTests;
|
|
|
|
/// <summary>
|
|
/// #821 / #809 facts, through the BOOTED server's runtime <c>AggregateManager</c> — the calculators a live
|
|
/// AggregateFilter monitored item gets, under the server's own default configuration. Both are decided (owner,
|
|
/// 2026-11-11): live PercentGood / DurationGood count Good time only (#809), and live Total / TimeAverage integrate only
|
|
/// the covered part of an interval the data starts inside, even with an Uncertain first sample (#821) — equal to
|
|
/// HistoryRead. The HistoryRead (Part 13) answers, the untouched baseline's and SDK 2.0.1's stock answers for the same
|
|
/// input are pinned beside it in <c>SdkAggregateParityTests</c>.
|
|
/// </summary>
|
|
public sealed class LiveAggregateLateStartFactsTests
|
|
{
|
|
private static readonly DateTime T0 = new(2026, 11, 11, 8, 0, 0, DateTimeKind.Utc);
|
|
|
|
/// <summary>The #810 QualityMix tag QP: Uncertain 10 at +5, Good 11 at +12, Uncertain 12 at +25, nothing after.</summary>
|
|
private static readonly (double Seconds, double Value, uint Status)[] Qp =
|
|
[
|
|
(5, 10, 0x40000000u), (12, 11, 0x00000000u), (25, 12, 0x40000000u), // Uncertain, Good, Uncertain
|
|
];
|
|
|
|
[Fact]
|
|
public async Task Live_AggregateFilter_calculators_on_an_Uncertain_first_late_start_interval()
|
|
{
|
|
await using var rig = await ServerEventRig.StartAsync("AggregateLateStart", encrypted: false,
|
|
TestContext.Current.CancellationToken);
|
|
var manager = rig.Server.CurrentInstance.AggregateManager;
|
|
var config = manager.GetDefaultConfiguration(NodeId.Null);
|
|
config.TreatUncertainAsBad.ShouldBeFalse("the server pins TreatUncertainAsBad = false (#782)");
|
|
|
|
double One(NodeId aggregate)
|
|
{
|
|
var calc = manager.CreateCalculator(aggregate, T0, T0.AddSeconds(20), 20_000, false, config);
|
|
calc.ShouldNotBeNull();
|
|
foreach (var (s, v, st) in Qp)
|
|
calc.QueueRawValue(new DataValue(Variant.From(v), st, T0.AddSeconds(s), T0.AddSeconds(s)));
|
|
calc.TryGetProcessedValue(true, out var dv).ShouldBeTrue();
|
|
dv.WrappedValue.TryGetValue(out double d).ShouldBeTrue();
|
|
return d;
|
|
}
|
|
|
|
// #821: Part 13 (HistoryRead on SqlServer/QuestDB): Total = 73.5 + 88 + 32/13 = 163.96…, TimeAverage = Total ÷ 15 s
|
|
// — live as in HistoryRead (before #821 the live calculator integrated the uncovered [0,5) as a ramp from 0 (+25)
|
|
// and divided by the whole 20 s: 188.96… / 9.448…).
|
|
const double part13Total = 73.5 + 88 + 32d / 13;
|
|
One(ObjectIds.AggregateFunction_Total).ShouldBe(part13Total, 1e-9); // 163.96…
|
|
One(ObjectIds.AggregateFunction_TimeAverage).ShouldBe(part13Total / 15, 1e-9); // 10.93…
|
|
// #809: the Uncertain [5,12) is not Good — only [12,20) is, live as in HistoryRead (8 000 ms / 40 %; before #809
|
|
// the live calculator counted the Uncertain time too: 15 000 ms / 75 %).
|
|
One(ObjectIds.AggregateFunction_DurationGood).ShouldBe(8_000d, 1e-9);
|
|
One(ObjectIds.AggregateFunction_PercentGood).ShouldBe(40d, 1e-9);
|
|
// DurationBad / PercentBad agree with HistoryRead: the 5 s before the data is Bad.
|
|
One(ObjectIds.AggregateFunction_DurationBad).ShouldBe(5_000d, 1e-9);
|
|
One(ObjectIds.AggregateFunction_PercentBad).ShouldBe(25d, 1e-9);
|
|
}
|
|
}
|