Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

13.6 KB
Raw Blame
using Aetheris.Kernel.Core.Brep;
using Aetheris.Kernel.Core.Step242;
using Aetheris.Kernel.Firmament.Visualization;

namespace Aetheris.Kernel.Firmament.Tests;

/// <summary>PMI on a composed machined part, as an engineer would specify it for manufacture.</summary>
public sealed class PmiShowcaseTests
{
    private static string Fixture(string relative)
    {
        var directory = new DirectoryInfo(AppContext.BaseDirectory);
        while (directory is not null && !File.Exists(Path.Combine(directory.FullName, "Aetheris.slnx"))) directory = directory.Parent;
        return Path.Combine(directory!.FullName, relative);
    }

    private static string Showcase() => File.ReadAllText(Fixture("fixtures/Canonical/PMI/showcase-bearing-mount.firmament"));

    private const string Plate = """
        Model P {
          units: mm
          Static d: Length = 8mm tol +0.1mm -0.05mm
          Profile s = Rect2 { center: [0mm, 0mm]; size: [60mm, 40mm] }
          Profile pad = Circle2 { center: [0mm, 0mm]; radius: 10mm }
          Compose body {
            Base stock { profile: s; from: 0mm; to: 8mm; role: Stock }
            Boss hub { on: Top; profile: pad; height: 6mm }
            Hole<Shaft> h { on: +Z; center: [0mm, 0mm]; diameter: d; end: ThroughAll }
            Hole<Shaft> a { on: +Z; center: [-22mm, -12mm]; diameter: 5mm; end: ThroughAll }
            Hole<Shaft> b { on: +Z; center: [22mm, -12mm]; diameter: 5mm; end: ThroughAll }
          }
          Pmi {
            PMI_BODY
          }
        }
        """;

    private static FirmamentStepExportResult Build(string pmi)
    {
        var result = FirmamentBuildAndExport.CompileSource(Plate.Replace("PMI_BODY", pmi));
        Assert.True(result.IsSuccess, string.Join("; ", result.Diagnostics.Select(d => d.Message)));
        return result.Value;
    }

    [Fact]
    public void RoundedStock_RimChamferRetainsBossPocketsAndCounterbores()
    {
        var source = Showcase().Replace(
            "Profile stockOutline = Rect2 { center: [0mm, 0mm]; size: [130mm, 90mm] }",
            "Profile stockOutline = RoundedRect2 { center: [0mm, 0mm]; size: [130mm, 90mm]; radius: 8mm }");
        Assert.Contains("RoundedRect2 { center: [0mm, 0mm]; size: [130mm, 90mm]", source);
        var result = FirmamentBuildAndExport.CompileSource(source);
        Assert.True(result.IsSuccess, string.Join("; ", result.Diagnostics.Select(d => d.Message)));
        var body = Step242Importer.ImportBody(result.Value.StepText).Value!;
        var kinds = body.Geometry.Surfaces.GroupBy(s => s.Value.Kind).ToDictionary(g => g.Key, g => g.Count());
        // One cone per rounded corner of the 1mm rim chamfer; the retained bore, boss, pocket corners
        // and counterbores are cylinders; nothing degrades to a spline.
        Assert.Equal(4, kinds.GetValueOrDefault(Core.Geometry.SurfaceGeometryKind.Cone));
        Assert.False(kinds.ContainsKey(Core.Geometry.SurfaceGeometryKind.BSplineSurfaceWithKnots));
        Assert.True(BrepExportPreflight.Validate(body).IsValid);
        var pmi = Step242SemanticPmiInspector.Inspect(result.Value.StepText);
        Assert.All(pmi.Items.Where(i => i.Kind != "Annotation"), i => Assert.NotEmpty(i.GeometricFaceEntityIds));
    }

