Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Extend FEA CLI with inline STEP support and diagnostics
Yuechen Li4e469a0440ee
diff --git a/Aetheris.CLI.Tests/Aetheris.CLI.Tests.csproj b/Aetheris.CLI.Tests/Aetheris.CLI.Tests.csprojindex 2fd99be1..751aa645 100644--- a/Aetheris.CLI.Tests/Aetheris.CLI.Tests.csproj+++ b/Aetheris.CLI.Tests/Aetheris.CLI.Tests.csproj@@ -19,6 +19,7 @@<ItemGroup><ProjectReference Include="..\Aetheris.CLI\Aetheris.CLI.csproj" />+ <ProjectReference Include="..\Aetheris.Kernel.StandardLibrary\Aetheris.Kernel.StandardLibrary.csproj" /><ProjectReference Include="..\tests\Aetheris.TestForgePack\Aetheris.TestForgePack.csproj" /><ProjectReference Include="..\tests\Aetheris.TestForgePack.Duplicate\Aetheris.TestForgePack.Duplicate.csproj" /></ItemGroup>diff --git a/Aetheris.CLI.Tests/FeaCliTests.cs b/Aetheris.CLI.Tests/FeaCliTests.csindex 236c6db1..93ef56d4 100644--- a/Aetheris.CLI.Tests/FeaCliTests.cs+++ b/Aetheris.CLI.Tests/FeaCliTests.cs@@ -1,5 +1,7 @@namespace Aetheris.CLI.Tests;+using System.Text.Json;+public sealed class FeaCliTests{[Fact]@@ -16,5 +18,24 @@ public sealed class FeaCliTestsfinally { if(Directory.Exists(output))Directory.Delete(output,true); }}+ [Fact]+ public void FeaCommand_InlineStepAndLatticeOverride_ReportProductionIdentity()+ {+ var root=FindRoot();var source=Path.Combine(root,"fixtures","FirmamentV2","FEA","inline-step-through-hole.firmament");var output=Path.Combine(Path.GetTempPath(),"aetheris-fea-x1-cli-"+Guid.NewGuid().ToString("N"));+ try+ {+ var stdout=new StringWriter();var stderr=new StringWriter();+ var exit=CliRunner.Run(["fea",source,"--lattice","4,4,3","--out-dir",output,"--json"],stdout,stderr);+ Assert.True(exit==0,$"exit={exit}; stderr={stderr}");Assert.Empty(stderr.ToString());+ using var json=JsonDocument.Parse(stdout.ToString());var rootElement=json.RootElement;+ Assert.Equal("InlineStep",rootElement.GetProperty("analysis").GetProperty("sourceKind").GetString());+ Assert.Equal(4,rootElement.GetProperty("analysis").GetProperty("lattice").GetProperty("countX").GetInt32());+ Assert.Equal("TotalResultantOverSelectedArea",rootElement.GetProperty("analysis").GetProperty("loads")[0].GetProperty("distribution").GetString());+ Assert.True(rootElement.GetProperty("solver").GetProperty("converged").GetBoolean());+ Assert.InRange(rootElement.GetProperty("equilibrium").GetProperty("residualNewton").GetProperty("length").GetDouble(),0,1e-3);+ }+ finally { if(Directory.Exists(output))Directory.Delete(output,true); }+ }+private static string FindRoot(){var directory=new DirectoryInfo(AppContext.BaseDirectory);while(directory is not null&&!File.Exists(Path.Combine(directory.FullName,"Aetheris.slnx")))directory=directory.Parent;return directory?.FullName??throw new DirectoryNotFoundException();}}diff --git a/Aetheris.CLI/CliRunner.cs b/Aetheris.CLI/CliRunner.csindex 42501019..4e520204 100644--- a/Aetheris.CLI/CliRunner.cs+++ b/Aetheris.CLI/CliRunner.cs@@ -156,7 +156,7 @@ public static class CliRunnerprivate const string ExperimentalAirChamferCorpusUsage = "Usage: aetheris experimental airchamfer-corpus --out-dir <dir> [--json]";private const string ExperimentalPrismaticCorpusUsage = "Usage: aetheris experimental prismatic-corpus --out-dir <dir> [--json]";private const string ExperimentalPrismaticMapUsage = "Usage: aetheris experimental prismatic-map --case <case> --rows <N> --cols <N> --json";- private const string FeaUsage = "Usage: aetheris fea <analysis.firmament> [--rotate <x,y,z-degrees>] [--out-dir <directory>] [--json]";+ private const string FeaUsage = "Usage: aetheris fea <analysis.firmament> [--lattice <nx,ny,nz>] [--rotate <x,y,z-degrees>] [--out-dir <directory>] [--json]";private const string DrawingUsage = "Usage: aetheris drawing compile <drawing.firmament> --out-dir <directory> [--json]";private const string SheetMetalUsage = "Usage: aetheris sheetmetal recognize <part.step> [--plan <recognition.json>] [--json] | aetheris sheetmetal recover-flat <part.step> --out-dir <directory> [--recognition-plan <recognition.json>] [--json] | aetheris sheetmetal compare-flat <recovered-flat.json> <native.firmament> [--semantic] [--json] | aetheris sheetmetal inspect <part.step|part.firmament> [--k-factor <0..1>] [--json] | aetheris sheetmetal paths <part.firmament> [--json] | aetheris sheetmetal recover <part.step> --out-dir <directory> [--json] | aetheris sheetmetal compare <part.step|part.firmament> <intent.firmament> [--semantic] [--json] | aetheris sheetmetal flatten <part.step|part.firmament> [--step <flat.step>] [--firmament <recovered.firmament>] [--svg <flat.svg>] [--k-factor <0..1>] [--json]";private const string ExperimentalLoopChamferCorpusUsage = "Usage: aetheris experimental loop-chamfer-corpus --out-dir <dir> [--json]";@@ -164,7 +164,9 @@ public static class CliRunnerinternal static readonly JsonSerializerOptions JsonOptions = new(){WriteIndented = true,- PropertyNamingPolicy = JsonNamingPolicy.CamelCase+ PropertyNamingPolicy = JsonNamingPolicy.CamelCase,+ // Numerical diagnostics may intentionally expose an unbounded conditioning proxy.+ NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals};static CliRunner()@@ -752,12 +754,13 @@ Model CanonicalPanel {private static int RunFea(string[] args, TextWriter stdout, TextWriter stderr){if (args.Length == 0 || IsHelpFlag(args[0])) { stdout.WriteLine(FeaUsage); return args.Length == 0 ? 1 : 0; }- var input = Path.GetFullPath(args[0]); string? outDir = null; var json = false;Vector3D? rotationDegrees=null;+ var input = Path.GetFullPath(args[0]); string? outDir = null; var json = false;Vector3D? rotationDegrees=null;(int X,int Y,int Z)? latticeOverride=null;for (var index = 1; index < args.Length; index++){if (args[index] == "--json") json = true;else if (args[index] == "--out-dir" && index + 1 < args.Length) outDir = Path.GetFullPath(args[++index]);else if(args[index]=="--rotate"&&index+1<args.Length){var values=args[++index].Split(',').Select(value=>double.Parse(value,System.Globalization.CultureInfo.InvariantCulture)).ToArray();if(values.Length!=3){stderr.WriteLine(FeaUsage);return 1;}rotationDegrees=new(values[0],values[1],values[2]);}+ else if(args[index]=="--lattice"&&index+1<args.Length){var values=args[++index].Split(',').Select(value=>int.TryParse(value,out var parsed)?parsed:0).ToArray();if(values.Length!=3||values.Any(value=>value<1)){stderr.WriteLine("Lattice override requires three positive integers.");return 1;}latticeOverride=(values[0],values[1],values[2]);}else { stderr.WriteLine(FeaUsage); return 1; }}if (!File.Exists(input)) { stderr.WriteLine($"Analysis source was not found: {input}"); return 1; }@@ -767,8 +770,13 @@ Model CanonicalPanel {foreach (var diagnostic in compiled.Diagnostics) stderr.WriteLine($"{diagnostic.Code}: {diagnostic.Message}");return 1;}+ if(latticeOverride is { } requestedLattice)compiled=compiled with{Analysis=compiled.Analysis with{Lattice=new Aetheris.Continuum.Lattice.LatticeSpec(compiled.Analysis.Body.ContinuumRegion.Bounds,requestedLattice.X,requestedLattice.Y,requestedLattice.Z)}};Transform3D? orientation=null;if(rotationDegrees is { } degrees){var b=compiled.Analysis.Body.ContinuumRegion.Bounds;var center=new Vector3D((b.Min.X+b.Max.X)/2,(b.Min.Y+b.Max.Y)/2,(b.Min.Z+b.Max.Z)/2);orientation=Transform3D.CreateTranslation(-center)*Transform3D.CreateRotationX(degrees.X*double.Pi/180)*Transform3D.CreateRotationY(degrees.Y*double.Pi/180)*Transform3D.CreateRotationZ(degrees.Z*double.Pi/180)*Transform3D.CreateTranslation(center);}- var solveOptions=new MechanicsSolveOptions(CutCellQuadraturePerAxis:6,DomainTransform:orientation,PreserveNominalCellVolumeUnderTransform:orientation is not null);var result = LinearElasticSolver.Solve(compiled.Analysis,solveOptions);+ // Generic imported BReps classify every intersecting site through exact kernel containment;+ // use the production default order while analytic domains retain the higher CLI verification order.+ var quadratureOrder=compiled.Analysis.Body.ContinuumRegion is Aetheris.FEA.Geometry.ImportedBrepAnalysisRegion?4:6;+ var solveOptions=new MechanicsSolveOptions(CutCellQuadraturePerAxis:quadratureOrder,DomainTransform:orientation,PreserveNominalCellVolumeUnderTransform:orientation is not null,+ RetryEmptyCutCells:compiled.Analysis.Body.ContinuumRegion is not Aetheris.FEA.Geometry.ImportedBrepAnalysisRegion);var result = LinearElasticSolver.Solve(compiled.Analysis,solveOptions);if (!result.IsSuccess){foreach (var diagnostic in result.Diagnostics.Where(item => item.Severity == Aetheris.FEA.Analysis.AnalysisDiagnosticSeverity.Error)) stderr.WriteLine($"{diagnostic.Code}: {diagnostic.Message}");@@ -778,10 +786,13 @@ Model CanonicalPanel {var report = new{analysis = new { compiled.Analysis.Id, kind = compiled.Analysis.Kind.ToString(), body = compiled.Analysis.Body.Id, compiled.Analysis.Body.SourceKind,+ geometryIdentity=compiled.Analysis.Body.ContinuumRegion.Id.Value,geometryHash=compiled.Analysis.Body.ResourceHash,brepBodyId=compiled.Analysis.Body.BrepBodyId,material = compiled.Analysis.Materials.Select(item => new { item.Id, item.StableMaterialId, item.ConstitutiveClass, item.YoungsModulusPascal, item.PoissonRatio, item.DensityKilogramsPerCubicMeter, item.YieldStrengthPascal }),constraints = compiled.Analysis.Constraints.Select(item => new { item.Id, region = item.Region.Path, components = item.Components }),- loads = compiled.Analysis.Loads.Select(item => new { item.Id, kind = item.Kind.ToString(), region = item.Region.Path, item.VectorSi, item.PressurePascal }),+ loads = compiled.Analysis.Loads.Select(item => new { item.Id, kind = item.Kind.ToString(), distribution=item.Distribution.ToString(), region = item.Region.Path, item.VectorSi, item.PressurePascal }),+ requestedResults=compiled.Analysis.RequestedFields.Order().Select(Aetheris.FEA.Analysis.AnalysisResultContracts.Describe),lattice = new { compiled.Analysis.Lattice.CountX, compiled.Analysis.Lattice.CountY, compiled.Analysis.Lattice.CountZ } },+ solverSettings=new{solveOptions.CutCellQuadraturePerAxis,solveOptions.RelativeResidualTolerance,solveOptions.MaximumIterations,solveOptions.RetryEmptyCutCells},orientationDegrees=rotationDegrees,result.System, result.Solver, result.Equilibrium, result.TinyCells, result.Performance,boundaryLoads=result.BoundaryLoads,numericalLowering=result.NumericalLowering,strainEnergy=result.StrainEnergy,stressProbes=result.StressProbes,maximumDisplacementMeters = result.MaximumDisplacementMeters, maximumVonMisesPascal = result.MaximumVonMisesPascal,abaqus = new { abaqus.Sha256, abaqus.NodeCount, abaqus.ElementCount, validation.IsValid, validation.Diagnostics }diff --git a/Aetheris.FEA.Tests/ProductionFeaX1Tests.cs b/Aetheris.FEA.Tests/ProductionFeaX1Tests.csnew file mode 100644index 00000000..75d0d5a2--- /dev/null+++ b/Aetheris.FEA.Tests/ProductionFeaX1Tests.cs@@ -0,0 +1,148 @@+using Aetheris.Continuum.Lattice;+using Aetheris.FEA.Analysis;+using Aetheris.FEA.Firmament;+using Aetheris.FEA.Geometry;+using Aetheris.FEA.Mechanics;+using Aetheris.Kernel.StandardLibrary.Materials;++namespace Aetheris.FEA.Tests;++public sealed class ProductionFeaX1Tests+{+ private const string CanonicalBeam = """+ Model CantileverWitness {+ Units: mm+ solid beam: Box { size: [120, 20, 20] }+ Analysis LinearElastic Cantilever {+ body: beam+ material: Standard.Materials.Aluminum.6061_T6+ Fixed Root {+ region: beam.face(-X)+ components: [X, Y, Z]+ }+ Force Tip {+ region: beam.face(+X)+ vector: [0N, -100N, 0N]+ }+ results: [Displacement, Strain, Stress, ReactionForce]+ lattice: [12, 2, 2]+ }+ }+ """;++ [Fact]+ public void CanonicalAndLegacySemanticConstructCasing_LowerIdentically()+ {+ var canonical = FirmamentAnalysisCompiler.Compile(CanonicalBeam);+ var legacy = FirmamentAnalysisCompiler.Compile(CanonicalBeam+ .Replace("Analysis LinearElastic", "analysis LinearElastic", StringComparison.Ordinal)+ .Replace("Fixed Root", "fixed Root", StringComparison.Ordinal)+ .Replace("Force Tip", "force Tip", StringComparison.Ordinal));+ Assert.True(canonical.IsSuccess, Describe(canonical));+ Assert.True(legacy.IsSuccess, Describe(legacy));+ Assert.Equal(canonical.Analysis!.Kind, legacy.Analysis!.Kind);+ Assert.Equal(canonical.Analysis.Constraints.Select(item=>(item.Id,item.Region.Path,string.Join(',',item.Components.Order()))),+ legacy.Analysis.Constraints.Select(item=>(item.Id,item.Region.Path,string.Join(',',item.Components.Order()))));+ Assert.Equal(canonical.Analysis.Loads.Select(item=>(item.Id,item.Kind,item.Region.Path,item.VectorSi,item.Distribution)),+ legacy.Analysis.Loads.Select(item=>(item.Id,item.Kind,item.Region.Path,item.VectorSi,item.Distribution)));+ Assert.Equal(LoadDistributionPolicy.TotalResultantOverSelectedArea, canonical.Analysis.Loads.Single().Distribution);+ }++ [Fact]+ public void CantileverScalingAndRefinement_ArePhysicallySensibleAndBalanced()+ {+ var source = FirmamentAnalysisCompiler.Compile(CanonicalBeam).Analysis!;+ var baseline = Solve(source);+ var twiceLoad = Solve(source with { Loads = source.Loads.Select(load => load with { VectorSi = load.VectorSi * 2 }).ToArray() });+ var twiceE = Solve(source with { Materials = source.Materials.Select(material => material with { YoungsModulusPascal = material.YoungsModulusPascal * 2 }).ToArray() });+ Assert.InRange(twiceLoad.MaximumDisplacementMeters / baseline.MaximumDisplacementMeters, 1.999, 2.001);+ Assert.InRange(twiceE.MaximumDisplacementMeters / baseline.MaximumDisplacementMeters, .499, .501);+ Assert.InRange(baseline.Equilibrium.ResidualNewton.Length, 0, 1e-5);++ var studies = new[] { (6, 2, 2), (12, 2, 2), (18, 3, 3) }.Select(counts =>+ Solve(source with { Lattice = new(source.Body.ContinuumRegion.Bounds, counts.Item1, counts.Item2, counts.Item3) })).ToArray();+ Assert.All(studies, result => Assert.True(result.IsSuccess, Describe(result)));+ Assert.All(studies, result => Assert.True(result.MaximumDisplacementMeters > 0 && double.IsFinite(result.MaximumDisplacementMeters)));+ Assert.All(studies, result => Assert.InRange(result.Equilibrium.ResidualNewton.Length, 0, 1e-4));+ Assert.True(studies[^1].System.DegreesOfFreedom > studies[0].System.DegreesOfFreedom);+ }++ [Fact]+ public void InlineStepThroughHole_UsesStableFaceIdentityAndSolvesSharedCutCellPath()+ {+ var root = FindRoot();+ var path = Path.Combine(root, "fixtures", "FirmamentV2", "FEA", "inline-step-through-hole.firmament");+ var compilation = FirmamentAnalysisCompiler.Compile(File.ReadAllText(path), path, Path.GetDirectoryName(path));+ Assert.True(compilation.IsSuccess, Describe(compilation));+ Assert.IsType<ImportedBrepAnalysisRegion>(compilation.Analysis!.Body.ContinuumRegion);+ Assert.NotNull(compilation.Analysis.Body.ResourceHash);+ Assert.Equal("6", compilation.Analysis.Constraints.Single().Region.ExactBrepFaceId);+ Assert.Equal("4", compilation.Analysis.Loads.Single().Region.ExactBrepFaceId);+ var result = LinearElasticSolver.Solve(compilation.Analysis, new(CutCellQuadraturePerAxis: 4, RelativeResidualTolerance: 1e-8, RetryEmptyCutCells: false));+ Assert.True(result.IsSuccess, Describe(result));+ Assert.True(result.System.CutCells > 0);+ Assert.True(result.MaximumDisplacementMeters > 0);+ Assert.InRange(result.Equilibrium.ResidualNewton.Length, 0, 1e-3);+ Assert.Equal(500, result.BoundaryLoads!.Single().IntegratedResultant.Length, 6);+ }++ [Fact]+ public void InvalidLatticeAndResultRequest_AreStableDiagnostics()+ {+ var lattice = FirmamentAnalysisCompiler.Compile(CanonicalBeam.Replace("[12, 2, 2]", "[12, 0, 2]", StringComparison.Ordinal));+ Assert.Contains(lattice.Diagnostics, item => item.Code == "fea-invalid-lattice-dimensions");+ var result = FirmamentAnalysisCompiler.Compile(CanonicalBeam.Replace("Stress,", "MysteryField,", StringComparison.Ordinal));+ Assert.Contains(result.Diagnostics, item => item.Code == "fea-invalid-result-request");+ }++ [Fact]+ public void RequestedResults_ControlPublishedTypedFields()+ {+ var analysis=FirmamentAnalysisCompiler.Compile(CanonicalBeam).Analysis!;+ var result=Solve(analysis with{RequestedFields=new HashSet<AnalysisResultField>{AnalysisResultField.Displacement}});+ Assert.NotEmpty(result.Displacements);+ Assert.Empty(result.CellFields);+ Assert.Empty(result.StrainFields!);+ Assert.Empty(result.StressFields!);+ Assert.Empty(result.Reactions);+ Assert.True(result.Equilibrium.ReactionForceNewton.Length>0);+ }++ [Fact]+ public void UnsupportedConstitutiveClass_IsRejectedBeforeAssembly()+ {+ var analysis=FirmamentAnalysisCompiler.Compile(CanonicalBeam).Analysis!;+ analysis=analysis with{Materials=analysis.Materials.Select(material=>material with{ConstitutiveClass=MaterialConstitutiveClass.Orthotropic}).ToArray()};+ var result=LinearElasticSolver.Solve(analysis);+ Assert.False(result.IsSuccess);+ Assert.Contains(result.Diagnostics,item=>item.Code=="fea-unsupported-constitutive-class");+ }++ [Fact]+ public void ImportedBodyWithAmbiguousKernelContainment_FailsBeforeSolver()+ {+ var root=FindRoot();var directory=Path.Combine(root,"testdata","firmasm","examples","occt-l-bracket");+ const string source="""+ Analysis LinearElastic UnsupportedImportedBracket {+ body: inlineSTEP("_part_003_l_bracket.step")+ material: Standard.Materials.Aluminum.6061_T6+ Fixed Mount { region: body.face(#100) }+ Force Load { region: body.face(#473) vector: [0N, -500N, 0N] }+ lattice: [2, 2, 3]+ }+ """;+ var compilation=FirmamentAnalysisCompiler.Compile(source,"ambiguous-import.firmament",directory);+ Assert.Contains(compilation.Diagnostics,item=>item.Code=="firmament-analysis-inline-step-containment-unsupported");+ }++ private static LinearElasticAnalysisResult Solve(LinearElasticAnalysisIr analysis)+ {+ var result = LinearElasticSolver.Solve(analysis, new(CutCellQuadraturePerAxis: 4, RelativeResidualTolerance: 1e-8));+ Assert.True(result.IsSuccess, Describe(result));+ return result;+ }++ private static string Describe(FirmamentAnalysisCompilation value) => string.Join("; ", value.Diagnostics.Select(item => item.Code + ":" + item.Message));+ private static string Describe(LinearElasticAnalysisResult value) => string.Join("; ", value.Diagnostics.Select(item => item.Code + ":" + item.Message));+ private static string FindRoot(){var directory=new DirectoryInfo(AppContext.BaseDirectory);while(directory is not null&&!File.Exists(Path.Combine(directory.FullName,"Aetheris.slnx")))directory=directory.Parent;return directory?.FullName??throw new DirectoryNotFoundException();}+}diff --git a/Aetheris.FEA/Analysis/AnalysisIr.cs b/Aetheris.FEA/Analysis/AnalysisIr.csindex 4dca15bb..e0d832af 100644--- a/Aetheris.FEA/Analysis/AnalysisIr.cs+++ b/Aetheris.FEA/Analysis/AnalysisIr.cs@@ -8,6 +8,8 @@ namespace Aetheris.FEA.Analysis;public enum AnalysisKind { LinearStaticElasticity }public enum AnalysisResultField { Displacement, Strain, Stress, ReactionForce }public enum BoundaryLoadKind { Traction, ResultantForce, Pressure }+public enum LoadDistributionPolicy { TotalResultantOverSelectedArea, TractionPerUnitArea, PressureNormalToSurface }+public enum AnalysisGeometrySourceKind { FirmamentNative, InlineStep }public enum DisplacementComponent { X, Y, Z }public sealed record AnalysisProvenance(@@ -55,7 +57,8 @@ public sealed record BoundaryLoadIr(SemanticRegionBinding Region,Vector3D VectorSi,double PressurePascal,- AnalysisProvenance Provenance);+ AnalysisProvenance Provenance,+ LoadDistributionPolicy Distribution = LoadDistributionPolicy.TotalResultantOverSelectedArea);public sealed record AnalysisBodyIr(string Id,@@ -63,7 +66,23 @@ public sealed record AnalysisBodyIr(IContinuumRegion ContinuumRegion,string? BrepBodyId,string? ResourceHash,- AnalysisProvenance Provenance);+ AnalysisProvenance Provenance)+{+ public AnalysisGeometrySourceKind GeometrySource => Enum.Parse<AnalysisGeometrySourceKind>(SourceKind);+}++public sealed record AnalysisResultSemantics(AnalysisResultField Field,string Representation,string Unit,string Location,string Recovery);+public static class AnalysisResultContracts+{+ public static AnalysisResultSemantics Describe(AnalysisResultField field)=>field switch+ {+ AnalysisResultField.Displacement=>new(field,"Vector3","m","admitted lattice node","primary solved degrees of freedom; aggregated nodes are affine extensions"),+ AnalysisResultField.Strain=>new(field,"symmetric tensor","1","occupied cell center","small-strain tensor recovered from the Q1 displacement gradient"),+ AnalysisResultField.Stress=>new(field,"Cauchy symmetric tensor plus von Mises scalar","Pa","occupied cell center","linear isotropic constitutive recovery; no nodal interpolation"),+ AnalysisResultField.ReactionForce=>new(field,"Vector3 per constraint","N","selected boundary condition","assembled constrained residual or consistent Nitsche boundary reaction"),+ _=>throw new ArgumentOutOfRangeException(nameof(field)),+ };+}public sealed record LinearElasticAnalysisIr(string Id,@@ -90,6 +109,8 @@ public static class AnalysisIrValidatordiagnostics.Add(Error("fea-m5-multiple-material-regions-unsupported", "M5 supports one homogeneous material while retaining region-shaped assignments.", analysis.Provenance));foreach (var material in analysis.Materials){+ if (material.ConstitutiveClass is not null and not MaterialConstitutiveClass.LinearElasticIsotropic)+ diagnostics.Add(Error("fea-unsupported-constitutive-class", $"Material '{material.Id}' uses unsupported constitutive class '{material.ConstitutiveClass}'. X1 supports LinearElasticIsotropic.", material.Provenance));if (!double.IsFinite(material.YoungsModulusPascal) || material.YoungsModulusPascal <= 0)diagnostics.Add(Error("fea-invalid-youngs-modulus", "Young's modulus must be finite and positive.", material.Provenance));if (!double.IsFinite(material.PoissonRatio) || material.PoissonRatio <= -1 || material.PoissonRatio >= 0.5)@@ -101,6 +122,8 @@ public static class AnalysisIrValidatordiagnostics.Add(Error("fea-empty-constraint", $"Constraint '{constraint.Id}' constrains no displacement components.", constraint.Provenance));foreach (var load in analysis.Loads.Where(l => string.IsNullOrWhiteSpace(l.Region.Path)))diagnostics.Add(Error("fea-empty-region-selection", $"Load '{load.Id}' has no semantic region.", load.Provenance));+ foreach(var load in analysis.Loads.Where(load=>!double.IsFinite(load.VectorSi.X)||!double.IsFinite(load.VectorSi.Y)||!double.IsFinite(load.VectorSi.Z)||!double.IsFinite(load.PressurePascal)))+ diagnostics.Add(Error("fea-invalid-load",$"Load '{load.Id}' contains a non-finite or unit-incompatible value.",load.Provenance));return diagnostics;}diff --git a/Aetheris.FEA/Firmament/FirmamentAnalysisCompiler.cs b/Aetheris.FEA/Firmament/FirmamentAnalysisCompiler.csindex 413c3edf..f6800e2d 100644--- a/Aetheris.FEA/Firmament/FirmamentAnalysisCompiler.cs+++ b/Aetheris.FEA/Firmament/FirmamentAnalysisCompiler.cs@@ -12,6 +12,9 @@ using Aetheris.Kernel.Core.Step242;using Aetheris.Kernel.Core.Topology;using Aetheris.Semantics;using Aetheris.Kernel.StandardLibrary.Materials;+using Aetheris.FEA.Geometry;+using System.Security.Cryptography;+using System.Text;namespace Aetheris.FEA.Firmament;@@ -21,21 +24,23 @@ public sealed record FirmamentAnalysisCompilation(LinearElasticAnalysisIr? Analypublic bool IsSuccess=>Analysis is not null&&!Diagnostics.Any(item=>item.Severity==AnalysisDiagnosticSeverity.Error);}-/// <summary>Bounded M5 parser/lowerer for declarative analysis blocks embedded in Firmament source.</summary>+/// <summary>Firmament analysis-intent compiler. Geometry, materials and selections are fully resolved before solver execution.</summary>public static class FirmamentAnalysisCompiler{- private static readonly Regex Header=new(@"\banalysis\s+LinearElastic\s+(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*\{",RegexOptions.CultureInvariant);+ private static readonly Regex Header=new(@"\banalysis\s+LinearElastic\s+(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*\{",RegexOptions.CultureInvariant|RegexOptions.IgnoreCase);public static FirmamentAnalysisCompilation Compile(string source,string? sourcePath=null,string? sourceDirectory=null,IReadOnlyDictionary<string,FirmamentAnalysisResource>? resources=null,IMaterialResolver? materialResolver=null){var started=System.Diagnostics.Stopwatch.GetTimestamp();var diagnostics=new List<AnalysisDiagnostic>();var match=Header.Match(source);- if(!match.Success)return Done(null,[Error("firmament-analysis-missing","No 'analysis LinearElastic' declaration was found.",sourcePath)],started);+ if(!match.Success)return Done(null,[Error("firmament-analysis-missing","No 'Analysis LinearElastic' declaration was found.",sourcePath)],started);var open=source.IndexOf('{',match.Index);var close=MatchingBrace(source,open);if(close<0)return Done(null,[Error("firmament-analysis-malformed","Analysis block has no closing brace.",sourcePath)],started);var block=source[(open+1)..close];var analysisSpan=new AnalysisProvenance(sourcePath??"<memory>",match.Index,close-match.Index+1,match.Value);var stripped=source.Remove(match.Index,close-match.Index+1);- var bodyName=Scalar(block,"body")??string.Empty;var resourceName=(Scalar(block,"bodyResource")??string.Empty).TrimStart('$');+ var bodyExpression=Scalar(block,"body")??string.Empty;+ var inlineCall=Regex.Match(bodyExpression,@"^(?:inlineSTEP|InlineStep)\s*\(\s*""(?<path>[^""]+)""\s*\)$",RegexOptions.CultureInvariant);+ var bodyName=inlineCall.Success?"body":bodyExpression;var resourceName=(Scalar(block,"bodyResource")??string.Empty).TrimStart('$');IContinuumRegion? region=null;string sourceKind;string? resourceHash=null;string? brepBodyId=null;string bodyId;IReadOnlyDictionary<string,string> semanticFaceIds=new Dictionary<string,string>();var namedRegions=new Dictionary<string,SemanticValue>(StringComparer.Ordinal);var sourceParse=FirmamentV2Parser.Parse(stripped,sourceDirectory);var directInline=sourceParse.Document?.Solids.SingleOrDefault(item=>item.Name==bodyName)?.InlineStep;- if(resourceName.Length>0||directInline is not null)+ if(resourceName.Length>0||directInline is not null||inlineCall.Success){bodyId=bodyName.Length>0?bodyName:resourceName;sourceKind="InlineStep";FirmamentAnalysisResource resource;@@ -43,7 +48,7 @@ public static class FirmamentAnalysisCompiler{if(resources is null||!resources.TryGetValue(resourceName,out resource!)){diagnostics.Add(Error("firmament-analysis-resource-missing",$"InlineStep analysis resource '${resourceName}' is not bound.",sourcePath));return Done(null,diagnostics,started);}}- else+ else if(directInline is not null){var imported=Step242Importer.ImportBody(File.ReadAllText(directInline!.NormalizedPath));if(!imported.IsSuccess||imported.Value is null){diagnostics.Add(Error("firmament-analysis-inline-step-import-failed",string.Join("; ",imported.Diagnostics.Select(item=>item.Message)),sourcePath));return Done(null,diagnostics,started);}@@ -56,30 +61,58 @@ public static class FirmamentAnalysisCompilerforeach(var member in semanticRoot.ExposedMembers)namedRegions[bodyId+"."+member.Key]=member.Value;}}+ else+ {+ var relativePath=inlineCall.Groups["path"].Value;+ var normalizedPath=Path.GetFullPath(relativePath,sourceDirectory??Directory.GetCurrentDirectory());+ if(!File.Exists(normalizedPath)){diagnostics.Add(Error("firmament-analysis-inline-step-file-missing",$"InlineStep analysis file was not found: {normalizedPath}",sourcePath));return Done(null,diagnostics,started);}+ var stepText=File.ReadAllText(normalizedPath);var imported=Step242Importer.ImportBody(stepText);+ if(!imported.IsSuccess||imported.Value is null){diagnostics.Add(Error("firmament-analysis-inline-step-import-failed",string.Join("; ",imported.Diagnostics.Select(item=>item.Message)),sourcePath));return Done(null,diagnostics,started);}+ resource=new(bodyId,Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(stepText))).ToLowerInvariant(),imported.Value);+ var entityFaceIds=new Dictionary<string,string>(StringComparer.Ordinal);var ordinal=0;+ foreach(Match entity in Regex.Matches(stepText,@"(?m)^\s*(#[0-9]+)\s*=\s*ADVANCED_FACE\s*\(",RegexOptions.CultureInvariant))entityFaceIds[entity.Groups[1].Value]=(++ordinal).ToString(CultureInfo.InvariantCulture);+ semanticFaceIds=entityFaceIds;+ }var points=resource.Body.Topology.Vertices.Select(v=>resource.Body.TryGetVertexPoint(v.Id,out var point)?point:(Point3D?)null).Where(p=>p.HasValue).Select(p=>p!.Value).ToArray();if(points.Length==0){diagnostics.Add(Error("firmament-analysis-inline-step-bounds-unavailable","Imported STEP has no exact vertex positions for bounded M5 CIR recognition.",sourcePath));return Done(null,diagnostics,started);}var rawMin=new Point3D(points.Min(p=>p.X),points.Min(p=>p.Y),points.Min(p=>p.Z));var rawMax=new Point3D(points.Max(p=>p.X),points.Max(p=>p.Y),points.Max(p=>p.Z));const double stepMeters=0.001;var size=(rawMax-rawMin)*stepMeters;var center=new Vector3D((rawMin.X+rawMax.X)*stepMeters/2,(rawMin.Y+rawMax.Y)*stepMeters/2,(rawMin.Z+rawMax.Z)*stepMeters/2);- // M5's InlineStep seam admits an exact six-planar-face box; other imported topology fails explicitly.- if(resource.Body.Topology.Faces.Count()!=6){diagnostics.Add(Error("firmament-analysis-inline-step-cir-unsupported","M5 InlineStep mechanics admits exact planar boxes; this imported body needs a broader BRep-to-CIR recognizer.",sourcePath));return Done(null,diagnostics,started);}- var faceIds=new Dictionary<string,string>(StringComparer.Ordinal);- foreach(var binding in resource.Body.Bindings.FaceBindings)+ if(resource.Body.Topology.Faces.Count()==6&&resource.Body.Bindings.FaceBindings.All(binding=>resource.Body.Geometry.GetSurface(binding.SurfaceGeometryId).Kind==SurfaceGeometryKind.Plane))+ {+ var faceIds=new Dictionary<string,string>(StringComparer.Ordinal);+ foreach(var binding in resource.Body.Bindings.FaceBindings)+ {+ var plane=resource.Body.Geometry.GetSurface(binding.SurfaceGeometryId).Plane!.Value;var n=plane.Normal.ToVector();+ var token=double.Abs(n.X)>0.9?(double.Abs(plane.Origin.X-rawMin.X)<double.Abs(plane.Origin.X-rawMax.X)?"x-min":"x-max")+ :double.Abs(n.Y)>0.9?(double.Abs(plane.Origin.Y-rawMin.Y)<double.Abs(plane.Origin.Y-rawMax.Y)?"y-min":"y-max")+ :(double.Abs(plane.Origin.Z-rawMin.Z)<double.Abs(plane.Origin.Z-rawMax.Z)?"z-min":"z-max");+ faceIds[token]=binding.FaceId.Value.ToString(CultureInfo.InvariantCulture);+ }+ region=new ExactBrepBoxContinuumRegion(new RegionId(bodyId+":imported-box-cir"),size.X,size.Y,size.Z,Transform3D.CreateTranslation(center),faceIds);+ semanticFaceIds=faceIds;+ }+ else{- var surface=resource.Body.Geometry.GetSurface(binding.SurfaceGeometryId);if(surface.Kind!=SurfaceGeometryKind.Plane||surface.Plane is not { } plane)continue;- var n=plane.Normal.ToVector();string token=double.Abs(n.X)>0.9?(double.Abs(plane.Origin.X-rawMin.X)<double.Abs(plane.Origin.X-rawMax.X)?"x-min":"x-max"):double.Abs(n.Y)>0.9?(double.Abs(plane.Origin.Y-rawMin.Y)<double.Abs(plane.Origin.Y-rawMax.Y)?"y-min":"y-max"):(double.Abs(plane.Origin.Z-rawMin.Z)<double.Abs(plane.Origin.Z-rawMax.Z)?"z-min":"z-max");faceIds[token]=binding.FaceId.Value.ToString(CultureInfo.InvariantCulture);+ ImportedBrepAnalysisRegion importedRegion;+ try{importedRegion=new ImportedBrepAnalysisRegion(new RegionId(bodyId+":imported-brep-cir"),resource.Body,stepMeters);}+ catch(Exception exception) when(exception is NotSupportedException or InvalidOperationException or ArgumentException)+ {diagnostics.Add(Error("firmament-analysis-inline-step-cir-unsupported",$"Imported STEP cannot be lowered to the bounded analysis domain: {exception.Message}",sourcePath));return Done(null,diagnostics,started);}+ if(!importedRegion.TryValidateOccupancySupport(out var evidence)){diagnostics.Add(Error("firmament-analysis-inline-step-containment-unsupported",$"Imported STEP cannot provide deterministic occupied-material classification. {evidence}",sourcePath));return Done(null,diagnostics,started);}+ region=importedRegion;}- region=new ExactBrepBoxContinuumRegion(new RegionId(bodyId+":inline-cir"),size.X,size.Y,size.Z,Transform3D.CreateTranslation(center),faceIds);semanticFaceIds=faceIds;resourceHash=resource.ContentHash;brepBodyId=resource.Body.Topology.Bodies.Single().Id.Value.ToString(CultureInfo.InvariantCulture);+ resourceHash=resource.ContentHash;brepBodyId=resource.Body.Topology.Bodies.Single().Id.Value.ToString(CultureInfo.InvariantCulture);}else{var parse=FirmamentV2Parser.Parse(stripped,sourceDirectory);- var units=Regex.Match(stripped,@"\bunits\s+(?<u>[A-Za-z]+)",RegexOptions.CultureInvariant).Groups["u"].Value;- var boxHeader=Regex.Match(stripped,$@"\bsolid\s+{Regex.Escape(bodyName)}\s*:\s*Box\s*\{{",RegexOptions.CultureInvariant);+ var units=Regex.Match(stripped,@"\bunits\s*:?\s*(?<u>[A-Za-z]+)",RegexOptions.CultureInvariant|RegexOptions.IgnoreCase).Groups["u"].Value;+ var boxHeader=Regex.Match(stripped,$@"\bsolid\s+{Regex.Escape(bodyName)}\s*:\s*Box\s*\{{",RegexOptions.CultureInvariant|RegexOptions.IgnoreCase);if(!boxHeader.Success){diagnostics.Add(Error("firmament-analysis-body-unsupported",$"Body '{bodyName}' is not a Firmament Box/box-with-hole solid.",sourcePath));return Done(null,diagnostics,started);}var boxOpen=stripped.IndexOf('{',boxHeader.Index);var boxClose=MatchingBrace(stripped,boxOpen);var sizeRaw=Numbers(Scalar(stripped[(boxOpen+1)..boxClose],"size"));if(sizeRaw.Length!=3){diagnostics.Add(Error("firmament-analysis-body-size-invalid",$"Body '{bodyName}' requires three Box dimensions.",sourcePath));return Done(null,diagnostics,started);}- var scale=UnitScale(units);var size=sizeRaw.Select(value=>value*scale).ToArray();var bounds=new BoundingBox3D(new(0,0,0),new(size[0],size[1],size[2]));- var modify=Regex.Match(stripped,$@"\bmodify\s+{Regex.Escape(bodyName)}\s*\{{",RegexOptions.CultureInvariant);double? holeRadius=null;- if(modify.Success){var modifyOpen=stripped.IndexOf('{',modify.Index);var modifyClose=MatchingBrace(stripped,modifyOpen);var radiusMatch=Regex.Match(stripped[(modifyOpen+1)..modifyClose],@"\bradius\s*:\s*(?<v>[-+0-9.eE]+)",RegexOptions.CultureInvariant);if(radiusMatch.Success)holeRadius=Number(radiusMatch.Groups["v"].Value)*scale;}+ var scale=UnitScale(units);if(scale is null){diagnostics.Add(Error("firmament-analysis-length-unit-unsupported",$"Analysis body length unit '{units}' is unsupported; use mm, cm, or m.",sourcePath));return Done(null,diagnostics,started);}+ var size=sizeRaw.Select(value=>value*scale.Value).ToArray();var bounds=new BoundingBox3D(new(0,0,0),new(size[0],size[1],size[2]));+ var modify=Regex.Match(stripped,$@"\bmodify\s+{Regex.Escape(bodyName)}\s*\{{",RegexOptions.CultureInvariant|RegexOptions.IgnoreCase);double? holeRadius=null;+ if(modify.Success){var modifyOpen=stripped.IndexOf('{',modify.Index);var modifyClose=MatchingBrace(stripped,modifyOpen);var radiusMatch=Regex.Match(stripped[(modifyOpen+1)..modifyClose],@"\bradius\s*:\s*(?<v>[-+0-9.eE]+)",RegexOptions.CultureInvariant);if(radiusMatch.Success)holeRadius=Number(radiusMatch.Groups["v"].Value)*scale.Value;}region=holeRadius is null?new AxisAlignedBoxRegion(new RegionId(bodyName+":cir"),bounds):new BlockWithCylindricalHoleRegion(new RegionId(bodyName+":cir"),bounds,holeRadius.Value);if(!parse.IsSuccess) diagnostics.Add(new("firmament-analysis-geometry-parser-fallback",AnalysisDiagnosticSeverity.Warning,"The bounded analysis body recognizer admitted Box/through-cylinder syntax while the general geometry parser reported: "+string.Join(",",parse.Diagnostics),analysisSpan));bodyId=bodyName;sourceKind="FirmamentNative";@@ -118,31 +151,35 @@ public static class FirmamentAnalysisCompilerreturn FirmamentAnalysisSemanticProducer.Normalize(path,bodyId,semanticFaceIds,provenance,sourceKind);}var constraints=new List<DisplacementConstraintIr>();- foreach(var nested in NestedAll(block,"fixed"))+ foreach(var nested in NestedAll(block,"Fixed")){var path=Scalar(nested.Body,"region")??"";var components=Components(Scalar(nested.Body,"components"));if(components.Count==0)components=[DisplacementComponent.X,DisplacementComponent.Y,DisplacementComponent.Z];var prov=new AnalysisProvenance(sourcePath??"<memory>",open+nested.Start,nested.Length,"fixed "+nested.Name);var normalized=NormalizeRegion(path,prov);if(normalized.Diagnostic is not null){diagnostics.Add(normalized.Diagnostic);continue;}constraints.Add(new(nested.Name,normalized.Region!,components,new(0,0,0),prov));}var loads=new List<BoundaryLoadIr>();- foreach(var keyword in new[]{("traction",BoundaryLoadKind.Traction),("force",BoundaryLoadKind.ResultantForce),("pressure",BoundaryLoadKind.Pressure)})foreach(var nested in NestedAll(block,keyword.Item1))+ foreach(var keyword in new[]{("Traction",BoundaryLoadKind.Traction),("Force",BoundaryLoadKind.ResultantForce),("Pressure",BoundaryLoadKind.Pressure)})foreach(var nested in NestedAll(block,keyword.Item1)){var path=Scalar(nested.Body,"region")??"";var prov=new AnalysisProvenance(sourcePath??"<memory>",open+nested.Start,nested.Length,keyword.Item1+" "+nested.Name);var vector=Vector(Scalar(nested.Body,"vector"),keyword.Item2==BoundaryLoadKind.ResultantForce);var pressure=keyword.Item2==BoundaryLoadKind.Pressure?Stress(Scalar(nested.Body,"value")):0;var normalized=NormalizeRegion(path,prov);if(normalized.Diagnostic is not null){diagnostics.Add(normalized.Diagnostic);continue;}- loads.Add(new(nested.Name,keyword.Item2,normalized.Region!,vector,pressure,prov));+ var distribution=keyword.Item2 switch{BoundaryLoadKind.ResultantForce=>LoadDistributionPolicy.TotalResultantOverSelectedArea,BoundaryLoadKind.Traction=>LoadDistributionPolicy.TractionPerUnitArea,_=>LoadDistributionPolicy.PressureNormalToSurface};+ loads.Add(new(nested.Name,keyword.Item2,normalized.Region!,vector,pressure,prov,distribution));}- var latticeValues=Numbers(Scalar(block,"lattice"));var lattice=latticeValues.Length==3?new LatticeSpec(region.Bounds,(int)latticeValues[0],(int)latticeValues[1],(int)latticeValues[2]):new LatticeSpec(region.Bounds,12,6,2);- var requested=(Scalar(block,"results")??"Displacement,Strain,Stress,ReactionForce").Trim('[',']').Split(',',StringSplitOptions.RemoveEmptyEntries|StringSplitOptions.TrimEntries).Select(Enum.Parse<AnalysisResultField>).ToHashSet();+ var latticeValues=Numbers(Scalar(block,"lattice"));+ if(latticeValues.Length is not (0 or 3)||latticeValues.Any(value=>!double.IsInteger(value)||value<1)){diagnostics.Add(Error("fea-invalid-lattice-dimensions","Lattice must contain exactly three positive integer dimensions.",sourcePath));return Done(null,diagnostics,started);}+ var lattice=latticeValues.Length==3?new LatticeSpec(region.Bounds,(int)latticeValues[0],(int)latticeValues[1],(int)latticeValues[2]):new LatticeSpec(region.Bounds,12,6,2);+ var requested=new HashSet<AnalysisResultField>();foreach(var item in (Scalar(block,"results")??"Displacement,Strain,Stress,ReactionForce").Trim('[',']').Split(',',StringSplitOptions.RemoveEmptyEntries|StringSplitOptions.TrimEntries)){if(Enum.TryParse<AnalysisResultField>(item,true,out var field))requested.Add(field);else diagnostics.Add(Error("fea-invalid-result-request",$"Analysis result '{item}' is unsupported.",sourcePath));}+ if(requested.Count==0){diagnostics.Add(Error("fea-invalid-result-request","Analysis must request at least one supported result field.",sourcePath));return Done(null,diagnostics,started);}var bodyProv=new AnalysisProvenance(sourcePath??"<memory>",match.Index,match.Length,"body "+bodyId,ExactBrepFaceId:brepBodyId);var ir=new LinearElasticAnalysisIr(match.Groups["name"].Value,AnalysisKind.LinearStaticElasticity,new(bodyId,sourceKind,region,brepBodyId,resourceHash,bodyProv),[material],constraints,loads,requested,lattice,analysisSpan);diagnostics.AddRange(AnalysisIrValidator.Validate(ir));return Done(ir,diagnostics,started);}private sealed record NestedBlock(string Name,string Body,int Start,int Length);- private static IEnumerable<NestedBlock> NestedAll(string source,string keyword){var regex=new Regex($@"\b{Regex.Escape(keyword)}\s+(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*\{{",RegexOptions.CultureInvariant);foreach(Match m in regex.Matches(source)){var open=source.IndexOf('{',m.Index);var close=MatchingBrace(source,open);if(close>open)yield return new(m.Groups["name"].Value,source[(open+1)..close],m.Index,close-m.Index+1);}}+ private static IEnumerable<NestedBlock> NestedAll(string source,string keyword){var regex=new Regex($@"\b{Regex.Escape(keyword)}\s+(?<name>[A-Za-z_][A-Za-z0-9_]*)\s*\{{",RegexOptions.CultureInvariant|RegexOptions.IgnoreCase);foreach(Match m in regex.Matches(source)){var open=source.IndexOf('{',m.Index);var close=MatchingBrace(source,open);if(close>open)yield return new(m.Groups["name"].Value,source[(open+1)..close],m.Index,close-m.Index+1);}}private static string? Nested(string source,string keyword,out string name,out int start){var item=NestedAll(source,keyword).FirstOrDefault();name=item?.Name??"";start=item?.Start??0;return item?.Body;}- private static string? Scalar(string source,string name){var m=Regex.Match(source,$@"(?m)^\s*{Regex.Escape(name)}\s*:\s*(?<value>[^\r\n}}]+)",RegexOptions.CultureInvariant);return m.Success?m.Groups["value"].Value.Trim():null;}+ private static string? Scalar(string source,string name){var m=Regex.Match(source,$@"(?m)^\s*{Regex.Escape(name)}\s*:\s*(?<value>[^\r\n}}]+)",RegexOptions.CultureInvariant|RegexOptions.IgnoreCase);return m.Success?m.Groups["value"].Value.Trim():null;}private static int MatchingBrace(string source,int open){var depth=0;for(var i=open;i<source.Length;i++){if(source[i]=='{')depth++;else if(source[i]=='}'&&--depth==0)return i;}return-1;}- private static double UnitScale(string unit)=>unit.ToLowerInvariant() switch{"m"=>1,"cm"=>.01,"mm"=>.001,_=>throw new FormatException($"Unsupported length unit '{unit}'.")};+ private static double? UnitScale(string unit)=>unit.ToLowerInvariant() switch{"m"=>1,"cm"=>.01,"mm"=>.001,_=>null};private static double Number(string? text)=>double.Parse(text??"NaN",NumberStyles.Float,CultureInfo.InvariantCulture);private static double Stress(string? text){if(text is null)return double.NaN;var m=Regex.Match(text,@"^(?<v>[-+0-9.eE]+)\s*(?<u>GPa|MPa|kPa|Pa)$",RegexOptions.IgnoreCase);if(!m.Success)return double.NaN;var v=Number(m.Groups["v"].Value);return v*(m.Groups["u"].Value.ToLowerInvariant() switch{"gpa"=>1e9,"mpa"=>1e6,"kpa"=>1e3,_=>1});}private static double? Density(string? text){if(string.IsNullOrWhiteSpace(text))return null;var m=Regex.Match(text,@"^(?<v>[-+0-9.eE]+)\s*kg/m3$",RegexOptions.IgnoreCase);return m.Success?Number(m.Groups["v"].Value):double.NaN;}diff --git a/Aetheris.FEA/Firmament/FirmamentAnalysisSemanticProducer.cs b/Aetheris.FEA/Firmament/FirmamentAnalysisSemanticProducer.csindex 5f49ed02..baa346ed 100644--- a/Aetheris.FEA/Firmament/FirmamentAnalysisSemanticProducer.cs+++ b/Aetheris.FEA/Firmament/FirmamentAnalysisSemanticProducer.cs@@ -6,7 +6,7 @@ namespace Aetheris.FEA.Firmament;internal static partial class FirmamentAnalysisSemanticProducer{- [GeneratedRegex(@"^(?<body>[A-Za-z_][A-Za-z0-9_]*)\.face\((?<side>[+-][XYZ])\)$", RegexOptions.CultureInvariant)]+ [GeneratedRegex(@"^(?<body>[A-Za-z_][A-Za-z0-9_]*)\.face\((?<side>[+-][XYZ]|\#?[0-9]+)\)$", RegexOptions.CultureInvariant | RegexOptions.IgnoreCase)]private static partial Regex FacePath();public static (SemanticValue? Value, SemanticDiagnostic? Diagnostic) Bind(@@ -20,8 +20,8 @@ internal static partial class FirmamentAnalysisSemanticProducerif (!match.Success || !string.Equals(match.Groups["body"].Value, expectedBody, StringComparison.Ordinal))return (null, new(SemanticValueValidator.PathMemberMissing,$"Boundary region '{authoredPath}' is not an exposed face of semantic body '{expectedBody}'.", sourceSpan));- var side = match.Groups["side"].Value;- var token = side switch { "-X" => "x-min", "+X" => "x-max", "-Y" => "y-min", "+Y" => "y-max", "-Z" => "z-min", "+Z" => "z-max", _ => string.Empty };+ var side = match.Groups["side"].Value.ToUpperInvariant();+ var token = side switch { "-X" => "x-min", "+X" => "x-max", "-Y" => "y-min", "+Y" => "y-max", "-Z" => "z-min", "+Z" => "z-max", _ => side };exactFaceIds.TryGetValue(token, out var faceId);var stableId = $"analysis-region:{origin}:{expectedBody}:face({side})" + (faceId is null ? string.Empty : ":" + faceId);return (new SemanticValue(stableId, new("BoundaryRegion"),diff --git a/Aetheris.FEA/Geometry/ImportedBrepAnalysisRegion.cs b/Aetheris.FEA/Geometry/ImportedBrepAnalysisRegion.csnew file mode 100644index 00000000..fdbe55e0--- /dev/null+++ b/Aetheris.FEA/Geometry/ImportedBrepAnalysisRegion.cs@@ -0,0 +1,176 @@+using Aetheris.Continuum.Boundaries;+using Aetheris.Continuum.Cir;+using Aetheris.Kernel.Core.Brep;+using Aetheris.Kernel.Core.Brep.Queries;+using Aetheris.Kernel.Core.Geometry;+using Aetheris.Kernel.Core.Geometry.Surfaces;+using Aetheris.Kernel.Core.Math;+using Aetheris.Kernel.Core.Numerics;+using Aetheris.Kernel.Core.Topology;++namespace Aetheris.FEA.Geometry;++/// <summary>+/// Production analysis-domain adapter for an imported closed BRep. The STEP importer remains the+/// sole owner of STEP syntax; this type only exposes kernel spatial and face-domain queries as CIR.+/// Imported coordinates are transformed to SI before they reach mechanics.+/// </summary>+public sealed class ImportedBrepAnalysisRegion : IContinuumRegion, IBoundsClassificationCapability, IPlanarBoundaryDomainCapability+{+ private readonly BrepBody _body;+ private readonly Transform3D _brepToWorld;+ private readonly Transform3D _worldToBrep;+ private readonly double _lengthScale;+ private readonly BrepSpatialQueries.PointContainmentQueryContext _queryContext;++ public ImportedBrepAnalysisRegion(RegionId id, BrepBody body, double lengthScaleToMeters = .001)+ {+ if (!double.IsFinite(lengthScaleToMeters) || lengthScaleToMeters <= 0)+ throw new ArgumentOutOfRangeException(nameof(lengthScaleToMeters));+ Id = id;+ _body = body ?? throw new ArgumentNullException(nameof(body));+ _lengthScale = lengthScaleToMeters;+ _brepToWorld = Transform3D.CreateScale(lengthScaleToMeters);+ _worldToBrep = _brepToWorld.Inverse();+ _queryContext = BrepSpatialQueries.CreatePointContainmentQueryContext(body);+ var bodyId=body.Topology.Bodies.Single().Id;var shellId=body.Topology.Shells.Single().Id;+ // Whole-shell bounds include deterministic samples of curved edge trims; vertex-only bounds+ // collapse periodic faces such as an imported cylindrical rod to their seam endpoints.+ Bounds=new WholeShellBoundaryQuery(body,new(id,bodyId.Value.ToString(),shellId.Value.ToString()),_brepToWorld).Bounds;+ }++ public RegionId Id { get; }+ public BoundingBox3D Bounds { get; }++ public ContinuumPointClassification Classify(Point3D point, double tolerance = 1e-9)+ {+ return ClassifyKernel(point,tolerance) switch+ {+ PointContainment.Inside => ContinuumPointClassification.Inside,+ PointContainment.Boundary => ContinuumPointClassification.Boundary,+ _ => ContinuumPointClassification.Outside,+ };+ }++ /// <summary>Rejects a body when the kernel cannot establish any occupied interior evidence.</summary>+ public bool TryValidateOccupancySupport(out string evidence)+ {+ var inside=0;var outside=0;var unknown=0;+ for(var k=0;k<4;k++)for(var j=0;j<4;j++)for(var i=0;i<4;i++)+ {+ var point=new Point3D(Bounds.Min.X+(Bounds.Max.X-Bounds.Min.X)*(i+.5)/4,+ Bounds.Min.Y+(Bounds.Max.Y-Bounds.Min.Y)*(j+.5)/4,+ Bounds.Min.Z+(Bounds.Max.Z-Bounds.Min.Z)*(k+.5)/4);+ switch(ClassifyKernel(point,1e-9)){case PointContainment.Inside:inside++;break;case PointContainment.Outside:outside++;break;case PointContainment.Boundary:inside++;break;default:unknown++;break;}+ }+ evidence=$"4x4x4 deterministic imported occupancy probes: inside/boundary={inside}, outside={outside}, unknown={unknown}.";+ return inside>0;+ }++ private PointContainment ClassifyKernel(Point3D point,double tolerance)+ {+ var kernelTolerance = new ToleranceContext(double.Max(tolerance / _lengthScale, 1e-9), ToleranceContext.Default.Angular);+ return BrepSpatialQueries.ClassifyPoint(_body, _worldToBrep.Apply(point), kernelTolerance, _queryContext).Value;+ }++ // Arbitrary closed BReps may contain holes or re-entrant material, so only disjoint cells can+ // be classified without sampling. Intersecting cells deliberately use deterministic cut-cell sampling.+ public ContinuumBoundsClassification ClassifyBounds(BoundingBox3D bounds, double tolerance = 1e-9) =>+ bounds.Max.X < Bounds.Min.X - tolerance || bounds.Min.X > Bounds.Max.X + tolerance+ || bounds.Max.Y < Bounds.Min.Y - tolerance || bounds.Min.Y > Bounds.Max.Y + tolerance+ || bounds.Max.Z < Bounds.Min.Z - tolerance || bounds.Min.Z > Bounds.Max.Z + tolerance+ ? ContinuumBoundsClassification.Outside : ContinuumBoundsClassification.Cut;++ public bool TryResolvePlanarBoundary(string semanticPath, string? exactBrepFaceId, out PlanarBoundaryDomain domain)+ {+ domain = null!;+ var faceId = ResolveFace(semanticPath, exactBrepFaceId);+ if (faceId is null || !_body.TryGetFaceSurface(faceId.Value, out var geometry)+ || geometry?.Kind != SurfaceGeometryKind.Plane || geometry.Plane is not PlaneSurface plane)+ return false;+ if (!TryLoops(faceId.Value, plane, out var outer, out var inner)) return false;+ var origin = _brepToWorld.Apply(plane.Origin);+ var u = _brepToWorld.Apply(plane.UAxis.ToVector());+ var v = _brepToWorld.Apply(plane.VAxis.ToVector());+ var n = plane.Normal.ToVector();+ u.TryNormalize(out u); v.TryNormalize(out v); n.TryNormalize(out n);+ var reference = new BoundaryReference("ImportedBRep", $"face:{faceId.Value.Value}", faceId.Value.Value.ToString(), semanticPath,+ Id.Value, _body.Topology.Bodies.Single().Id.Value.ToString(), _body.Topology.Shells.Single().Id.Value.ToString());+ domain = new(reference, origin, u, v, n,+ outer.Select(p => (p.U * _lengthScale, p.V * _lengthScale)).ToArray(),+ inner.Select(loop => (IReadOnlyList<(double U, double V)>)loop.Select(p => (p.U * _lengthScale, p.V * _lengthScale)).ToArray()).ToArray(),+ "Imported BRep planar trim; outward orientation resolved by CIR two-sided probe");+ return true;+ }++ private FaceId? ResolveFace(string path, string? exactId)+ {+ if (int.TryParse(exactId, out var id) && _body.Topology.TryGetFace(new(id), out _)) return new(id);+ var explicitMatch = System.Text.RegularExpressions.Regex.Match(path, @"\.face\(\#?(?<id>[0-9]+)\)$");+ if (explicitMatch.Success && int.TryParse(explicitMatch.Groups["id"].Value, out id) && _body.Topology.TryGetFace(new(id), out _)) return new(id);+ var token = new[] { "-X", "+X", "-Y", "+Y", "-Z", "+Z" }.FirstOrDefault(path.Contains);+ if (token is null) return null;+ var axis = token[1] switch { 'X' => new Vector3D(1, 0, 0), 'Y' => new Vector3D(0, 1, 0), _ => new Vector3D(0, 0, 1) };+ var candidates = _body.Topology.Faces.Select(face => (face.Id, Surface: _body.GetFaceSurface(face.Id)))+ .Where(item => item.Surface.Kind == SurfaceGeometryKind.Plane && item.Surface.Plane is not null+ && double.Abs(item.Surface.Plane.Value.Normal.ToVector().Dot(axis)) >= .999)+ .Select(item => (item.Id, Position: new Vector3D(item.Surface.Plane!.Value.Origin.X, item.Surface.Plane.Value.Origin.Y, item.Surface.Plane.Value.Origin.Z).Dot(axis)))+ .OrderBy(item => item.Id.Value).ToArray();+ if (candidates.Length == 0) return null;+ var extreme = token[0] == '-' ? candidates.Min(item => item.Position) : candidates.Max(item => item.Position);+ return candidates.First(item => double.Abs(item.Position - extreme) <= 1e-8).Id;+ }++ private bool TryLoops(FaceId faceId, PlaneSurface plane, out IReadOnlyList<(double U, double V)> outer, out IReadOnlyList<IReadOnlyList<(double U, double V)>> inner)+ {+ var loops = new List<IReadOnlyList<(double U, double V)>>();+ foreach (var loopId in _body.GetLoopIds(faceId))+ {+ var points = new List<Point3D>();+ foreach (var coedgeId in _body.GetCoedgeIds(loopId))+ {+ var coedge = _body.Topology.GetCoedge(coedgeId);+ if (!_body.TryGetEdgeCurve(coedge.EdgeId, out var curve) || curve is null || !_body.Bindings.TryGetEdgeBinding(coedge.EdgeId, out var binding))+ continue;+ var interval = binding.TrimInterval ?? new ParameterInterval(0, 1);+ var count = curve.Kind == CurveGeometryKind.Line3 ? 2 : 25;+ for (var i = 0; i < count; i++)+ {+ var fraction = i / (count - 1d);+ if (coedge.IsReversed) fraction = 1 - fraction;+ var t = interval.Start + (interval.End - interval.Start) * fraction;+ var point = Evaluate(curve, t);+ if (points.Count == 0 || (point - points[^1]).Length > 1e-9) points.Add(point);+ }+ }+ if (points.Count > 1 && (points[0] - points[^1]).Length <= 1e-9) points.RemoveAt(points.Count - 1);+ var projected = points.Select(point =>+ {+ var delta = point - plane.Origin;+ return (delta.Dot(plane.UAxis.ToVector()), delta.Dot(plane.VAxis.ToVector()));+ }).ToArray();+ if (projected.Length >= 3) loops.Add(projected);+ }+ var ordered = loops.OrderByDescending(loop => double.Abs(SignedArea(loop))).ToArray();+ outer = ordered.FirstOrDefault() ?? [];+ inner = ordered.Skip(1).ToArray();+ return outer.Count >= 3 && double.Abs(SignedArea(outer)) > 1e-12;+ }++ private static Point3D Evaluate(CurveGeometry curve, double t) => curve.Kind switch+ {+ CurveGeometryKind.Line3 => curve.Line3!.Value.Evaluate(t),+ CurveGeometryKind.Circle3 => curve.Circle3!.Value.Evaluate(t),+ CurveGeometryKind.BSpline3 => curve.BSpline3!.Value.Evaluate(t),+ CurveGeometryKind.Ellipse3 => curve.Ellipse3!.Value.Evaluate(t),+ CurveGeometryKind.Hyperbola3 => curve.Hyperbola3!.Value.Evaluate(t),+ _ => throw new NotSupportedException($"Imported boundary curve '{curve.Kind}' is unsupported."),+ };++ private static double SignedArea(IReadOnlyList<(double U, double V)> points)+ {+ var area = 0d;+ for (var i = 0; i < points.Count; i++) area += points[i].U * points[(i + 1) % points.Count].V - points[(i + 1) % points.Count].U * points[i].V;+ return area * .5;+ }+}diff --git a/Aetheris.FEA/Mechanics/LinearElasticSolver.cs b/Aetheris.FEA/Mechanics/LinearElasticSolver.csindex 73aa193a..0828fdc5 100644--- a/Aetheris.FEA/Mechanics/LinearElasticSolver.cs+++ b/Aetheris.FEA/Mechanics/LinearElasticSolver.cs@@ -14,7 +14,8 @@ public sealed record MechanicsSolveOptions(double RelativeResidualTolerance = 1e-9,int? MaximumIterations = null,Transform3D? DomainTransform = null,- bool PreserveNominalCellVolumeUnderTransform = false);+ bool PreserveNominalCellVolumeUnderTransform = false,+ bool RetryEmptyCutCells = true);public static class LinearElasticSolver{@@ -56,7 +57,7 @@ public static class LinearElasticSolverforeach (var cell in grid.Cells.Where(item => item.Classification != CellClassification.Outside)){var plan = CreateQuadrature(region, cell, options.CutCellQuadraturePerAxis);- if(plan.Points.Count==0&&cell.Classification==CellClassification.Cut)+ if(plan.Points.Count==0&&cell.Classification==CellClassification.Cut&&options.RetryEmptyCutCells){for(var order=Math.Max(options.CutCellQuadraturePerAxis+1,8);order<=32&&plan.Points.Count==0;order*=2)plan=CreateQuadrature(region,cell,order);}@@ -103,7 +104,10 @@ public static class LinearElasticSolverMechanicsBoundaryQuadraturePlan? Plan(SemanticRegionBinding binding){var key=binding.Path+"|"+binding.ExactBrepFaceId;if(boundaryPlans.TryGetValue(key,out var cached))return cached;- var semanticStart=Stopwatch.GetTimestamp();var resolved=planar.TryResolvePlanarBoundary(binding.Path,binding.ExactBrepFaceId,out var domain);semanticFaceTime+=Stopwatch.GetElapsedTime(semanticStart);+ var semanticStart=Stopwatch.GetTimestamp();bool resolved;PlanarBoundaryDomain domain;+ try{resolved=planar.TryResolvePlanarBoundary(binding.Path,binding.ExactBrepFaceId,out domain);}+ catch(NotSupportedException exception){semanticFaceTime+=Stopwatch.GetElapsedTime(semanticStart);diagnostics.Add(new("fea-boundary-geometry-unsupported",AnalysisDiagnosticSeverity.Error,exception.Message,binding.Provenance));return null;}+ semanticFaceTime+=Stopwatch.GetElapsedTime(semanticStart);if(!resolved){diagnostics.Add(new("fea-boundary-region-unresolved",AnalysisDiagnosticSeverity.Error,$"Semantic region '{binding.Path}' did not resolve to an exact planar face.",binding.Provenance));return null;}if(!domain.TryOrientFromMaterialSide(region,out domain)){diagnostics.Add(new("fea-material-side-ambiguity",AnalysisDiagnosticSeverity.Error,$"Semantic region '{binding.Path}' did not provide an unambiguous CIR material side.",binding.Provenance));return null;}try{var planStart=Stopwatch.GetTimestamp();var created=MechanicsBoundaryQuadrature.Create(domain,binding,active.Select(item=>item.Cell).ToArray());boundaryPlanTime+=Stopwatch.GetElapsedTime(planStart);boundaryPlans[key]=created;return created;}@@ -196,8 +200,15 @@ public static class LinearElasticSolvervar sparseBytes = (long)rawMatrix.Nonzeros * (sizeof(double) + sizeof(int)) + (long)(dofs + 1) * sizeof(int);var resultBytes = (long)displacements.Length * (sizeof(int) + 6*sizeof(double)) + (long)fields.Count * 16*sizeof(double);var lowering=new NumericalLoweringEvidence("m5c-v1-frozen","Compiler metadata governing independent numerical carriers; never a physical stiffness multiplier.",basisPlan.Supports,basisPlan.Treatments,boundaryEvidence,basisPlan.JudgmentCalls,boundaryChoices.Count,basisPlan.FixedThresholdCount,ImmersedNumericalLowering.Hash(basisPlan,boundaryEvidence),authorityTime,TimeSpan.Zero,constraintTime);- return new(analysis.Id, true, convergence, displacements, fields, reactions, equilibrium, system, tiny,- new(domainTime,quadratureTime,assemblyTime,boundaryTime,convergence.Runtime,recoveryTime,sparseBytes,resultBytes,semanticFaceTime,boundaryPlanTime,loadAssemblyTime,constraintTime),diagnostics,loadEvidence,lowering,energy,stressProbes);+ var reportedDisplacements=analysis.RequestedFields.Contains(AnalysisResultField.Displacement)?displacements:[];+ var wantsStrain=analysis.RequestedFields.Contains(AnalysisResultField.Strain);var wantsStress=analysis.RequestedFields.Contains(AnalysisResultField.Stress);+ var reportedFields=wantsStrain&&wantsStress?fields:[];+ var strainFields=wantsStrain?fields.Select(item=>new CellStrainResult(item.I,item.J,item.K,item.Position,item.Strain)).ToArray():[];+ var stressFields=wantsStress?fields.Select(item=>new CellStressResult(item.I,item.J,item.K,item.Position,item.StressPascal,item.VonMisesPascal)).ToArray():[];+ var reportedReactions=analysis.RequestedFields.Contains(AnalysisResultField.ReactionForce)?reactions:[];+ var reportedStressProbes=analysis.RequestedFields.Contains(AnalysisResultField.Stress)?stressProbes:[];+ return new(analysis.Id, true, convergence, reportedDisplacements, reportedFields, reportedReactions, equilibrium, system, tiny,+ new(domainTime,quadratureTime,assemblyTime,boundaryTime,convergence.Runtime,recoveryTime,sparseBytes,resultBytes,semanticFaceTime,boundaryPlanTime,loadAssemblyTime,constraintTime),diagnostics,loadEvidence,lowering,energy,reportedStressProbes,strainFields,stressFields);}public static MechanicsQuadraturePlan CreateQuadrature(IContinuumRegion region, ContinuumCell cell, int cutSamplesPerAxis)@@ -451,7 +462,8 @@ public static class LinearElasticSolvermaximum=double.Max(maximum,error);weighted+=error*error*point.AreaWeight;area+=point.AreaWeight;}}- return (maximum,area==0?0:double.Sqrt(weighted/area));+ // Roundoff can leave a tiny negative weighted sum when oriented triangle weights cancel.+ return (maximum,area==0?0:double.Sqrt(double.Max(0,weighted/area)));}private static Vector3D StrongReaction(IReadOnlyList<double> residual,IReadOnlySet<int> effectiveNodes,IReadOnlyDictionary<int,IReadOnlyList<(int EffectiveNode,double Weight)>> mappings)diff --git a/Aetheris.FEA/Mechanics/MechanicsModels.cs b/Aetheris.FEA/Mechanics/MechanicsModels.csindex 2890c6b9..a2876559 100644--- a/Aetheris.FEA/Mechanics/MechanicsModels.cs+++ b/Aetheris.FEA/Mechanics/MechanicsModels.cs@@ -22,6 +22,8 @@ public sealed record BoundaryLoadEvidence(string LoadId,string RegionPath,stringpublic readonly record struct MechanicsNode(int Id, Point3D Position);public readonly record struct SymmetricTensor(double XX, double YY, double ZZ, double XY, double YZ, double XZ);public sealed record CellFieldResult(int I, int J, int K, Point3D Position, SymmetricTensor Strain, SymmetricTensor StressPascal, double VonMisesPascal);+public sealed record CellStrainResult(int I,int J,int K,Point3D Position,SymmetricTensor Strain);+public sealed record CellStressResult(int I,int J,int K,Point3D Position,SymmetricTensor CauchyStressPascal,double VonMisesPascal);public sealed record NodalDisplacement(int NodeId, Point3D Position, Vector3D DisplacementMeters);public sealed record ReactionResult(string ConstraintId, Vector3D ForceNewton);public sealed record SolverConvergence(bool Converged, int Iterations, double InitialResidual, double FinalResidual, IReadOnlyList<double> ResidualHistory, TimeSpan Runtime);@@ -60,8 +62,10 @@ public sealed record LinearElasticAnalysisResult(IReadOnlyList<BoundaryLoadEvidence>? BoundaryLoads=null,NumericalLoweringEvidence? NumericalLowering=null,StrainEnergyConsistency? StrainEnergy=null,- IReadOnlyList<ExactStressProbe>? StressProbes=null)+ IReadOnlyList<ExactStressProbe>? StressProbes=null,+ IReadOnlyList<CellStrainResult>? StrainFields=null,+ IReadOnlyList<CellStressResult>? StressFields=null){public double MaximumDisplacementMeters => Displacements.Count == 0 ? 0 : Displacements.Max(item => item.DisplacementMeters.Length);- public double MaximumVonMisesPascal => CellFields.Count == 0 ? 0 : CellFields.Max(item => item.VonMisesPascal);+ public double MaximumVonMisesPascal => StressFields is { Count: >0 }?StressFields.Max(item=>item.VonMisesPascal):CellFields.Count == 0 ? 0 : CellFields.Max(item => item.VonMisesPascal);}diff --git a/docs/fea/architecture.md b/docs/fea/architecture.mdindex bc44632c..0aa5d7be 100644--- a/docs/fea/architecture.md+++ b/docs/fea/architecture.md@@ -20,7 +20,7 @@ Firmament owns body, homogeneous material assignment, semantic regions, constraiAnalysisIR contains no node, element, DOF, or sparse-matrix indices. `SemanticRegionBinding` preserves the source path, optional exact BRep face IDs, recognized imported faces, and declaration provenance. Solver indices first appear during mechanics discretization.-M5 supports native Box and centered box-minus-through-cylinder material domains. InlineStep Templates support canonical six-planar-face boxes through `ImportedStep`; unsupported imported topology fails with `firmament-analysis-inline-step-cir-unsupported` instead of silently approximating arbitrary BRep solids.+X1 supports native Box and centered box-minus-through-cylinder material domains plus closed imported BReps admitted by kernel point containment. InlineStep Templates and direct `inlineSTEP(path)` expressions lower through the existing STEP importer. Six-planar-face boxes retain an analytic fast path; general imported bodies use conservative cut-cell sampling and exact planar BRep face trims. Unsupported kernel containment fails instead of silently fabricating material. See [FEA-PROD-X1](production-x1.md).## Boundary ownershipdiff --git a/docs/fea/artifacts/m5/convergence/plate-hole-24x12x2.firmament b/docs/fea/artifacts/m5/convergence/plate-hole-24x12x2.firmamentindex 21c8fec2..16f98a2a 100644--- a/docs/fea/artifacts/m5/convergence/plate-hole-24x12x2.firmament+++ b/docs/fea/artifacts/m5/convergence/plate-hole-24x12x2.firmament@@ -2,13 +2,13 @@ model PlateHoleFine {units mmsolid plate: Box { size: [200, 100, 10] }modify plate { region hole on face(+Z) { cut Cylinder { radius: 10 through: face(-Z) } } }- analysis LinearElastic PlateHoleFineAnalysis {+ Analysis LinearElastic PlateHoleFineAnalysis {body: platematerial Steel { youngsModulus: 200GPapoissonRatio: 0.3 }- fixed Clamp { region: plate.face(-X)+ Fixed Clamp { region: plate.face(-X)components: [X, Y, Z] }- force Tension { region: plate.face(+X)+ Force Tension { region: plate.face(+X)vector: [10000N, 0N, 0N] }lattice: [24, 12, 2]results: [Displacement, Strain, Stress, ReactionForce]diff --git a/docs/fea/artifacts/m5/convergence/plate-hole-8x4x1.firmament b/docs/fea/artifacts/m5/convergence/plate-hole-8x4x1.firmamentindex 27da3d67..85a83ed2 100644--- a/docs/fea/artifacts/m5/convergence/plate-hole-8x4x1.firmament+++ b/docs/fea/artifacts/m5/convergence/plate-hole-8x4x1.firmament@@ -2,13 +2,13 @@ model PlateHoleCoarse {units mmsolid plate: Box { size: [200, 100, 10] }modify plate { region hole on face(+Z) { cut Cylinder { radius: 10 through: face(-Z) } } }- analysis LinearElastic PlateHoleCoarseAnalysis {+ Analysis LinearElastic PlateHoleCoarseAnalysis {body: platematerial Steel { youngsModulus: 200GPapoissonRatio: 0.3 }- fixed Clamp { region: plate.face(-X)+ Fixed Clamp { region: plate.face(-X)components: [X, Y, Z] }- force Tension { region: plate.face(+X)+ Force Tension { region: plate.face(+X)vector: [10000N, 0N, 0N] }lattice: [8, 4, 1]results: [Displacement, Strain, Stress, ReactionForce]diff --git a/docs/fea/artifacts/m5/plate-with-hole.firmament b/docs/fea/artifacts/m5/plate-with-hole.firmamentindex 23bda8f2..4b75f2ed 100644--- a/docs/fea/artifacts/m5/plate-with-hole.firmament+++ b/docs/fea/artifacts/m5/plate-with-hole.firmament@@ -15,7 +15,7 @@ model PlateWithHoleModel {}}- analysis LinearElastic PlateWithHole {+ Analysis LinearElastic PlateWithHole {body: platematerial Steel {@@ -24,12 +24,12 @@ model PlateWithHoleModel {density: 7850kg/m3}- fixed Clamp {+ Fixed Clamp {region: plate.face(-X)components: [X, Y, Z]}- force Tension {+ Force Tension {region: plate.face(+X)vector: [10000N, 0N, 0N]}diff --git a/docs/fea/firmament-analysis.md b/docs/fea/firmament-analysis.mdindex eff8d76d..30b5302b 100644--- a/docs/fea/firmament-analysis.md+++ b/docs/fea/firmament-analysis.md@@ -10,18 +10,18 @@The M5 analysis block is declarative and erases to AnalysisIR before mechanics execution:```firmament-analysis LinearElastic PlateWithHole {+Analysis LinearElastic PlateWithHole {body: platematerial Steel {youngsModulus: 200GPapoissonRatio: 0.3density: 7850kg/m3}- fixed Clamp {+ Fixed Clamp {region: plate.face(-X)components: [X, Y, Z]}- force Tension {+ Force Tension {region: plate.face(+X)vector: [10000N, 0N, 0N]}@@ -32,7 +32,7 @@ analysis LinearElastic PlateWithHole {`youngsModulus` accepts `Pa`, `kPa`, `MPa`, or `GPa` and normalizes to Pa. Resultant force components require N. Traction components and pressure require Pa. Lengths from native Firmament bodies normalize to meters. Poisson ratio is dimensionless and must lie in `(-1, 0.5)`.-`fixed` defaults to all three translation components; components may be selected individually. `traction` is force per area. `force` is a resultant distributed by the same exact-area traction integration. `pressure` uses `-p n_outward` on exact planar semantic faces; CIR material-side classification, not BRep `SameSense`, establishes outward direction.+`Fixed` defaults to all three translation components; components may be selected individually. `Traction` is force per area. `Force` is a total resultant distributed by the same exact-area traction integration. `Pressure` uses `-p n_outward` on exact planar semantic faces; CIR material-side classification, not BRep `SameSense`, establishes outward direction. Legacy lowercase semantic constructs remain accepted.Orientation and lattice adaptation are backend solve options and do not appear in AnalysisIR.@@ -54,7 +54,7 @@ An InlineStep Template uses a typed resource parameter:```firmamentTemplate < Part: ImportedStep > Model ImportedBoxAnalysis {- analysis LinearElastic ImportedBoxPull {+ Analysis LinearElastic ImportedBoxPull {body: importedbodyResource: Part// material, constraints, loads, lattice...@@ -62,6 +62,6 @@ Template < Part: ImportedStep > Model ImportedBoxAnalysis {}```-Bind it with `ForgeImportedStep(resource.Name)` and `AddResource(resource)`. M5 validates canonical STEP evidence and six-face exact-box admission.+Bind it with `ForgeImportedStep(resource.Name)` and `AddResource(resource)`. X1 also admits general closed BReps through kernel containment and the shared CIR/cut-cell path; six-face exact boxes retain their faster analytic lowering.Diagnostics include invalid material, unresolved/nonplanar faces, invalid local frames/trims, no owned fragments, material-side ambiguity, area/resultant/moment mismatch, rigid modes, conflicting constraints, non-convergence, missing imported resources, unsupported imported CIR lowering, and invalid Abaqus output.diff --git a/docs/fea/production-x1.md b/docs/fea/production-x1.mdnew file mode 100644index 00000000..9da787ed--- /dev/null+++ b/docs/fea/production-x1.md@@ -0,0 +1,70 @@+# FEA-PROD-X1 production boundary++The production path is:++```text+Firmament analysis intent+ -> resolved geometry source (native body or imported STEP)+ -> IContinuumRegion analysis domain in SI coordinates+ -> deterministic regular lattice and occupied cut-cell quadrature+ -> MAT-DB-X1 LinearElasticIsotropic material record+ -> exact semantic planar boundary/load lowering+ -> deterministic sparse Q1 assembly and PCG solve+ -> typed result fields and reproducibility report+```++`LinearElasticAnalysisIr` is the ownership boundary. It contains the analysis kind, domain reference, resolved material and stable ID, constraints, loads and explicit distribution policy, lattice, requested outputs, SI values, and provenance. The mechanics namespace does not parse Firmament or STEP and does not query the material database.++Native boxes and box-with-hole bodies and imported BReps converge at `IContinuumRegion`. Six-planar-face imported boxes retain an exact analytic fast path. Other closed imported BReps use kernel `BrepSpatialQueries` for occupancy and exact BRep topology/trim curves for planar boundary domains. STEP coordinates currently follow the repository's documented millimetre import assumption and are scaled to metres at the analysis-domain seam. Unsupported or ambiguous kernel containment produces an empty/unsupported domain diagnostic rather than fabricated material.++The direct bounded form is:++```firmament+Analysis LinearElastic ImportedThroughHole {+ body: inlineSTEP("part.step")+ material: Standard.Materials.Aluminum.6061_T6+ Fixed Mount {+ region: body.face(#170)+ components: [X, Y, Z]+ }+ Force Load {+ region: body.face(#141)+ vector: [0N, -500N, 0N]+ }+ results: [Displacement, Strain, Stress, ReactionForce]+ lattice: [6, 4, 3]+}+```++The existing canonical `InlineStep name { Path: ... }` plus `body: name` form and recognized semantic regions remain supported. `#170` denotes stable STEP `ADVANCED_FACE` identity and is lowered to the corresponding BRep face ID; sequential `face(6)`, recognized region names, and bounded directional selectors remain available. This is a bounded face-selection system, not a universal CAD query language.++## Load and result semantics++`Force` is a total resultant in newtons, distributed over the selected exact face by area while preserving resultant and first moment. `Traction` is a vector in Pa applied per unit area. `Pressure` is a scalar in Pa acting opposite the CIR-resolved outward normal. Reports state this as `TotalResultantOverSelectedArea`, `TractionPerUnitArea`, or `PressureNormalToSurface`.++| Result | Representation | Unit | Location/recovery |+| --- | --- | --- | --- |+| Displacement | vector | m | admitted lattice nodes; aggregated nodes are affine extensions |+| Strain | symmetric small-strain tensor | 1 | occupied cell center from the Q1 gradient |+| Stress | isotropic Cauchy tensor plus von Mises scalar | Pa | occupied cell center; no nodal stress interpolation |+| ReactionForce | vector per constraint | N | constrained residual or consistent Nitsche boundary integral |++Only requested result collections are exposed. Equilibrium evidence is always retained as a run-integrity metric. The CLI report includes geometry identity/hash, BRep body ID, stable material ID, lattice, constraints, load policy, solver settings, timings, sparse memory, residual history, result contracts, and `sum(reaction)+sum(load)`.++## X1 witnesses++- Catalog coupon: `fixtures/FirmamentV2/Materials/catalog-material-coupon.firmament` preserves the MAT-DB-X1 5052-H32 path.+- Cantilever: `ProductionFeaX1Tests` checks exact linear scaling (`u` doubles with load and halves with doubled `E`), three bounded lattice levels, increasing DOFs, finite displacement, and reaction equilibrium. For the 120x20x20 mm beam, 100 N transverse tip resultant, and 70 GPa modulus, slender Euler-Bernoulli theory gives 61.71 micrometres. The table trends toward that reference; the fine result is about 5.6% low. The beam is only six depths long and the load/support idealizations differ, so this is an empirical credibility check rather than an asymptotic or exact-agreement claim.++| Lattice | DOFs | max displacement | beam-reference error | equilibrium residual | PCG residual / iterations | assembly / solve | sparse bytes |+| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |+| 6x2x2 | 189 | 42.803 micrometres | -30.6% | 1.27e-9 N | 3.21e-8 / 49 | 28 / 25 ms | 101,308 |+| 12x2x2 | 351 | 53.931 micrometres | -12.6% | 3.22e-9 N | 2.94e-8 / 56 | 54 / 46 ms | 197,212 |+| 18x3x3 | 912 | 58.270 micrometres | -5.6% | 1.19e-9 N | 2.66e-8 / 89 | 186 / 223 ms | 597,652 |++The CLI `--lattice nx,ny,nz` override produced these three runs from one canonical fixture, keeping analysis intent fixed while varying only discretization. Timings are machine/run dependent.+- Imported through-hole: `fixtures/FirmamentV2/FEA/inline-step-through-hole.firmament` imports a seven-face planar/cylindrical STEP body without rebuilding it. At 6x4x3 it produced 72 cut cells, 420 DOFs, 22,230 nonzeros, 45 PCG iterations, 14.445 micrometre maximum displacement, 44.945 MPa maximum cell-center von Mises stress, and an 8.43e-9 N equilibrium residual. The measured run spent about 0.17 s in domain setup, 0.83 s in cut quadrature, 0.46 s in assembly, 0.04 s in solve, and used about 268 kB of sparse storage; timings are machine-dependent.++The imported witness deliberately disables high-order rescue sampling for cells already empty at the bounded occupancy pass. This policy is reported as a solver setting. It avoids exponential work over generic BRep bounding-box voids; users must refine the lattice when features are thinner than the chosen occupancy sampling.++Curved-face loads, universal selection, adaptive refinement, nonlinear constitutive laws, contact, and formal convergence guarantees remain outside X1. The OCCT L-bracket was also audited: its imported analytic-ray containment currently returns `Unknown` for interior probes because of the kernel's bounded B-spline face-domain support. X1 does not paper over that kernel limitation with a mesh or ad-hoc STEP parser.diff --git a/docs/firmament-v2/casing-style.md b/docs/firmament-v2/casing-style.mdnew file mode 100644index 00000000..bc860ef8--- /dev/null+++ b/docs/firmament-v2/casing-style.md@@ -0,0 +1,22 @@+# Firmament V2 casing++Firmament generally uses PascalCase for semantic constructs and camelCase for ordinary data slots. Casing is a readability convention, not a semantic ceremony. The parser may accept legacy casing where it is unambiguous, and no style-only warnings are emitted. New V2 language vocabulary does not use snake_case; imported names, user identifiers, and engineering designations such as `5052_H32` retain their source spelling.++The bounded FEA-PROD-X1 audit used three decisions: **canonicalize** first-party output, **allow both** for low-cost migration aliases, and **doesn't matter** for identifiers whose spelling carries no language meaning.++| Token/family | Category | Existing spellings | Canonical spelling | Decision | Parser policy |+| --- | --- | --- | --- | --- | --- |+| `Model`, `Template`, `Record`, `Static`, `Profile`, `Selection` | declaration | primarily PascalCase | PascalCase | canonicalize | CanonicalOnly in the central V2 grammar |+| `Analysis` | semantic declaration | `analysis`, `Analysis` | `Analysis` | allow both | CanonicalPreferredAcceptAliases |+| `LinearElastic` | analysis/type value | `LinearElastic` | `LinearElastic` | canonicalize | CasePermissive inside analysis declarations |+| `Fixed`, `Force`, `Traction`, `Pressure` | analysis semantic construct | lowercase and PascalCase | PascalCase | allow both | CanonicalPreferredAcceptAliases |+| `InlineStep` declaration | imported-body declaration | `InlineStep` | `InlineStep` | canonicalize | CanonicalOnly in the central V2 grammar |+| `inlineSTEP(path)` analysis expression | built-in compatibility function | `inlineSTEP`, `InlineStep` | `inlineSTEP` | allow both | CanonicalPreferredAcceptAliases |+| `Recognize`, `Replace`, `Modify`, `Match`, `Require`, `Assert`, `Pmi` | semantic/DSL construct | PascalCase in canonical grammar; some legacy lowercase routes | PascalCase | canonicalize | CanonicalOnly where ambiguity or route selection matters |+| `body`, `bodyResource`, `material`, `region`, `components`, `vector`, `results`, `lattice` | ordinary property | camelCase | camelCase | canonicalize documentation | CasePermissive in the analysis block |+| `Displacement`, `Strain`, `Stress`, `ReactionForce`; `X`, `Y`, `Z` | enum-like value | PascalCase/uppercase | shown spelling | allow both | CasePermissive in analysis lists |+| `face(...)`, user function/member names | member/function-like | camelCase or authored identifier | camelCase for first-party members | doesn't matter for user members | identifier semantics apply |+| model, body, region, constraint, load names | user identifier | authored spelling, including underscores | author choice | doesn't matter | case-sensitive identity |+| STEP entity references, recognized external names, material designation tokens | external/imported identifier | source spelling such as `#141`, `5052_H32` | source spelling | doesn't matter | exact external identity |++This is deliberately not a global case-insensitive rewrite. The central V2 grammar retains canonical-only spellings where token case participates in deterministic route selection. The analysis compiler accepts the harmless legacy aliases listed above so existing M5 files remain viable while first-party FEA fixtures use the preferred form.diff --git a/docs/milestones/MAT-DB-X1.md b/docs/milestones/MAT-DB-X1.mdindex ae6e7546..4a692be9 100644--- a/docs/milestones/MAT-DB-X1.md+++ b/docs/milestones/MAT-DB-X1.md@@ -52,7 +52,7 @@ Values are not supplier certificates. Reports should preserve the attached proveFirmament names one catalog material; it does not query the database:```firmament-analysis LinearElastic CouponPull {+Analysis LinearElastic CouponPull {body: couponmaterial: Standard.Materials.Aluminum.5052_H32// constraints and loads...diff --git a/fixtures/FirmamentV2/FEA/cantilever.firmament b/fixtures/FirmamentV2/FEA/cantilever.firmamentnew file mode 100644index 00000000..33af7488--- /dev/null+++ b/fixtures/FirmamentV2/FEA/cantilever.firmament@@ -0,0 +1,22 @@+Model CantileverWitness {+ Units: mm+ solid beam: Box { size: [120, 20, 20] }++ Analysis LinearElastic Cantilever {+ body: beam+ material: Standard.Materials.Aluminum.6061_T6++ Fixed Root {+ region: beam.face(-X)+ components: [X, Y, Z]+ }++ Force Tip {+ region: beam.face(+X)+ vector: [0N, -100N, 0N]+ }++ results: [Displacement, Strain, Stress, ReactionForce]+ lattice: [12, 2, 2]+ }+}diff --git a/fixtures/FirmamentV2/FEA/inline-step-through-hole.firmament b/fixtures/FirmamentV2/FEA/inline-step-through-hole.firmamentnew file mode 100644index 00000000..d24d630d--- /dev/null+++ b/fixtures/FirmamentV2/FEA/inline-step-through-hole.firmament@@ -0,0 +1,19 @@+Model ImportedThroughHoleWitness {+ Analysis LinearElastic ImportedThroughHole {+ body: inlineSTEP("../InlineStep/testdata/canonical-through-hole.step")+ material: Standard.Materials.Aluminum.6061_T6++ Fixed Mount {+ region: body.face(#170)+ components: [X, Y, Z]+ }++ Force ServiceLoad {+ region: body.face(#141)+ vector: [0N, -500N, 0N]+ }++ results: [Displacement, Strain, Stress, ReactionForce]+ lattice: [6, 4, 3]+ }+}diff --git a/fixtures/FirmamentV2/Materials/catalog-material-coupon.firmament b/fixtures/FirmamentV2/Materials/catalog-material-coupon.firmamentindex 8a430093..27096468 100644--- a/fixtures/FirmamentV2/Materials/catalog-material-coupon.firmament+++ b/fixtures/FirmamentV2/Materials/catalog-material-coupon.firmament@@ -2,14 +2,14 @@ model CatalogMaterialCoupon {units mmsolid coupon: Box { size: [80, 20, 2] }- analysis LinearElastic CouponPull {+ Analysis LinearElastic CouponPull {body: couponmaterial: Standard.Materials.Aluminum.5052_H32- fixed Clamp {+ Fixed Clamp {region: coupon.face(-X)components: [X, Y, Z]}- force Pull {+ Force Pull {region: coupon.face(+X)vector: [1000N, 0N, 0N]}