Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Implement M6b topology-backed expect_exists selector checks

Yuechen Li4a8a97c4f9e7
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
index fe92f74d..1fd6cce9 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
@@ -118,7 +118,7 @@ public sealed class FirmamentPrimitiveExecutionTests
Assert.True(result.Compilation.IsSuccess);
var artifact = result.Compilation.Value;
- Assert.Equal("firmament-contract-validations-executed", artifact.ArtifactKind);
+ Assert.Equal("firmament-topology-exists-validation-executed", artifact.ArtifactKind);
Assert.Equal(2, artifact.PrimitiveLoweringPlan!.Primitives.Count);
Assert.Equal(2, artifact.PrimitiveLoweringPlan.Booleans.Count);
Assert.Single(artifact.PrimitiveLoweringPlan.SkippedOps);
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentScaffoldTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentScaffoldTests.cs
index 485347de..a22fd063 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentScaffoldTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentScaffoldTests.cs
@@ -37,7 +37,7 @@ public sealed class FirmamentScaffoldTests
Assert.True(result.Compilation.IsSuccess);
var artifact = result.Compilation.Value;
- Assert.Equal("firmament-contract-validations-executed", artifact.ArtifactKind);
+ Assert.Equal("firmament-topology-exists-validation-executed", artifact.ArtifactKind);
Assert.NotNull(artifact.ParsedDocument);
Assert.Equal("1", artifact.ParsedDocument!.Firmament.Version);
Assert.Equal("demo", artifact.ParsedDocument.Model.Name);
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentValidationExecutionTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentValidationExecutionTests.cs
index 5c8dd357..04275bc0 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentValidationExecutionTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentValidationExecutionTests.cs
@@ -20,14 +20,32 @@ public sealed class FirmamentValidationExecutionTests
}
[Fact]
- public void Compile_Executes_ExpectExists_For_ContractValid_SelectorTarget()
+ public void Compile_Executes_ExpectExists_For_TopologyBacked_SelectorTargets()
{
- var result = CompileFixture("testdata/firmament/fixtures/m6a-valid-expect-exists-selector-contract-level.firmament");
+ var result = CompileFixture("testdata/firmament/fixtures/m6b-valid-selector-exists.firmament");
+
+ Assert.True(result.Compilation.IsSuccess);
+ var validations = result.Compilation.Value.ValidationExecutionResult!.Validations;
+ Assert.Equal(4, validations.Count);
+ Assert.All(validations, validation =>
+ {
+ Assert.True(validation.IsExecuted);
+ Assert.True(validation.IsSuccess);
+ Assert.Null(validation.Reason);
+ });
+ }
+
+ [Fact]
+ public void Compile_Executes_ExpectExists_For_Empty_SelectorResolution_As_Deterministic_Failure()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m6b-invalid-selector-empty.firmament");
Assert.True(result.Compilation.IsSuccess);
var validation = Assert.Single(result.Compilation.Value.ValidationExecutionResult!.Validations);
Assert.True(validation.IsExecuted);
- Assert.True(validation.IsSuccess);
+ Assert.False(validation.IsSuccess);
+ Assert.Equal("Selector 'sphere.edges' resolved to no topology elements.", validation.Reason);
+
}
[Fact]
@@ -143,7 +161,7 @@ ops[4]:
}
[Fact]
- public void Compile_Still_Executes_Primitives_And_Booleans_With_M6a_ValidationExecution_Output()
+ public void Compile_Still_Executes_Primitives_And_Booleans_With_M6b_ValidationExecution_Output()
{
var result = CompileFixture("testdata/firmament/fixtures/m3d-mixed-primitive-boolean-validation.firmament");
diff --git a/Aetheris.Kernel.Firmament/Diagnostics/FirmamentDiagnosticCodes.cs b/Aetheris.Kernel.Firmament/Diagnostics/FirmamentDiagnosticCodes.cs
index a7a9d77e..80d2aa05 100644
--- a/Aetheris.Kernel.Firmament/Diagnostics/FirmamentDiagnosticCodes.cs
+++ b/Aetheris.Kernel.Firmament/Diagnostics/FirmamentDiagnosticCodes.cs
@@ -30,6 +30,7 @@ public static class FirmamentDiagnosticCodes
public static readonly FirmamentDiagnosticCode ValidationTargetUnknownSelectorRootFeatureId = new($"{FirmamentDiagnosticConventions.ReferencePrefix}-0004");
public static readonly FirmamentDiagnosticCode ValidationTargetInvalidSelectorPortToken = new($"{FirmamentDiagnosticConventions.ReferencePrefix}-0005");
public static readonly FirmamentDiagnosticCode ValidationTargetSelectorPortNotAllowedForFeatureKind = new($"{FirmamentDiagnosticConventions.ReferencePrefix}-0006");
+ public static readonly FirmamentDiagnosticCode ValidationTargetSelectorResolvedEmpty = new($"{FirmamentDiagnosticConventions.ReferencePrefix}-0007");
public static readonly FirmamentDiagnosticCode SelectorPlaceholder = new($"{FirmamentDiagnosticConventions.SelectorPrefix}-0001");
public static readonly FirmamentDiagnosticCode SchemaPlaceholder = new($"{FirmamentDiagnosticConventions.SchemaPrefix}-0001");
public static readonly FirmamentDiagnosticCode LoweringPlaceholder = new($"{FirmamentDiagnosticConventions.LoweringPrefix}-0001");
diff --git a/Aetheris.Kernel.Firmament/Execution/FirmamentSelectorResolver.cs b/Aetheris.Kernel.Firmament/Execution/FirmamentSelectorResolver.cs
new file mode 100644
index 00000000..9f324b26
--- /dev/null
+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentSelectorResolver.cs
@@ -0,0 +1,48 @@
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Firmament.ParsedModel;
+using Aetheris.Kernel.Firmament.Validation;
+
+namespace Aetheris.Kernel.Firmament.Execution;
+
+internal static class FirmamentSelectorResolver
+{
+ public static bool TryResolve(
+ string selectorTarget,
+ IReadOnlyDictionary<string, BrepBody> featureBodies,
+ FirmamentSelectorResultKind resultKind,
+ out FirmamentSelectorResolution resolution)
+ {
+ resolution = null!;
+
+ var separatorIndex = selectorTarget.IndexOf('.', StringComparison.Ordinal);
+ if (separatorIndex <= 0 || separatorIndex >= selectorTarget.Length - 1)
+ {
+ return false;
+ }
+
+ var featureId = selectorTarget[..separatorIndex];
+ var port = selectorTarget[(separatorIndex + 1)..];
+
+ if (!featureBodies.TryGetValue(featureId, out var body))
+ {
+ return false;
+ }
+
+ var count = resultKind switch
+ {
+ FirmamentSelectorResultKind.Face or FirmamentSelectorResultKind.FaceSet => body.Topology.Faces.Count(),
+ FirmamentSelectorResultKind.EdgeSet => body.Topology.Edges.Count(),
+ FirmamentSelectorResultKind.VertexSet => body.Topology.Vertices.Count(),
+ _ => 0
+ };
+
+ resolution = new FirmamentSelectorResolution(featureId, port, resultKind, count);
+ return true;
+ }
+}
+
+internal sealed record FirmamentSelectorResolution(
+ string FeatureId,
+ string Port,
+ FirmamentSelectorResultKind ResultKind,
+ int Count);
diff --git a/Aetheris.Kernel.Firmament/Execution/FirmamentValidationExecutor.cs b/Aetheris.Kernel.Firmament/Execution/FirmamentValidationExecutor.cs
index 2a48e092..8d48534e 100644
--- a/Aetheris.Kernel.Firmament/Execution/FirmamentValidationExecutor.cs
+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentValidationExecutor.cs
@@ -1,5 +1,7 @@
using System.Globalization;
+using Aetheris.Kernel.Core.Diagnostics;
using Aetheris.Kernel.Core.Results;
+using Aetheris.Kernel.Firmament.Diagnostics;
using Aetheris.Kernel.Firmament.ParsedModel;
using Aetheris.Kernel.Firmament.Validation;
@@ -7,11 +9,16 @@ namespace Aetheris.Kernel.Firmament.Execution;
internal static class FirmamentValidationExecutor
{
- public static KernelResult<FirmamentValidationExecutionResult> Execute(FirmamentParsedDocument parsedDocument)
+ public static KernelResult<FirmamentValidationExecutionResult> Execute(
+ FirmamentParsedDocument parsedDocument,
+ FirmamentPrimitiveExecutionResult primitiveExecutionResult)
{
ArgumentNullException.ThrowIfNull(parsedDocument);
+ ArgumentNullException.ThrowIfNull(primitiveExecutionResult);
var validations = new List<FirmamentExecutedValidation>();
+ var diagnostics = new List<KernelDiagnostic>();
+ var featureBodies = BuildFeatureBodyMap(primitiveExecutionResult);
for (var index = 0; index < parsedDocument.Ops.Entries.Count; index++)
{
@@ -24,7 +31,7 @@ internal static class FirmamentValidationExecutor
var target = entry.RawFields.TryGetValue("target", out var targetRaw) ? targetRaw : null;
var result = entry.KnownKind switch
{
- FirmamentKnownOpKind.ExpectExists => ExecuteExpectExists(index, entry, target),
+ FirmamentKnownOpKind.ExpectExists => ExecuteExpectExists(index, entry, target, featureBodies, diagnostics),
FirmamentKnownOpKind.ExpectSelectable => ExecuteExpectSelectable(index, entry, target),
FirmamentKnownOpKind.ExpectManifold => new FirmamentExecutedValidation(
OpIndex: index,
@@ -46,25 +53,75 @@ internal static class FirmamentValidationExecutor
}
return KernelResult<FirmamentValidationExecutionResult>.Success(
- new FirmamentValidationExecutionResult(validations));
+ new FirmamentValidationExecutionResult(validations),
+ diagnostics);
}
- private static FirmamentExecutedValidation ExecuteExpectExists(int opIndex, FirmamentParsedOpEntry entry, string? target)
+ private static FirmamentExecutedValidation ExecuteExpectExists(
+ int opIndex,
+ FirmamentParsedOpEntry entry,
+ string? target,
+ IReadOnlyDictionary<string, Aetheris.Kernel.Core.Brep.BrepBody> featureBodies,
+ ICollection<KernelDiagnostic> diagnostics)
{
+ if (string.IsNullOrWhiteSpace(target))
+ {
+ return new FirmamentExecutedValidation(
+ OpIndex: opIndex,
+ Kind: entry.KnownKind,
+ Target: target,
+ IsExecuted: true,
+ IsSuccess: false,
+ Reason: "expect_exists target is not executable at M6a.");
+ }
+
var isSelectorShaped = entry.ClassifiedFields is not null
&& entry.ClassifiedFields.TryGetValue("targetShape", out var targetShape)
&& string.Equals(targetShape, FirmamentValidationTargetShape.SelectorShaped.ToString(), StringComparison.Ordinal);
- var isSuccess = !string.IsNullOrWhiteSpace(target)
- && (isSelectorShaped || IsFeatureIdTarget(entry));
+ if (!isSelectorShaped)
+ {
+ var isSuccess = IsFeatureIdTarget(entry);
+ return new FirmamentExecutedValidation(
+ OpIndex: opIndex,
+ Kind: entry.KnownKind,
+ Target: target,
+ IsExecuted: true,
+ IsSuccess: isSuccess,
+ Reason: isSuccess ? null : "expect_exists target is not executable at M6a.");
+ }
+
+ if (entry.ClassifiedFields is null
+ || !entry.ClassifiedFields.TryGetValue("selectorResultKind", out var selectorResultKind)
+ || !Enum.TryParse<FirmamentSelectorResultKind>(selectorResultKind, out var resultKind)
+ || !FirmamentSelectorResolver.TryResolve(target, featureBodies, resultKind, out var resolution))
+ {
+ return new FirmamentExecutedValidation(
+ OpIndex: opIndex,
+ Kind: entry.KnownKind,
+ Target: target,
+ IsExecuted: true,
+ IsSuccess: false,
+ Reason: "expect_exists selector target could not be resolved to executable topology at M6b.");
+ }
+
+ var success = resolution.Count > 0;
+ if (!success)
+ {
+ diagnostics.Add(CreateDiagnostic(
+ FirmamentDiagnosticCodes.ValidationTargetSelectorResolvedEmpty,
+ $"Selector '{target}' resolved to no topology elements."));
+ }
return new FirmamentExecutedValidation(
OpIndex: opIndex,
Kind: entry.KnownKind,
Target: target,
IsExecuted: true,
- IsSuccess: isSuccess,
- Reason: isSuccess ? null : "expect_exists target is not executable at M6a.");
+ IsSuccess: success,
+ Reason: success
+ ? null
+ : $"Selector '{target}' resolved to no topology elements.");
}
private static FirmamentExecutedValidation ExecuteExpectSelectable(int opIndex, FirmamentParsedOpEntry entry, string? target)
@@ -110,8 +167,32 @@ internal static class FirmamentValidationExecutor
: $"expect_selectable count '{requestedCount}' is incompatible with selector cardinality '{selectorCardinality}' at M6a contract level.");
}
+ private static IReadOnlyDictionary<string, Aetheris.Kernel.Core.Brep.BrepBody> BuildFeatureBodyMap(FirmamentPrimitiveExecutionResult primitiveExecutionResult)
+ {
+ var map = new Dictionary<string, Aetheris.Kernel.Core.Brep.BrepBody>(StringComparer.Ordinal);
+
+ foreach (var primitive in primitiveExecutionResult.ExecutedPrimitives)
+ {
+ map[primitive.FeatureId] = primitive.Body;
+ }
+
+ foreach (var boolean in primitiveExecutionResult.ExecutedBooleans)
+ {
+ map[boolean.FeatureId] = boolean.Body;
+ }
+
+ return map;
+ }
+
private static bool IsFeatureIdTarget(FirmamentParsedOpEntry entry) =>
entry.ClassifiedFields is not null
&& entry.ClassifiedFields.TryGetValue("targetShape", out var targetShape)
&& string.Equals(targetShape, FirmamentValidationTargetShape.FeatureId.ToString(), StringComparison.Ordinal);
+
+ private static KernelDiagnostic CreateDiagnostic(FirmamentDiagnosticCode code, string message) =>
+ new(
+ KernelDiagnosticCode.ValidationFailed,
+ KernelDiagnosticSeverity.Warning,
+ $"[{code.Value}] {message}",
+ FirmamentDiagnosticConventions.Source);
}
diff --git a/Aetheris.Kernel.Firmament/FirmamentCompilationArtifact.cs b/Aetheris.Kernel.Firmament/FirmamentCompilationArtifact.cs
index a38914e2..3117cb6a 100644
--- a/Aetheris.Kernel.Firmament/FirmamentCompilationArtifact.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentCompilationArtifact.cs
@@ -5,7 +5,7 @@ using Aetheris.Kernel.Firmament.ParsedModel;
namespace Aetheris.Kernel.Firmament;
public sealed record FirmamentCompilationArtifact(
- string ArtifactKind = "firmament-m5b-selector-contract-metadata-validated-primitives-and-booleans-executed",
+ string ArtifactKind = "firmament-topology-exists-validation-executed",
FirmamentParsedDocument? ParsedDocument = null,
FirmamentPrimitiveLoweringPlan? PrimitiveLoweringPlan = null,
FirmamentPrimitiveExecutionResult? PrimitiveExecutionResult = null,
diff --git a/Aetheris.Kernel.Firmament/FirmamentCompiler.cs b/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
index 35de24d7..4cc669d8 100644
--- a/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentCompiler.cs
@@ -70,7 +70,7 @@ public sealed class FirmamentCompiler
KernelResult<FirmamentCompilationArtifact>.Failure(primitiveExecutionResult.Diagnostics));
}
- var validationExecutionResult = FirmamentValidationExecutor.Execute(validatedDocument);
+ var validationExecutionResult = FirmamentValidationExecutor.Execute(validatedDocument, primitiveExecutionResult.Value);
if (!validationExecutionResult.IsSuccess)
{
return new FirmamentCompileResult(
@@ -80,7 +80,7 @@ public sealed class FirmamentCompiler
return new FirmamentCompileResult(
KernelResult<FirmamentCompilationArtifact>.Success(
new FirmamentCompilationArtifact(
- ArtifactKind: "firmament-contract-validations-executed",
+ ArtifactKind: "firmament-topology-exists-validation-executed",
ParsedDocument: validatedDocument,
PrimitiveLoweringPlan: primitiveLoweringResult.Value,
PrimitiveExecutionResult: primitiveExecutionResult.Value,
diff --git a/testdata/firmament/fixtures/m6b-invalid-selector-empty.firmament b/testdata/firmament/fixtures/m6b-invalid-selector-empty.firmament
new file mode 100644
index 00000000..2129af52
--- /dev/null
+++ b/testdata/firmament/fixtures/m6b-invalid-selector-empty.firmament
@@ -0,0 +1,15 @@
+firmament:
+ version: 1
+
+model:
+ name: m6b_invalid_selector_empty
+ units: mm
+
+ops[2]:
+ -
+ op: sphere
+ id: sphere
+ radius: 3
+ -
+ op: expect_exists
+ target: sphere.edges
diff --git a/testdata/firmament/fixtures/m6b-valid-selector-exists.firmament b/testdata/firmament/fixtures/m6b-valid-selector-exists.firmament
new file mode 100644
index 00000000..f22b6414
--- /dev/null
+++ b/testdata/firmament/fixtures/m6b-valid-selector-exists.firmament
@@ -0,0 +1,46 @@
+firmament:
+ version: 1
+
+model:
+ name: m6b_valid_selector_exists
+ units: mm
+
+ops[8]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 10
+ 8
+ 6
+ -
+ op: sphere
+ id: sphere
+ radius: 4
+ -
+ op: cylinder
+ id: cyl
+ radius: 2
+ height: 5
+ -
+ op: add
+ id: join
+ to: base
+ with:
+ op: box
+ size[3]:
+ 1
+ 1
+ 1
+ -
+ op: expect_exists
+ target: base.top_face
+ -
+ op: expect_exists
+ target: sphere.surface
+ -
+ op: expect_exists
+ target: cyl.side_face
+ -
+ op: expect_exists
+ target: join.edges