    [Fact]
    public void RimChamfer_RejectsAPocketInsideTheCorridor()
    {
        var source = Showcase()
            .Replace("Profile stockOutline = Rect2 { center: [0mm, 0mm]; size: [130mm, 90mm] }",
                "Profile stockOutline = RoundedRect2 { center: [0mm, 0mm]; size: [130mm, 90mm]; radius: 8mm }")
            .Replace("EdgeFinish<Chamfer> perimeterBreak { target: stockOutline.Outer; on: Top; distance: 1mm }",
                "EdgeFinish<Chamfer> perimeterBreak { target: stockOutline.Outer; on: Top; distance: 9mm }");
        var result = FirmamentBuildAndExport.CompileSource(source);
        Assert.False(result.IsSuccess);
        Assert.Contains(result.Diagnostics, d => d.Message.Contains("ProfileRimFinishCavityInterference", StringComparison.Ordinal));
    }

    [Fact]
    public void TypedToleranceDimension_BindsOnAComposedBody()
    {
        var step = Build("HoleDiameter S { target: h dimension: d }").StepText;
        var size = Assert.Single(Step242SemanticPmiInspector.Inspect(step).Items, i => i.Kind == "Diameter");
        Assert.Equal(8, size.Value); Assert.Equal(.1, size.TolerancePlus); Assert.Equal(.05, size.ToleranceMinus);
    }

    [Fact]
    public void ComposeOperationCap_IsANamedPmiTarget()
    {
        var step = Build("Datum A { target: face(-Z) } Parallelism Top { target: face(hub.Top) tolerance: 0.02mm datumRefs: [A] }").StepText;
        var control = Assert.Single(Step242SemanticPmiInspector.Inspect(step).Items, i => i.Kind == "Parallelism");
        Assert.Single(control.GeometricFaceEntityIds);
        // The ambiguous axis spelling is not silently resolved to some +Z face of a stepped body.
        var body = Core.Step242.Step242Importer.ImportBody(step).Value;
        var face = body.Bindings.FaceBindings.Single(b => b.SourceStepEntityId == control.GeometricFaceEntityIds[0]);
        Assert.Equal(14, body.GetFaceSurface(face.FaceId).Plane!.Value.Origin.Z, 9);
    }

    [Fact]
    public void AxisDatum_OnASplitFace_AttachesToEveryCoplanarPatch()
    {
        var step = Build("Datum A { target: face(-Z) } Datum B { target: face(-X) } Datum C { target: face(-Y) }").StepText;
        var datums = Step242SemanticPmiInspector.Inspect(step).Items.Where(i => i.Kind == "Datum").ToArray();
        Assert.Equal(3, datums.Length);
        Assert.All(datums, d => Assert.NotEmpty(d.GeometricFaceEntityIds));
    }

    [Fact]
    public void HoleList_IsOneRequirementWithItsQuantity_OnShaftWallsOnly()
    {
        var step = Build("Datum A { target: face(-Z) } Datum B { target: face(-X) } Datum C { target: face(-Y) }\n"
            + "HoleDiameter S { target: [a, b] value: 5mm tolerance: PlusMinus(0.1mm) }\n"
            + "Position L { target: [a, b] tolerance: 0.2mm zone: Cylindrical datumRefs: [A, B, C] modifiers: [MaximumMaterial] }").StepText;
        var items = Step242SemanticPmiInspector.Inspect(step).Items;
        var size = Assert.Single(items, i => i.Kind == "Diameter");
        var position = Assert.Single(items, i => i.Kind == "Position");
        Assert.Equal(2, size.Quantity); Assert.Equal(2, position.Quantity);
        Assert.Equal(size.GeometricFaceEntityIds.Order(), position.GeometricFaceEntityIds.Order());
        var display = PmiDisplayProjection.FromStep(step);
        Assert.StartsWith("2X Ø5 ±0.1", Assert.Single(display, a => a.Kind == "Diameter").Text);
    }

    [Theory]
    [InlineData("HoleDiameter S { target: [a] value: 5mm tolerance: PlusMinus(0.1mm) }")]
    [InlineData("HoleDiameter S { target: [a, missing] value: 5mm tolerance: PlusMinus(0.1mm) }")]
    [InlineData("Datum A { target: [a, b] }")]
    public void InvalidHoleLists_Reject(string pmi)
    {
        var result = FirmamentBuildAndExport.CompileSource(Plate.Replace("PMI_BODY", pmi));
        Assert.False(result.IsSuccess);
    }

