Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

11.5 KB
Raw Blame
using Aetheris.Kernel.Firmament.Assembly;
using Aetheris.Semantics;

namespace Aetheris.Kernel.Firmament.Tests.Assembly;

public sealed class ArticulatedSubassemblyTests
{
    [Fact]
    public void RepeatedArticulatedDefinitionsKeepIndependentStateAndResolveRigidAncestry()
    {
        var compiled = new AssemblyM1Pipeline().CompileFile(Fixture("articulated-subassemblies.firmament"));
        Assert.True(compiled.IsSuccess, Evidence(compiled.Diagnostics));
        var ir = compiled.Ir!;
        Assert.Equal(2, compiled.Geometry!.Artifact.Definitions.Count);
        var definition = Assert.Single(ir.AssemblyDefinitions!);
        Assert.Single(definition.LocalJoints!);
        Assert.Equal(5, ir.Joints!.Count);
        var zero = AssemblyKinematics.Evaluate(ir, new Dictionary<string, double>());
        Assert.True(zero.IsSuccess, Evidence(zero.Diagnostics));
        foreach (var instance in ir.Instances)
            AssertMatrix(instance.ResolvedTransform!.Matrix, zero.Instances.Single(i => i.StableId == instance.StableId).ResolvedTransform!.Matrix);
        var state = new Dictionary<string, double> { ["Shoulder"] = 90, ["Articulated.First.Elbow"] = 45, ["Articulated.Second.Elbow"] = -30 };
        var pose = AssemblyKinematics.Evaluate(ir, state);
        Assert.True(pose.IsSuccess, Evidence(pose.Diagnostics));
        var tip = pose.Instances.Single(i => i.Path.ToString() == "Articulated.First.Tip");
        Assert.Equal(0, tip.ResolvedTransform!.Matrix[12], 9);
        Assert.Equal(20, tip.ResolvedTransform.Matrix[13], 9);
        Assert.Equal(Math.Cos(135 * Math.PI / 180), tip.ResolvedTransform.Matrix[0], 9);
        var follower = pose.Instances.Single(i => i.Path.ToString() == "Articulated.Follower");
        AssertMatrix(tip.ResolvedTransform.Matrix, follower.ResolvedTransform!.Matrix);
        var port = ir.Instances.Single(i => i.Path.ToString() == "Articulated.First").SemanticRoot.ExposedMembers["Tool"];
        var tool = Assert.IsType<ExactDatumFrameBinding>(AssemblyWorldQuery.Resolve(ir with { Instances = pose.Instances }, port.StableIdentity));
        Assert.Equal(tip.ResolvedTransform.Matrix[0], tool.XAxisX, 9);
        Assert.Equal(tip.ResolvedTransform.Matrix[13], tool.OriginY, 9);
        var second = pose.Instances.Single(i => i.Path.ToString() == "Articulated.Second.Tip");
        Assert.Equal(120, second.ResolvedTransform!.Matrix[12], 9);
        Assert.Equal(-0.5, second.ResolvedTransform.Matrix[1], 9);
        var again = AssemblyKinematics.Evaluate(ir, state.Reverse().ToDictionary(p => p.Key, p => p.Value));
        foreach (var instance in pose.Instances)
        {
            AssertMatrix(instance.ResolvedTransform!.Matrix, again.Instances.Single(i => i.StableId == instance.StableId).ResolvedTransform!.Matrix);
            Assert.Same(ir.Instances.Single(i => i.StableId == instance.StableId).SemanticRoot, instance.SemanticRoot);
        }
        Assert.True(AssemblyIrAp242Exporter.Export(compiled).IsSuccess);
    }

    [Fact]
    public void SharedDerivedFramesComposeBeforeSeating()
    {
        var compiled = new AssemblyM1Pipeline().CompileFile(Fixture("derived-datum-frames.firmament"));
        Assert.True(compiled.IsSuccess, Evidence(compiled.Diagnostics));
        var cam = Assert.Single(compiled.Ir!.Instances, i => i.Kind == AssemblyInstanceKind.Part);
        var matrix = cam.ResolvedTransform!.Matrix;
        Assert.Equal(3 + 100 / Math.Sqrt(2), matrix[12], 9);
        Assert.Equal(4 + 100 / Math.Sqrt(2), matrix[13], 9);
        Assert.Equal(25, matrix[14], 9);
        Assert.Equal(1, matrix[0], 9);
        Assert.Equal(0, matrix[1], 9);
    }

