Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add CIR adaptive calibration and policy comparison harness tests

Yuechen Lid856f9f448e3
diff --git a/Aetheris.Kernel.Core.Tests/Cir/CirAdaptiveCalibrationTests.cs b/Aetheris.Kernel.Core.Tests/Cir/CirAdaptiveCalibrationTests.cs
new file mode 100644
index 00000000..92780fa2
--- /dev/null
+++ b/Aetheris.Kernel.Core.Tests/Cir/CirAdaptiveCalibrationTests.cs
@@ -0,0 +1,207 @@
+using Aetheris.Kernel.Core.Cir;
+using Aetheris.Kernel.Core.Math;
+
+namespace Aetheris.Kernel.Core.Tests.Cir;
+
+public sealed record CirAdaptiveCalibrationPolicy(string Name, CirAdaptiveVolumeOptions AdaptiveOptions, int DenseResolution);
+
+public sealed record CirAdaptiveCalibrationMetrics(
+ string ShapeName,
+ string PolicyName,
+ double? ExpectedVolume,
+ double DenseEstimate,
+ double AdaptiveEstimate,
+ double DenseAbsoluteError,
+ double DenseRelativeError,
+ double AdaptiveAbsoluteError,
+ double AdaptiveRelativeError,
+ double AdaptiveDenseDelta,
+ int DenseSampleCount,
+ int AdaptiveSampledPointCount,
+ int RegionsVisited,
+ int RegionsClassifiedInside,
+ int RegionsClassifiedOutside,
+ int RegionsSubdivided,
+ int RegionsSampledDirectly,
+ int UnknownOrRejectedRegions,
+ int MaxDepthReached,
+ IReadOnlyDictionary<CirRegionPlanAction, int> ActionCounts,
+ IReadOnlyDictionary<string, int> CandidateCounts,
+ IReadOnlyList<CirAdaptiveTraceEvent> TraceHead);
+
+public sealed record CirAdaptiveCalibrationCase(
+ string ShapeName,
+ CirAdaptiveCalibrationPolicy Policy,
+ CirAdaptiveCalibrationMetrics Metrics,
+ IReadOnlyList<string> Notes);
+
+public sealed record CirAdaptiveCalibrationReport(IReadOnlyList<CirAdaptiveCalibrationCase> Cases);
+
+internal static class CirAdaptiveCalibrationHarness
+{
+ public static CirAdaptiveCalibrationReport Run(IEnumerable<(string ShapeName, CirNode Node, double? ExpectedVolume)> shapes, IEnumerable<CirAdaptiveCalibrationPolicy> policies)
+ {
+ var cases = new List<CirAdaptiveCalibrationCase>();
+
+ foreach (var (shapeName, node, expectedVolume) in shapes)
+ {
+ var tape = CirTapeLowerer.Lower(node);
+ foreach (var policy in policies)
+ {
+ var dense = CirVolumeEstimator.EstimateVolume(node, policy.DenseResolution);
+ var adaptive = CirAdaptiveVolumeEstimator.EstimateVolume(tape, node.Bounds, policy.AdaptiveOptions);
+ var denseSamples = policy.DenseResolution * policy.DenseResolution * policy.DenseResolution;
+ var adaptiveSamplePoints = adaptive.RegionsSampledDirectly * policy.AdaptiveOptions.DirectSampleGrid * policy.AdaptiveOptions.DirectSampleGrid * policy.AdaptiveOptions.DirectSampleGrid;
+
+ var actionCounts = adaptive.TraceEvents
+ .GroupBy(e => e.Action)
+ .ToDictionary(g => g.Key, g => g.Count());
+ var candidateCounts = adaptive.TraceEvents
+ .Where(e => !string.IsNullOrWhiteSpace(e.Candidate))
+ .GroupBy(e => e.Candidate)
+ .ToDictionary(g => g.Key, g => g.Count());
+
+ var denseAbsError = expectedVolume.HasValue ? System.Math.Abs(dense - expectedVolume.Value) : 0d;
+ var adaptiveAbsError = expectedVolume.HasValue ? System.Math.Abs(adaptive.EstimatedVolume - expectedVolume.Value) : 0d;
+ var denseRelError = expectedVolume.HasValue && expectedVolume.Value != 0d ? denseAbsError / expectedVolume.Value : 0d;
+ var adaptiveRelError = expectedVolume.HasValue && expectedVolume.Value != 0d ? adaptiveAbsError / expectedVolume.Value : 0d;
+
+ var metrics = new CirAdaptiveCalibrationMetrics(
+ shapeName,
+ policy.Name,
+ expectedVolume,
+ dense,
+ adaptive.EstimatedVolume,
+ denseAbsError,
+ denseRelError,
+ adaptiveAbsError,
+ adaptiveRelError,
+ System.Math.Abs(adaptive.EstimatedVolume - dense),
+ denseSamples,
+ adaptiveSamplePoints,
+ adaptive.TotalRegionsVisited,
+ adaptive.RegionsClassifiedInside,
+ adaptive.RegionsClassifiedOutside,
+ adaptive.RegionsSubdivided,
+ adaptive.RegionsSampledDirectly,
+ adaptive.UnknownOrRejectedRegions,
+ adaptive.MaxDepthReached,
+ actionCounts,
+ candidateCounts,
+ adaptive.TraceEvents.Take(12).ToArray());
+
+ cases.Add(new CirAdaptiveCalibrationCase(shapeName, policy, metrics, adaptive.Notes));
+ }
+ }
+
+ return new CirAdaptiveCalibrationReport(cases);
+ }
+}
+
+public sealed class CirAdaptiveCalibrationTests
+{
+ [Fact]
+ public void AdaptiveCalibration_Box_ReportIsDeterministic()
+ {
+ var shape = ("box", (CirNode)new CirBoxNode(6d, 4d, 2d), 48d as double?);
+ var policy = ConservativePolicy();
+
+ var first = CirAdaptiveCalibrationHarness.Run([shape], [policy]);
+ var second = CirAdaptiveCalibrationHarness.Run([shape], [policy]);
+
+ var a = first.Cases.Single().Metrics;
+ var b = second.Cases.Single().Metrics;
+
+ Assert.Equal(a.AdaptiveEstimate, b.AdaptiveEstimate);
+ Assert.Equal(a.DenseEstimate, b.DenseEstimate);
+ Assert.Equal(a.RegionsVisited, b.RegionsVisited);
+ Assert.Equal(a.RegionsSubdivided, b.RegionsSubdivided);
+ Assert.Equal(a.RegionsSampledDirectly, b.RegionsSampledDirectly);
+ Assert.Equal(a.MaxDepthReached, b.MaxDepthReached);
+ Assert.Equal(a.ActionCounts.OrderBy(kv => kv.Key).ToArray(), b.ActionCounts.OrderBy(kv => kv.Key).ToArray());
+ Assert.Equal(a.CandidateCounts.OrderBy(kv => kv.Key).ToArray(), b.CandidateCounts.OrderBy(kv => kv.Key).ToArray());
+ Assert.Equal(a.TraceHead, b.TraceHead);
+ }
+
+ [Fact]
+ public void AdaptiveCalibration_BoxMinusCylinder_ReportsUsefulMetrics()
+ {
+ var shape = BuildBoxMinusCylinder();
+ var report = CirAdaptiveCalibrationHarness.Run([shape], [ConservativePolicy()]);
+ var metrics = report.Cases.Single().Metrics;
+
+ Assert.True(metrics.DenseEstimate > 0d);
+ Assert.True(metrics.AdaptiveEstimate > 0d);
+ Assert.True(metrics.DenseSampleCount > 0);
+ Assert.True(metrics.RegionsVisited > 0);
+ Assert.True(metrics.ActionCounts.Count > 0);
+ Assert.True(metrics.CandidateCounts.Count > 0);
+ }
+
+ [Fact]
+ public void AdaptiveCalibration_AdaptiveWithinTolerance()
+ {
+ var report = CirAdaptiveCalibrationHarness.Run(BuildShapes(), [ConservativePolicy()]);
+
+ foreach (var c in report.Cases)
+ {
+ Assert.True(c.Metrics.AdaptiveDenseDelta <= 18d, $"{c.ShapeName} delta too high: {c.Metrics.AdaptiveDenseDelta:R}");
+
+ if (c.Metrics.ExpectedVolume.HasValue)
+ {
+ Assert.True(c.Metrics.AdaptiveRelativeError <= 0.08d, $"{c.ShapeName} relative error too high: {c.Metrics.AdaptiveRelativeError:R}");
+ }
+ }
+ }
+
+ [Fact]
+ public void AdaptiveCalibration_PolicyComparisonShowsDifferentWorkProfiles()
+ {
+ var report = CirAdaptiveCalibrationHarness.Run(BuildShapes(), [ConservativePolicy(), CoarsePolicy()]);
+
+ foreach (var shape in report.Cases.GroupBy(c => c.ShapeName))
+ {
+ var conservative = shape.Single(c => c.Policy.Name == "conservative").Metrics;
+ var coarse = shape.Single(c => c.Policy.Name == "coarse").Metrics;
+ Assert.True(
+ conservative.RegionsVisited != coarse.RegionsVisited
+ || conservative.AdaptiveSampledPointCount != coarse.AdaptiveSampledPointCount
+ || conservative.MaxDepthReached != coarse.MaxDepthReached,
+ $"Expected different work profile for {shape.Key}.");
+ }
+ }
+
+ [Fact]
+ public void AdaptiveCalibration_TraceSummaryPresent()
+ {
+ var report = CirAdaptiveCalibrationHarness.Run([BuildBoxMinusCylinder()], [ConservativePolicy()]);
+ var metrics = report.Cases.Single().Metrics;
+
+ Assert.NotEmpty(metrics.TraceHead);
+ Assert.NotEmpty(metrics.ActionCounts);
+ Assert.NotEmpty(metrics.CandidateCounts);
+ }
+
+ private static IEnumerable<(string ShapeName, CirNode Node, double? ExpectedVolume)> BuildShapes()
+ {
+ yield return ("box", new CirBoxNode(6d, 4d, 2d), 48d);
+ yield return BuildBoxMinusCylinder();
+ yield return ("sphere", new CirSphereNode(2d), (4d / 3d) * System.Math.PI * 8d);
+ var transformedSphere = new CirTransformNode(new CirSphereNode(2d), Transform3D.CreateTranslation(new Vector3D(3d, -1d, 2d)));
+ yield return ("transformed_sphere", transformedSphere, (4d / 3d) * System.Math.PI * 8d);
+ }
+
+ private static (string ShapeName, CirNode Node, double? ExpectedVolume) BuildBoxMinusCylinder()
+ {
+ var box = new CirBoxNode(8d, 8d, 8d);
+ var cut = new CirSubtractNode(box, new CirCylinderNode(2d, 8d));
+ var expected = (8d * 8d * 8d) - (System.Math.PI * 4d * 8d);
+ return ("box_minus_cylinder", cut, expected);
+ }
+
+ private static CirAdaptiveCalibrationPolicy ConservativePolicy()
+ => new("conservative", new CirAdaptiveVolumeOptions(MaxDepth: 8, DirectSampleGrid: 2, MaxTraceEvents: 80, MinimumRegionExtent: 0.04d), DenseResolution: 32);
+
+ private static CirAdaptiveCalibrationPolicy CoarsePolicy()
+ => new("coarse", new CirAdaptiveVolumeOptions(MaxDepth: 4, DirectSampleGrid: 3, MaxTraceEvents: 80, MinimumRegionExtent: 0.08d), DenseResolution: 32);
+}