    [Fact]
    public void PartNotes_ExportAndReadBack()
    {
        var step = Build("Note Material { text: \"MATERIAL: 6061-T6\" }").StepText;
        var note = Assert.Single(Step242SemanticPmiInspector.Inspect(step).Items, i => i.Kind == "Annotation");
        Assert.Equal("Material", note.Name); Assert.Equal("MATERIAL: 6061-T6", note.Text);
        var result = FirmamentBuildAndExport.CompileSource(Plate.Replace("PMI_BODY", "Note Empty { text: \"\" }"));
        Assert.False(result.IsSuccess);
    }

    [Fact]
    public void Showcase_SpecifiesThePartCompletely_AndEveryRecordIsDrawn()
    {
        var result = FirmamentBuildAndExport.CompileSource(Showcase());
        Assert.True(result.IsSuccess, string.Join("; ", result.Diagnostics.Select(d => d.Message)));
        var inspection = Step242SemanticPmiInspector.Inspect(result.Value.StepText);
        Assert.Equal(3, inspection.DatumCount); Assert.Equal(17, inspection.DimensionCount);
        Assert.Equal(5, inspection.GeometricToleranceCount); Assert.Equal(3, inspection.AnnotationCount);
        Assert.All(inspection.Items.Where(i => i.Kind != "Annotation"), i => Assert.NotEmpty(i.GeometricFaceEntityIds));
        var display = PmiDisplayProjection.FromStep(result.Value.StepText);
        Assert.Equal(inspection.Items.Count, display.Count);
        Assert.All(display, a => Assert.NotEmpty(a.Lines));
        Assert.Contains(display, a => a.Text.StartsWith("4X Ø6.6 ±0.1", StringComparison.Ordinal));
        Assert.Contains(display, a => a.Text == "Position Ø0.25 (M) | A | B | C");
        Assert.Contains(display, a => a.Text == "2X 16 × 40");
        Assert.Contains(display, a => a.Text == "1 × 45°");
    }

    [Fact]
    public void ProjectedDimensions_ComeFromTheBuiltGeometry()
    {
        var step = Build("""
            Datum A { target: face(-Z) }
            Dimension T { target: stock.Height }
            Dimension L { target: stock.Length }
            Dimension W { target: stock.Width }
            Dimension D { target: hub.Diameter }
            Dimension H { target: hub.Height }
            Location FromB { origin: face(-X) to: hub }
            Location HoleFromC { origin: face(-Y) to: a basic: true }
            """).StepText;
        var items = Step242SemanticPmiInspector.Inspect(step).Items.Where(i => i.Kind == "Dimension").ToDictionary(i => i.Name);
        Assert.Equal(8, items["T"].Value); Assert.Equal("thickness", items["T"].DimensionKind);
        Assert.Equal(60, items["L"].Value); Assert.Equal(40, items["W"].Value);
        Assert.Equal(20, items["D"].Value); Assert.Equal(6, items["H"].Value);
        Assert.Equal(30, items["FromB"].Value); Assert.Equal("location -X", items["FromB"].DimensionKind);
        Assert.Equal(8, items["HoleFromC"].Value); Assert.Equal("location -Y basic", items["HoleFromC"].DimensionKind);
        Assert.All(items.Values, i => Assert.NotEmpty(i.GeometricFaceEntityIds));
    }