    [Fact]
    public void PlainPlacementFollowsAMovingTargetWithoutCreatingAPhysicalJoint()
    {
        var compiled = new AssemblyM1Pipeline().CompileFile(Fixture("relative-moving-frames.firmament"));
        Assert.True(compiled.IsSuccess, Evidence(compiled.Diagnostics));
        var ir = compiled.Ir!;
        Assert.Equal(2, ir.Joints!.Count);
        Assert.Single(ir.FrameDependencies);
        var pose = AssemblyKinematics.Evaluate(ir, new Dictionary<string, double> { ["Base"] = 90, ["Elbow"] = 45 });
        Assert.True(pose.IsSuccess, Evidence(pose.Diagnostics));
        foreach (var name in new[] { "Rigid", "Tip" })
        {
            var item = pose.Instances.Single(i => i.Path.ToString() == "RelativeFrames." + name);
            Assert.Equal(0, item.ResolvedTransform!.Matrix[12], 9);
            Assert.Equal(20, item.ResolvedTransform.Matrix[13], 9);
        }
        var tip = pose.Instances.Single(i => i.Path.ToString() == "RelativeFrames.Tip");
        Assert.Equal(Math.Cos(135 * Math.PI / 180), tip.ResolvedTransform!.Matrix[0], 9);
        var usd = AssemblyUsdExporter.Export(compiled);
        Assert.DoesNotContain("PhysicsFixedJoint", usd);
        Assert.Contains("PhysicsRevoluteJoint", usd);
    }

    [Theory]
    [InlineData("b: Articulated.First.Mount", "b: Articulated.First.Tool")]
    [InlineData("from: Mount;", "from: Tool;")]
    public void MovingInternalPortsCannotSilentlyBecomeRigidInstallationMounts(string from, string to)
    {
        var source = File.ReadAllText(Fixture("articulated-subassemblies.firmament")).ReplaceRequired(from, to);
        var parsed = new AssemblyM0Parser().Parse(source);
        Assert.True(parsed.IsSuccess, Evidence(parsed.Diagnostics));
        var compiled = new AssemblyM0Compiler().Compile(parsed.Source!);
        Assert.False(compiled.IsSuccess);
        Assert.Contains(compiled.Diagnostics, d => d.Code == "assembly-kinematic-moving-mount-unsupported");
    }

    [Fact]
    public void ExposedMovingParentRetainsAuthoredGapAndClocking()
    {
        var source = File.ReadAllText(Fixture("articulated-subassemblies.firmament"))
            .Replace("Interface<Fixed> Follow {", "Interface<Fixed> Follow { gap: 2mm; clocking: 30deg;");
        var compiled = new AssemblyM1Pipeline().Compile(source);
        Assert.True(compiled.IsSuccess, Evidence(compiled.Diagnostics));
        var ir = compiled.Ir!;
        var zero = AssemblyKinematics.Evaluate(ir, new Dictionary<string, double>());
        foreach (var instance in ir.Instances)
            AssertMatrix(instance.ResolvedTransform!.Matrix, zero.Instances.Single(i => i.StableId == instance.StableId).ResolvedTransform!.Matrix);
        var pose = AssemblyKinematics.Evaluate(ir, new Dictionary<string, double> { ["Shoulder"] = 90, ["Articulated.First.Elbow"] = 45 });
        Assert.True(pose.IsSuccess, Evidence(pose.Diagnostics));
        var follower = pose.Instances.Single(i => i.Path.ToString() == "Articulated.Follower");
        Assert.Equal(2, follower.ResolvedTransform!.Matrix[14], 9);
        Assert.Equal(Math.Cos(165 * Math.PI / 180), follower.ResolvedTransform.Matrix[0], 9);
    }

    [Theory]
        [InlineData("Interface Drive = Elbow;")]
    public void UnimplementedPublicInterfaceContractsDoNotDisappear(string exposure)
    {
        var source = File.ReadAllText(Fixture("articulated-subassemblies.firmament"))
            .Replace("DatumFrame Tool = Tip.Pivot.Frame;", "DatumFrame Tool = Tip.Pivot.Frame; " + exposure);
        var parsed = new AssemblyM0Parser().Parse(source);
        Assert.False(parsed.IsSuccess);
        Assert.Contains(parsed.Diagnostics, d => d.Code == "assembly-expose-kind-unsupported");
    }

    [Fact]
    public void UnresolvedPublicMateAliasRejectsRatherThanDisappearing()
    {
        var source = File.ReadAllText(Fixture("articulated-subassemblies.firmament")).Replace("Mate Bend = Elbow;", "Mate Bend = Missing;");
        var parsed = new AssemblyM0Parser().Parse(source);
        Assert.False(parsed.IsSuccess);
        Assert.Contains(parsed.Diagnostics, d => d.Code == "assembly-expose-mate-unresolved");
    }

