Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

9.1 KB
Raw Blame
using Aetheris.Kernel.Core.Brep;
using Aetheris.Kernel.Core.Brep.Verification;
using Aetheris.Kernel.Core.Geometry;
using Aetheris.Kernel.Core.Step242;
using Aetheris.Kernel.Firmament.FirmamentV2;
using Aetheris.Kernel.Firmament.Materializer;

namespace Aetheris.Kernel.Firmament.Tests;

public sealed class FirmamentPathFeatureTests
{
    private static string Root
    {
        get
        {
            var root = new DirectoryInfo(AppContext.BaseDirectory);
            while (root is not null && !File.Exists(Path.Combine(root.FullName, "Aetheris.slnx"))) root = root.Parent;
            return root!.FullName;
        }
    }
    private static string Fixture(string file) => File.ReadAllText(Path.Combine(Root, "fixtures/Canonical/Features/PathFeatures", file));
    private static FirmamentV2ValidationReport Validate(string source) => FirmamentBuildAdmissionValidation.Admit(
        FirmamentV2ValidationReportBuilder.Build(FirmamentV2Parser.Parse(source), "path-feature.firmament", sourceText: source), source);
    private static string Messages<T>(Aetheris.Kernel.Core.Results.KernelResult<T> result) => string.Join("; ", result.Diagnostics.Select(d => d.Message));

    [Theory]
    [InlineData("manual-rib.firmament", "Stiffener", 16)]
    [InlineData("plate-seal-groove.firmament", "SealSeat", 8)]
    [InlineData("shaft-seal-groove.firmament", "SealSeat", 40)]
    [InlineData("bore-seal-groove.firmament", "SealSeat", 40)]
    [InlineData("arc-rib.firmament", "Stiffener", 14)]
    public void AuthoredFeatureBuildsThroughUnifiedAdmission(string fixture, string name, double maximumZ)
    {
        var source = Fixture(fixture); var validated = Validate(source);
        Assert.Equal("valid", validated.Status); Assert.Equal("Built", validated.ValidationLevel);
        var parsed = FirmamentV2Parser.Parse(source);
        Assert.Equal("UnifiedMechanical", parsed.ParserRoute);
        var declared = Assert.Single(parsed.Document!.PathFeatures);
        Assert.EndsWith(fixture is "manual-rib.firmament" or "arc-rib.firmament" ? "Spine" : "Seal", declared.GuideReference);
        var built = FirmamentBuildAndExport.CompileSource(source);
        Assert.True(built.IsSuccess, Messages(built));
        Assert.Equal(parsed.Document.ModelName, built.Value.ExportedFeatureId);
        Assert.Equal(name, Assert.Single(built.Value.MaterializedFeatures).Name);
        Assert.NotEmpty(built.Value.RuntimeCorrespondence!.Descendants);
        Assert.Equal(declared.GuideReference, Assert.Single(built.Value.EngineeringFeatures!).Profile);
        var featureFaces = built.Value.RuntimeCorrespondence.Descendants.Where(d => d.Role == SemanticTopologyRole.PathFeatureFace).ToArray();
        Assert.NotEmpty(featureFaces);
        Assert.All(featureFaces, d => Assert.Contains(name, d.StableId));
        var body = built.Value.RuntimeBody!;
        var points = body.Topology.Vertices.Select(v => { Assert.True(body.TryGetVertexPoint(v.Id, out var p)); return p; }).ToArray();
        Assert.Equal(0, points.Min(p => p.Z), 8); Assert.Equal(maximumZ, points.Max(p => p.Z), 8);
        Assert.True(BrepExportPreflight.Validate(body).IsValid);
        Assert.DoesNotContain("B_SPLINE_SURFACE", built.Value.StepText, StringComparison.Ordinal);
        Assert.All(body.Geometry.Curves, c => Assert.Null(c.Value.BSpline3));
        var imported = Step242Importer.ImportBody(built.Value.StepText);
        Assert.True(imported.IsSuccess, Messages(imported));
        var mass = BrepMassProperties.Evaluate(imported.Value);
        Assert.True(mass.IsEnclosed && mass.IsOrientationConsistent);
    }

    [Fact]
    public void TwoDifferentChannelSectionsBuildWithoutDroppingEither()
    {
        var source = Fixture("plate-channels.firmament"); Assert.Equal("valid", Validate(source).Status);
        var built = FirmamentBuildAndExport.CompileSource(source);
        Assert.True(built.IsSuccess, Messages(built)); Assert.Equal(2, built.Value.MaterializedFeatures.Count);
        Assert.Contains(built.Value.RuntimeBody!.Geometry.Surfaces, s => s.Value.Cylinder is not null);
        Assert.Contains(built.Value.RuntimeBody!.Geometry.Surfaces, s => s.Value.Sphere is not null);
        Assert.True(BrepMassProperties.Evaluate(built.Value.RuntimeBody!).IsEnclosed);
    }