    [Fact]
    public void Sizes_AreAlsoWrittenInStandardAp242Form_AndReadOnce()
    {
        var step = Build("HoleDiameter S { target: h dimension: d } Dimension D { target: hub.Diameter } Dimension T { target: stock.Height }").StepText;
        Assert.Contains("DIMENSIONAL_SIZE(", step); Assert.Contains("PLUS_MINUS_TOLERANCE(", step); Assert.Contains("DIMENSIONAL_LOCATION(", step);
        Assert.Equal(3, Step242SemanticPmiInspector.Inspect(step).DimensionCount);
        // A reader that only knows the standard entities finds the same sizes and limits.
        var standardOnly = step.Replace("PROPERTY_DEFINITION('diameter:", "PROPERTY_DEFINITION('x:").Replace("PROPERTY_DEFINITION('dimension:", "PROPERTY_DEFINITION('x:")
            .Replace("'firmament-native:", "'x:");
        var dims = Step242SemanticPmiInspector.Inspect(standardOnly).Items.Where(i => i.Kind == "Dimension").ToArray();
        var hole = Assert.Single(dims, i => i.Value == 8 && i.DimensionKind == "diameter");
        Assert.Equal(.1, hole.TolerancePlus); Assert.Equal(.05, hole.ToleranceMinus);
        Assert.Single(dims, i => i.Value == 20 && i.DimensionKind == "diameter");
        Assert.Single(dims, i => i.Value == 8 && i.DimensionKind == "linear distance");
    }

    [Fact]
    public void HoleCallout_ProjectsItsCounterbore()
    {
        var source = Plate.Replace("Hole<Shaft> a { on: +Z; center: [-22mm, -12mm]; diameter: 5mm; end: ThroughAll }",
            "Hole<Counterbore> a { on: +Z; center: [-22mm, -12mm]; diameter: 5mm; counterboreDiameter: 9mm; counterboreDepth: 3mm; end: ThroughAll }")
            .Replace("PMI_BODY", "HoleCallout C { target: a value: 5mm tolerance: PlusMinus(0.1mm) }");
        var result = FirmamentBuildAndExport.CompileSource(source);
        Assert.True(result.IsSuccess, string.Join("; ", result.Diagnostics.Select(d => d.Message)));
        var items = Step242SemanticPmiInspector.Inspect(result.Value.StepText).Items;
        Assert.Single(items, i => i.Kind == "Diameter" && i.Value == 5);
        Assert.Single(items, i => i.Name == "C.CounterboreDiameter" && i.Value == 9);
        Assert.Single(items, i => i.Name == "C.CounterboreDepth" && i.Value == 3);
        Assert.Contains(PmiDisplayProjection.FromStep(result.Value.StepText), a => a.Text.Contains("Ø5 ±0.1", StringComparison.Ordinal));
    }

    [Theory]
    [InlineData("Dimension D { target: stock.Volume }")]
    [InlineData("Dimension D { target: [hub.Diameter, stock.Height] }")]
    [InlineData("Location L { origin: face(+Z) to: hub }")]
    [InlineData("Location L { origin: face(-X) to: nothing }")]
    [InlineData("Location L { origin: face(-X) to: hub basic: true tolerance: PlusMinus(0.1mm) }")]
    public void InvalidProjections_Reject(string pmi)
    {
        var result = FirmamentBuildAndExport.CompileSource(Plate.Replace("PMI_BODY", pmi));
        Assert.False(result.IsSuccess);
    }

    [Fact]
    public void HoleWall_OnAComposeHole_TargetsItsShaft()
    {
        var step = Build("Datum A { target: face(-Z) } Position P { target: face(h.Wall) tolerance: 0.1mm datumRefs: [A] }").StepText;
        Assert.NotEmpty(Assert.Single(Step242SemanticPmiInspector.Inspect(step).Items, i => i.Kind == "Position").GeometricFaceEntityIds);
    }

    [Fact]
    public void PmiRecordErrors_AreLocatedAndExplained()
    {
        var source = Plate.Replace("PMI_BODY", "HoleDiameter S { target: h dimension: nothere }");
        var report = FirmamentV2.FirmamentV2ValidationReportBuilder.Build(FirmamentV2.FirmamentV2Parser.Parse(source), "plate.firmament", sourceText: source);
        var error = Assert.Single(report.Diagnostics, d => d.Code.StartsWith("firmament-v2-pmi-dimension-type-mismatch:", StringComparison.Ordinal));
        Assert.Contains("toleranced Length Static", error.Message);
        Assert.NotNull(error.Line); Assert.NotEqual(1, error.Line);
    }
}