    [Fact]
    public void PublicMateChannelCanBeReexportedThroughANestedReusableDefinition()
    {
        var source = File.ReadAllText(Fixture("articulated-subassemblies.firmament"));
        var wrapper = """
            Subassembly Sleeve {
              <Assembly Sleeve><Assembly Unit = Arm>
                Placement { from: Mount; to: World; }
              </Assembly></Assembly>
              anchor: Sleeve;
              expose { DatumFrame Mount = Unit.Mount; DatumFrame Tool = Unit.Tool; Mate Bend = Unit.Bend; }
            }
            """;
        source = source.Replace("Assembly Articulated {", wrapper + "\nAssembly Articulated {")
            .Replace("<Assembly First = Arm>", "<Assembly First = Sleeve>")
            .Replace("<Assembly Second = Arm>", "<Assembly Second = Sleeve>");
        source += "\n" + string.Join('\n', File.ReadAllLines(Fixture("articulated-motion.firmament")).Where(l => !l.StartsWith("include ", StringComparison.Ordinal)));
        var compiled = new AssemblyM1Pipeline().Compile(source);
        Assert.True(compiled.IsSuccess, Evidence(compiled.Diagnostics));
        var joint = Assert.Single(compiled.Ir!.Joints!, j => j.PublicNames.Contains("Articulated.First.Bend"));
        Assert.Equal("Articulated.First.Unit.Elbow", joint.Name);
        var pose = AssemblyMotion.Evaluate(compiled.Ir, "Cycle", 1.25);
        Assert.True(pose.IsSuccess, Evidence(pose.Diagnostics));
        Assert.Equal(225, pose.State[joint.Name], 9);
    }

    [Fact]
    public void InventoryImportsShareOneArticulatedDefinitionWithIndependentPublicChannels()
    {
        var compiled = new AssemblyM1Pipeline().CompileFile(Fixture("articulated-module-motion.firmament"));
        Assert.True(compiled.IsSuccess, Evidence(compiled.Diagnostics));
        var ir = compiled.Ir!;
        Assert.Single(ir.AssemblyDefinitions!);
        Assert.Equal(2, compiled.Geometry!.Artifact.Definitions.Count);
        var pose = AssemblyMotion.Evaluate(ir, "Cycle", .25);
        Assert.True(pose.IsSuccess, Evidence(pose.Diagnostics));
        Assert.Equal(90, pose.State["ModularMotion.First.Elbow"], 9);
        Assert.Equal(-180, pose.State["ModularMotion.Second.Elbow"], 9);
    }

    [Theory]
    [InlineData("from: Shaft", "from: Missing", "assembly-datum-source-unresolved")]
    [InlineData("from: Shaft", "from: Cam", "assembly-datum-dependency-cycle")]
    [InlineData("angle: -45deg", "angle: -45mm", "firmament-v2-field-value-invalid")]
    [InlineData("translateLocal:", "translateLocla:", "firmament-v2-canonical-field-unknown")]
    public void InvalidDerivedFramesAreRejected(string from, string to, string code)
    {
        var source = File.ReadAllText(Fixture("derived-datum-frames.firmament")).ReplaceRequired(from, to);
        var parsed = new AssemblyM0Parser().Parse(source, "derived-datum-frames.firmament");
        Assert.False(parsed.IsSuccess);
        Assert.Contains(parsed.Diagnostics, d => d.Code == code);
    }

    [Fact]
    public void UnusedDerivedDatumStillRequiresAResolvedDeclaredSource()
    {
        var source = File.ReadAllText(Fixture("derived-datum-frames.firmament"))
            .Replace("Concept Struct Layout {", "Concept Struct Layout { DatumFrame Unused { from: Layout.Missing }");
        var parsed = new AssemblyM0Parser().Parse(source);
        Assert.False(parsed.IsSuccess);
        Assert.Contains(parsed.Diagnostics, d => d.Code == "assembly-datum-source-unresolved");
    }

    private static string Fixture(string name) => FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/Canonical/AssemblyInterfaces/" + name);
    private static string Evidence(IReadOnlyList<AssemblyDiagnostic> diagnostics) => string.Join("\n", diagnostics.Select(d => d.Code + ": " + d.Message));
    private static void AssertMatrix(double[] expected, double[] actual)
    {
        for (var i = 0; i < 16; i++) Assert.Equal(expected[i], actual[i], 9);
    }
}