    [Theory]
    [InlineData("shaft-seal-groove.firmament", "station: 20mm", "station: 1mm")]
    [InlineData("shaft-seal-groove.firmament", "radius: 15mm }", "radius: 14mm }")]
    [InlineData("bore-seal-groove.firmament", "radius: 2mm", "radius: 5mm")]
    [InlineData("plate-seal-groove.firmament", "radius: 1.5mm", "radius: 1.5mm; depth: 2mm")]
    public void GrooveContractsRejectWithoutWritingPartialGeometry(string fixture, string before, string after)
    {
        var source = Fixture(fixture).Replace(before, after, StringComparison.Ordinal);
        Assert.Equal("invalid", Validate(source).Status);
        Assert.False(FirmamentBuildAndExport.CompileSource(source).IsSuccess);
    }

    [Theory]
    [InlineData("thickness: 3mm", "thikness: 3mm", "canonical-field-unknown")]
    [InlineData("draft: 2deg", "draft: 30deg", "draft-collapse")]
    [InlineData("height: 10mm", "height: 0mm", "dimensions")]
    [InlineData("height: 10mm", "height: 10deg", "unit-mismatch")]
    [InlineData("on: face(Plate.Top)", "on: +X", "contract")]
    [InlineData("on XY", "on XZ", "frame")]
    [InlineData("path: Layout.Spine", "path: Missing", "guide")]
    [InlineData("Rib<Rectangular>", "Rib<Semicircular>", "contract")]
    [InlineData("ends: Round", "ends: Guess", "contract")]
    public void UnsupportedIntentNeverValidatesOrBuilds(string before, string after, string code)
    {
        var source = Fixture("manual-rib.firmament").Replace(before, after, StringComparison.Ordinal);
        var validated = Validate(source); var built = FirmamentBuildAndExport.CompileSource(source);
        Assert.Equal("invalid", validated.Status); Assert.False(built.IsSuccess);
        Assert.Contains(validated.Diagnostics, d => d.Code.Contains(code, StringComparison.Ordinal));
        Assert.Contains(validated.Diagnostics, d => d.SourceSpan is not null && d.Line > 0);
    }

    [Fact]
    public void ScalarBindingsAndOpenPathRetainTheirEngineeringMeaning()
    {
        const string source = """
            Model ParameterizedRib {
                units: mm
                Static H: Length = 8mm
                Path Spine { start: Point2(-15mm,0mm); heading: 0deg; Line Run { length: 30mm } }
                Box Plate { size: [50mm,40mm,5mm] }
                Modify Plate { Rib<Rectangular> Web { on: +Z; path: Spine; thickness: 3mm; height: H; draft: 1deg } }
            }
            """;
        var result = FirmamentBuildAndExport.CompileSource(source);
        Assert.True(result.IsSuccess, Messages(result));
        var body = result.Value.RuntimeBody!;
        var top = body.Topology.Vertices.Select(v => { body.TryGetVertexPoint(v.Id, out var p); return p.Z; }).Max();
        Assert.Equal(13, top, 8);
    }

    [Fact]
    public void MultipleManualRibsRemainNamedAfterReordering()
    {
        const string prefix = """
            Model Ribs {
            units: mm
            Path Left { start: Point2(-15mm,-8mm); heading: 0deg; Line RunL { length: 30mm } }
            Path Right { start: Point2(-15mm,8mm); heading: 0deg; Line RunR { length: 30mm } }
            Box Plate { size: [50mm,40mm,5mm] }
            Modify Plate {
            """;
        const string a = "Rib<Rectangular> Alpha { on: +Z; path: Left; thickness: 3mm; height: 8mm }";
        const string b = "Rib<Rectangular> Beta { on: +Z; path: Right; thickness: 3mm; height: 8mm }";
        var first = FirmamentBuildAndExport.CompileSource(prefix + a + b + "}}");
        var second = FirmamentBuildAndExport.CompileSource(prefix + b + a + "}}");
        Assert.True(first.IsSuccess, Messages(first)); Assert.True(second.IsSuccess, Messages(second));
        Assert.Equal(first.Value.RuntimeCorrespondence!.Descendants.Select(d => d.StableId).Order(),
            second.Value.RuntimeCorrespondence!.Descendants.Select(d => d.StableId).Order());
        Assert.Equal(2, second.Value.MaterializedFeatures.Count);
        Assert.Equal(BrepMassProperties.Evaluate(first.Value.RuntimeBody!).SignedVolume,
            BrepMassProperties.Evaluate(second.Value.RuntimeBody!).SignedVolume, 6);
        var crossing = prefix.Replace("Point2(-15mm,8mm)", "Point2(-15mm,-8mm)", StringComparison.Ordinal) + a + b + "}}";
        var rejected = FirmamentBuildAndExport.CompileSource(crossing);
        Assert.False(rejected.IsSuccess); Assert.Contains("redundant or completely buried", Messages(rejected));
    }

    [Fact]
    public void QualifiedGuideCannotCaptureAnotherLayoutsPointDependencies()
    {
        var source = Fixture("manual-rib.firmament").Replace("Box Plate", """
            Concept Struct Other on XY {
                Point2 Start { position: [1mm,1mm] }
                Point2 End { position: [2mm,1mm] }
            }
            Box Plate
            """, StringComparison.Ordinal);
        Assert.Equal("invalid", Validate(source).Status);
        var rejected = FirmamentBuildAndExport.CompileSource(source);
        Assert.False(rejected.IsSuccess); Assert.Contains("guide-ambiguous", Messages(rejected));
    }
}