Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Expose experimental FEA solver controls and thin-wall evidence
Yuechen Lidc48533d2dd4
diff --git a/Aetheris.CLI/CliRunner.cs b/Aetheris.CLI/CliRunner.csindex 07457d13..e579648f 100644--- a/Aetheris.CLI/CliRunner.cs+++ b/Aetheris.CLI/CliRunner.cs@@ -163,7 +163,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> [--lattice <nx,ny,nz>] [--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>] [--experimental-preconditioner <identity|jacobi|block-jacobi|ic0>] [--experimental-equilibration <true|false>] [--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]";@@ -1080,13 +1080,15 @@ 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;(int X,int Y,int Z)? latticeOverride=null;+ var input = Path.GetFullPath(args[0]); string? outDir = null; var json = false;Vector3D? rotationDegrees=null;(int X,int Y,int Z)? latticeOverride=null;ExperimentalPreconditionerKind? experimentalPreconditioner=null;bool? experimentalEquilibration=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 if(args[index]=="--experimental-preconditioner"&&index+1<args.Length){var value=args[++index];experimentalPreconditioner=value.ToLowerInvariant() switch{"identity"=>ExperimentalPreconditionerKind.Identity,"jacobi"=>ExperimentalPreconditionerKind.Jacobi,"block-jacobi"=>ExperimentalPreconditionerKind.BlockJacobi3,"ic0"=>ExperimentalPreconditionerKind.IncompleteCholeskyZero,_=>(ExperimentalPreconditionerKind?)null};if(experimentalPreconditioner is null){stderr.WriteLine("Experimental preconditioner must be identity, jacobi, block-jacobi, or ic0.");return 1;}}+ else if(args[index]=="--experimental-equilibration"&&index+1<args.Length){if(!bool.TryParse(args[++index],out var value)){stderr.WriteLine("Experimental equilibration must be true or false.");return 1;}experimentalEquilibration=value;}else { stderr.WriteLine(FeaUsage); return 1; }}if (!File.Exists(input))@@ -1118,7 +1120,7 @@ Model CanonicalPanel {var quadratureOrder=compiled.Analysis.Body.ContinuumRegion is Aetheris.FEA.Geometry.ImportedBrepAnalysisRegion?4:6;var isExperimentalShell=compiled.Analysis.Mode==Aetheris.FEA.Analysis.AnalysisMode.ExperimentalShell;var solveOptions=new MechanicsSolveOptions(CutCellQuadraturePerAxis:quadratureOrder,RelativeResidualTolerance:isExperimentalShell?1e-8:1e-9,MaximumIterations:isExperimentalShell?10000:null,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);+ RetryEmptyCutCells:compiled.Analysis.Body.ContinuumRegion is not Aetheris.FEA.Geometry.ImportedBrepAnalysisRegion,ExperimentalPreconditioner:experimentalPreconditioner,ExperimentalSymmetricEquilibration:experimentalEquilibration);var result = LinearElasticSolver.Solve(compiled.Analysis,solveOptions);if (!result.IsSuccess){var errors = result.Diagnostics.Where(item => item.Severity == Aetheris.FEA.Analysis.AnalysisDiagnosticSeverity.Error).ToArray();@@ -1128,7 +1130,7 @@ Model CanonicalPanel {command = "fea",success = false,input,- diagnostics = errors.Select(diagnostic => new { diagnostic.Code, severity = diagnostic.Severity.ToString(), diagnostic.Message })+ diagnostics = errors.Select(diagnostic => new { diagnostic.Code, severity = diagnostic.Severity.ToString(), diagnostic.Message }),result.System,result.Solver,experimentalShell=result.ExperimentalShell}, JsonOptions));elseforeach (var diagnostic in errors) stderr.WriteLine($"{diagnostic.Code}: {diagnostic.Message}");@@ -1149,10 +1151,12 @@ Model CanonicalPanel {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(), distribution=item.Distribution.ToString(), region = item.Region.Path, item.VectorSi, item.PressurePascal }),+ bodyForces = (compiled.Analysis.BodyForces??[]).Select(item=>new{item.Id,item.AccelerationMetersPerSecondSquared}),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 },experimentalShell=compiled.Analysis.ExperimentalShell },- 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,+ lattice = new { compiled.Analysis.Lattice.CountX, compiled.Analysis.Lattice.CountY, compiled.Analysis.Lattice.CountZ },experimentalShell=compiled.Analysis.ExperimentalShell,+ midsurfacePatchGraph=compiled.Analysis.MidsurfacePatchGraph is null?null:new{analysisSource=compiled.Analysis.MidsurfacePatchGraph.AnalysisSource.ToString(),compiled.Analysis.MidsurfacePatchGraph.SheetMetalBody,compiled.Analysis.MidsurfacePatchGraph.ThicknessMeters,compiled.Analysis.MidsurfacePatchGraph.Material,patchCount=compiled.Analysis.MidsurfacePatchGraph.Patches.Count,compiled.Analysis.MidsurfacePatchGraph.PanelPatchCount,compiled.Analysis.MidsurfacePatchGraph.BendPatchCount,compiled.Analysis.MidsurfacePatchGraph.OpeningCount,interfaceCount=compiled.Analysis.MidsurfacePatchGraph.Interfaces.Count,patches=compiled.Analysis.MidsurfacePatchGraph.Patches.Select(x=>new{x.Identity,kind=x.Kind.ToString(),bounds=x.ParameterDomain.Bounds,x.OpeningCount,x.SourceAuthority}),interfaces=compiled.Analysis.MidsurfacePatchGraph.Interfaces.Select(x=>new{x.Identity,x.PatchA,edgeA=x.EdgeA.ToString(),x.PatchB,edgeB=x.EdgeB.ToString(),orientation=x.Orientation.ToString(),x.StartMeters,x.EndMeters,x.MaximumMismatchMeters,x.SemanticBendId})} },+ solverSettings=new{solveOptions.CutCellQuadraturePerAxis,solveOptions.RelativeResidualTolerance,solveOptions.MaximumIterations,solveOptions.RetryEmptyCutCells,solveOptions.ExperimentalPreconditioner,solveOptions.ExperimentalSymmetricEquilibration},+ orientationDegrees=rotationDegrees,result.System, result.Solver, result.Equilibrium, result.TinyCells, result.Performance,boundaryLoads=result.BoundaryLoads,bodyLoads=result.BodyLoads,numericalLowering=result.NumericalLowering,strainEnergy=result.StrainEnergy,stressProbes=result.StressProbes,experimentalShell=result.ExperimentalShell,maximumDisplacementMeters = result.MaximumDisplacementMeters, maximumVonMisesPascal = result.MaximumVonMisesPascal,abaqus = abaqusReport@@ -1166,10 +1170,12 @@ Model CanonicalPanel {File.WriteAllText(Path.Combine(outDir, "residual-history.json"), JsonSerializer.Serialize(result.Solver.ResidualHistory, JsonOptions));File.WriteAllText(Path.Combine(outDir, "displacement-stress-summary.json"), JsonSerializer.Serialize(new { maximumDisplacementMeters = result.MaximumDisplacementMeters, maximumVonMisesPascal = result.MaximumVonMisesPascal, result.Equilibrium }, JsonOptions));File.WriteAllText(Path.Combine(outDir,"boundary-quadrature.json"),JsonSerializer.Serialize(result.BoundaryLoads,JsonOptions));+ File.WriteAllText(Path.Combine(outDir,"body-force-quadrature.json"),JsonSerializer.Serialize(result.BodyLoads,JsonOptions));File.WriteAllText(Path.Combine(outDir,"numerical-lowering-strategy-map.json"),JsonSerializer.Serialize(result.NumericalLowering,JsonOptions));if(experimental){File.WriteAllText(Path.Combine(outDir,"experimental-shell-evidence.json"),JsonSerializer.Serialize(result.ExperimentalShell,JsonOptions));+ if(compiled.Analysis.MidsurfacePatchGraph is not null)File.WriteAllText(Path.Combine(outDir,"midsurface-patch-graph.json"),JsonSerializer.Serialize(report.analysis.midsurfacePatchGraph,JsonOptions));File.WriteAllText(Path.Combine(outDir,"parameter-domain-grid.svg"),ThinWallDebugArtifacts.ParameterDomainSvg(compiled.Analysis));File.WriteAllText(Path.Combine(outDir,"mapped-deformed-cells.svg"),ThinWallDebugArtifacts.MappedAndDeformedSvg(compiled.Analysis,result));}diff --git a/Aetheris.FEA.Tests/ExperimentalShellX1AuthorityTests.cs b/Aetheris.FEA.Tests/ExperimentalShellX1AuthorityTests.csnew file mode 100644index 00000000..16fb0a3b--- /dev/null+++ b/Aetheris.FEA.Tests/ExperimentalShellX1AuthorityTests.cs@@ -0,0 +1,137 @@+using Aetheris.FEA.Analysis;+using Aetheris.SheetMetal;++namespace Aetheris.FEA.Tests;++public sealed class ExperimentalShellX1AuthorityTests+{+ [Fact]+ public void CompilerDerivesNativeThicknessAndMaterialWithoutDuplicateAnalysisAuthority()+ {+ var path=Path.Combine(FindRoot(),"fixtures","Canonical","FEA","ExperimentalShell","native-l-bracket.firmament");+ var compiled=Aetheris.FEA.Firmament.FirmamentAnalysisCompiler.Compile(File.ReadAllText(path),path,Path.GetDirectoryName(path));+ Assert.True(compiled.IsSuccess,string.Join("; ",compiled.Diagnostics.Select(x=>x.Code+":"+x.Message)));+ Assert.Equal(AnalysisGeometrySourceKind.NativeSheetMetal,compiled.Analysis!.Body.GeometrySource);+ Assert.Equal(.0015,compiled.Analysis.ExperimentalShell!.ThicknessMeters,12);+ Assert.NotNull(compiled.Analysis.Materials.Single().CatalogMaterial);+ Assert.Equal(3,compiled.Analysis.MidsurfacePatchGraph!.Patches.Count);+ foreach(var patch in compiled.Analysis.MidsurfacePatchGraph.Patches)+ {+ var b=patch.ParameterDomain.Bounds;var mapped=ThinWallAnalysisAuthority.Evaluate(patch,(b.Min.X+b.Max.X)/2,(b.Min.Y+b.Max.Y)/2,0);+ Assert.True(mapped.DerivativeR.Cross(mapped.DerivativeS).Dot(mapped.DerivativeT)>0,$"{patch.Identity}: R={mapped.DerivativeR}, S={mapped.DerivativeS}, T={mapped.DerivativeT}");+ }+ }++ [Fact]+ public void NativeSingleBendSolvesWithSharedC0TraceDegreesOfFreedom()+ {+ var path=Path.Combine(FindRoot(),"fixtures","Canonical","FEA","ExperimentalShell","native-l-bracket.firmament");var compiled=Aetheris.FEA.Firmament.FirmamentAnalysisCompiler.Compile(File.ReadAllText(path),path,Path.GetDirectoryName(path));+ Assert.True(compiled.IsSuccess,string.Join("; ",compiled.Diagnostics.Select(x=>x.Code+":"+x.Message)));+ var result=Aetheris.FEA.Mechanics.LinearElasticSolver.Solve(compiled.Analysis!,new(RelativeResidualTolerance:1e-8,MaximumIterations:10000));+ Assert.True(result.IsSuccess,string.Join("; ",result.Diagnostics.Select(x=>x.Code+":"+x.Message)));+ Assert.Equal(585,result.System.DegreesOfFreedom);+ Assert.Equal(90,result.ExperimentalShell!.NativeSheetMetal!.SharedDisplacementDegreesOfFreedom);+ Assert.Equal(2,result.ExperimentalShell.NativeSheetMetal.InterfaceCount);+ Assert.InRange(result.Equilibrium.ResidualNewton.Length,0,1e-5);+ Assert.InRange(result.StrainEnergy!.RelativeResidual,0,1e-6);+ Assert.True(double.IsFinite(result.MaximumDisplacementMeters)&&result.MaximumDisplacementMeters>0);+ }++ [Fact]+ public void NativeFlatPanelMatchesFrozenSyntheticFlatSolution()+ {+ var native=Compile("Canonical","FEA","ExperimentalShell","native-flat-cantilever.firmament");var synthetic=Compile("Canonical","FEA","ExperimentalShell","flat-cantilever.firmament");+ var nativeResult=Aetheris.FEA.Mechanics.LinearElasticSolver.Solve(native,new(RelativeResidualTolerance:1e-8,MaximumIterations:10000));var syntheticResult=Aetheris.FEA.Mechanics.LinearElasticSolver.Solve(synthetic,new(RelativeResidualTolerance:1e-8,MaximumIterations:10000));+ Assert.True(nativeResult.IsSuccess,string.Join("; ",nativeResult.Diagnostics.Select(x=>x.Code+":"+x.Message)));Assert.True(syntheticResult.IsSuccess);+ Assert.InRange(Math.Abs(nativeResult.MaximumDisplacementMeters-syntheticResult.MaximumDisplacementMeters)/syntheticResult.MaximumDisplacementMeters,0,1e-7);+ Assert.InRange(Math.Abs(nativeResult.StrainEnergy!.AlgebraicJoule-syntheticResult.StrainEnergy!.AlgebraicJoule)/syntheticResult.StrainEnergy.AlgebraicJoule,0,1e-7);+ }++ [Fact]+ public void NativeAuthorityConflictsFailWithTypedDiagnostics()+ {+ var material=CompileResult("Invalid","FEA","ExperimentalShell","native-sheetmetal-unresolved-material.firmament");Assert.Contains(material.Diagnostics,x=>x.Code=="firmament-material-unknown");+ var thickness=CompileResult("Invalid","FEA","ExperimentalShell","native-sheetmetal-thickness-override.firmament");Assert.Contains(thickness.Diagnostics,x=>x.Code=="thinwall-thickness-source-mismatch");+ var partialEdge=CompileResult("Invalid","FEA","ExperimentalShell","native-sheetmetal-partial-edge-interface.firmament");Assert.Contains(partialEdge.Diagnostics,x=>x.Code=="thinwall-sheetmetal-interface-mismatch");+ }++ [Fact]+ public void NativeTwoBendChannelRetainsOpeningsAndConformingInterfaces()+ {+ var analysis=Compile("Canonical","FEA","ExperimentalShell","native-u-channel.firmament");var graph=analysis.MidsurfacePatchGraph!;+ Assert.Equal(5,graph.Patches.Count);Assert.Equal(2,graph.BendPatchCount);Assert.Equal(2,graph.OpeningCount);Assert.Equal(4,graph.Interfaces.Count);+ var result=Aetheris.FEA.Mechanics.LinearElasticSolver.Solve(analysis,new(RelativeResidualTolerance:1e-8,MaximumIterations:10000));+ Assert.True(result.IsSuccess,string.Join("; ",result.Diagnostics.Select(x=>x.Code+":"+x.Message)));+ Assert.Equal(180,result.ExperimentalShell!.NativeSheetMetal!.SharedDisplacementDegreesOfFreedom);+ Assert.InRange(result.Equilibrium.ResidualNewton.Length,0,1e-5);+ var repeat=Aetheris.FEA.Mechanics.LinearElasticSolver.Solve(analysis,new(RelativeResidualTolerance:1e-8,MaximumIterations:10000));+ Assert.True(repeat.IsSuccess);+ Assert.Equal(result.MaximumDisplacementMeters,repeat.MaximumDisplacementMeters);+ Assert.Equal(result.ExperimentalShell.DeterministicDiscretizationHash,repeat.ExperimentalShell!.DeterministicDiscretizationHash);+ Assert.Equal(result.Solver.ResidualHistory,repeat.Solver.ResidualHistory);+ }++ [Fact]+ public void CurvedTrimmedShellAssemblesDensityBodyForceWithAlphaAwareVolumeQuadrature()+ {+ var analysis=Compile("Canonical","FEA","ExperimentalShell","curved-body-force-shell.firmament");+ var result=Aetheris.FEA.Mechanics.LinearElasticSolver.Solve(analysis,new(RelativeResidualTolerance:1e-8,MaximumIterations:10000));+ Assert.True(result.IsSuccess,string.Join("; ",result.Diagnostics.Select(x=>x.Code+":"+x.Message)));+ var body=result.BodyLoads!.Single();+ Assert.Equal(7850,body.DensityKilogramsPerCubicMeter);+ Assert.True(body.IntegratedVolumeCubicMeters>0);+ Assert.Equal(0,body.IntegratedResultantNewton.X,12);+ Assert.Equal(0,body.IntegratedResultantNewton.Y,12);+ Assert.True(body.IntegratedResultantNewton.Z<0);+ Assert.InRange(result.Equilibrium.ResidualNewton.Length,0,1e-5);+ Assert.True(result.ExperimentalShell!.CutCells>0);+ var missingDensity=analysis with{Materials=analysis.Materials.Select(x=>x with{DensityKilogramsPerCubicMeter=null}).ToArray()};+ var rejected=Aetheris.FEA.Mechanics.LinearElasticSolver.Solve(missingDensity);+ Assert.False(rejected.IsSuccess);+ Assert.Contains(rejected.Diagnostics,x=>x.Code=="fea-body-force-density-missing");+ }++ [Fact]+ public void OffsetCutRemainsFiniteWithoutChangingTheX0CutCellMethod()+ {+ var path=Path.Combine(FindRoot(),"fixtures","Canonical","FEA","ExperimentalShell","cut-boundary-plate.firmament");+ var source=File.ReadAllText(path).Replace("Point2(0mm, 0mm)","Point2(137mm, 83mm)",StringComparison.Ordinal);+ var compiled=Aetheris.FEA.Firmament.FirmamentAnalysisCompiler.Compile(source,path,Path.GetDirectoryName(path));+ Assert.True(compiled.IsSuccess,string.Join("; ",compiled.Diagnostics.Select(x=>x.Code+":"+x.Message)));+ var result=Aetheris.FEA.Mechanics.LinearElasticSolver.Solve(compiled.Analysis!,new(RelativeResidualTolerance:1e-8,MaximumIterations:10000));+ Assert.True(result.IsSuccess,string.Join("; ",result.Diagnostics.Select(x=>x.Code+":"+x.Message)));+ Assert.True(double.IsFinite(result.StrainEnergy!.AlgebraicJoule));+ Assert.True(result.ExperimentalShell!.CutCells>0);+ Assert.InRange(result.Equilibrium.ResidualNewton.Length,0,1e-5);+ }++ private static LinearElasticAnalysisIr Compile(params string[] parts){var result=CompileResult(parts);Assert.True(result.IsSuccess,string.Join("; ",result.Diagnostics.Select(x=>x.Code+":"+x.Message)));return result.Analysis!;}+ private static Aetheris.FEA.Firmament.FirmamentAnalysisCompilation CompileResult(params string[] parts){var path=Path.Combine(new[]{FindRoot(),"fixtures"}.Concat(parts).ToArray());return Aetheris.FEA.Firmament.FirmamentAnalysisCompiler.Compile(File.ReadAllText(path),path,Path.GetDirectoryName(path));}++ [Fact]+ public void NativeSingleBendProjectsExactPanelBendPanelGraph()+ {+ var path=Path.Combine(FindRoot(),"fixtures","Canonical","SheetMetal","l-bracket.firmament");+ var authored=SheetMetalFirmament.Compile(File.ReadAllText(path),path);+ Assert.True(authored.IsSuccess,string.Join("; ",authored.Diagnostics.Select(x=>x.Code+":"+x.Message)));+ var projection=ThinWallAnalysisAuthority.Project(authored.Part!,new(path,0,0,"SheetMetal LBracket"));+ Assert.True(projection.IsSuccess,string.Join("; ",projection.Diagnostics.Select(x=>x.Code+":"+x.Message)));+ var graph=projection.Graph!;+ Assert.Equal(ThinWallAnalysisSourceKind.NativeSheetMetal,graph.AnalysisSource);+ Assert.Equal(.0015,graph.ThicknessMeters,12);+ Assert.Equal(2,graph.PanelPatchCount);+ Assert.Equal(1,graph.BendPatchCount);+ Assert.Equal(2,graph.Interfaces.Count);+ Assert.All(graph.Interfaces,x=>Assert.InRange(x.MaximumMismatchMeters,0,1e-10));+ var bend=graph.Patches.Single(x=>x.Kind==MidsurfacePatchKind.CylindricalBend);+ Assert.Equal(.00275,bend.SurfaceMap.RadiusMeters,12);+ Assert.Equal(Math.PI/2,Math.Abs(bend.SurfaceMap.AngleRadians),12);+ foreach(var point in new[]{(R:0d,S:0d),(R:bend.ParameterDomain.Bounds.Max.X,S:0d),(R:0d,S:bend.ParameterDomain.Bounds.Max.Y),(R:bend.ParameterDomain.Bounds.Max.X,S:bend.ParameterDomain.Bounds.Max.Y)})+ {+ var mapped=ThinWallAnalysisAuthority.Evaluate(bend,point.R,point.S,0);+ Assert.True(mapped.DerivativeR.Cross(mapped.DerivativeS).Dot(mapped.DerivativeT)>0);+ }+ }++ 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/Aetheris.FEA.csproj b/Aetheris.FEA/Aetheris.FEA.csprojindex 6adde57d..3cd09c09 100644--- a/Aetheris.FEA/Aetheris.FEA.csproj+++ b/Aetheris.FEA/Aetheris.FEA.csproj@@ -11,5 +11,6 @@<ProjectReference Include="..\Aetheris.Semantics\Aetheris.Semantics.csproj" /><ProjectReference Include="..\Aetheris.Kernel.Firmament\Aetheris.Kernel.Firmament.csproj" /><ProjectReference Include="..\Aetheris.Kernel.StandardLibrary\Aetheris.Kernel.StandardLibrary.csproj" />+ <ProjectReference Include="..\Aetheris.SheetMetal\Aetheris.SheetMetal.csproj" /></ItemGroup></Project>diff --git a/Aetheris.FEA/Analysis/AnalysisIr.cs b/Aetheris.FEA/Analysis/AnalysisIr.csindex 6d0f9a6d..7db110c8 100644--- a/Aetheris.FEA/Analysis/AnalysisIr.cs+++ b/Aetheris.FEA/Analysis/AnalysisIr.cs@@ -11,7 +11,7 @@ public enum ThinWallGeometryMapKind { Flat, Cylindrical }public enum AnalysisResultField { Displacement, Strain, Stress, ReactionForce, StrainEnergy }public enum BoundaryLoadKind { Traction, ResultantForce, Pressure }public enum LoadDistributionPolicy { TotalResultantOverSelectedArea, TractionPerUnitArea, PressureNormalToSurface }-public enum AnalysisGeometrySourceKind { FirmamentNative, InlineStep }+public enum AnalysisGeometrySourceKind { FirmamentNative, InlineStep, NativeSheetMetal }public enum DisplacementComponent { X, Y, Z }public sealed record AnalysisProvenance(@@ -62,6 +62,12 @@ public sealed record BoundaryLoadIr(AnalysisProvenance Provenance,LoadDistributionPolicy Distribution = LoadDistributionPolicy.TotalResultantOverSelectedArea);+/// <summary>A uniform acceleration applied to the physical material volume.</summary>+public sealed record BodyForceIr(+ string Id,+ Vector3D AccelerationMetersPerSecondSquared,+ AnalysisProvenance Provenance);+public sealed record AnalysisBodyIr(string Id,string SourceKind,@@ -111,7 +117,9 @@ public sealed record LinearElasticAnalysisIr(LatticeSpec Lattice,AnalysisProvenance Provenance,AnalysisMode Mode = AnalysisMode.ProductionSolid,- ExperimentalShellSettings? ExperimentalShell = null);+ ExperimentalShellSettings? ExperimentalShell = null,+ MidsurfacePatchGraph? MidsurfacePatchGraph = null,+ IReadOnlyList<BodyForceIr>? BodyForces = null);public enum AnalysisDiagnosticSeverity { Info, Warning, Error }public sealed record AnalysisDiagnostic(string Code, AnalysisDiagnosticSeverity Severity, string Message, AnalysisProvenance? Provenance = null);@@ -142,6 +150,16 @@ public static class AnalysisIrValidatordiagnostics.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));+ foreach(var load in analysis.BodyForces??[])+ {+ var acceleration=load.AccelerationMetersPerSecondSquared;+ if(!double.IsFinite(acceleration.X)||!double.IsFinite(acceleration.Y)||!double.IsFinite(acceleration.Z))+ diagnostics.Add(Error("fea-invalid-body-force",$"Body force '{load.Id}' contains a non-finite or unit-incompatible acceleration.",load.Provenance));+ if(analysis.Materials.Any(material=>material.DensityKilogramsPerCubicMeter is null or <=0))+ diagnostics.Add(Error("fea-body-force-density-missing",$"Body force '{load.Id}' requires a finite positive material density.",load.Provenance));+ }+ if(analysis.Mode!=AnalysisMode.ExperimentalShell&&(analysis.BodyForces?.Count??0)>0)+ diagnostics.Add(Error("fea-body-force-mode-unsupported","BodyForce is currently qualified only for ExperimentalShell.",analysis.Provenance));if(analysis.Mode==AnalysisMode.ExperimentalShell){var shell=analysis.ExperimentalShell;diff --git a/Aetheris.FEA/Analysis/ThinWallAnalysisAuthority.cs b/Aetheris.FEA/Analysis/ThinWallAnalysisAuthority.csnew file mode 100644index 00000000..29a09153--- /dev/null+++ b/Aetheris.FEA/Analysis/ThinWallAnalysisAuthority.cs@@ -0,0 +1,283 @@+using Aetheris.Continuum.Cir;+using Aetheris.Kernel.Core.Math;+using Aetheris.Kernel.Firmament.Materializer;+using Aetheris.SheetMetal;+using Aetheris.FEA.Mechanics;++namespace Aetheris.FEA.Analysis;++public enum ThinWallAnalysisSourceKind { Synthetic, NativeSheetMetal }+public enum MidsurfacePatchKind { PlanarPanel, CylindricalBend }+public enum MidsurfacePatchEdge { RMinimum, RMaximum, SMinimum, SMaximum }+public enum PatchInterfaceOrientation { Same, Reversed }++/// <summary>Analytic surface data projected from product authority; all lengths are SI.</summary>+public sealed record MidsurfaceSurfaceMap(+ MidsurfacePatchKind Kind,+ Point3D Origin,+ Vector3D AxisR,+ Vector3D AxisS,+ Vector3D MaterialNormal,+ double RadiusMeters = 0,+ double AngleRadians = 0);++public sealed record MidsurfacePatch(+ string Identity,+ MidsurfacePatchKind Kind,+ MidsurfaceSurfaceMap SurfaceMap,+ IContinuumRegion ParameterDomain,+ double ThicknessMeters,+ string Material,+ int OpeningCount,+ string SourceAuthority);++public sealed record MidsurfacePatchInterface(+ string Identity,+ string PatchA,+ MidsurfacePatchEdge EdgeA,+ string PatchB,+ MidsurfacePatchEdge EdgeB,+ PatchInterfaceOrientation Orientation,+ Point3D StartMeters,+ Point3D EndMeters,+ double MaximumMismatchMeters,+ string SemanticBendId);++/// <summary>Read-only analysis projection. SheetMetalPartIr remains the product geometry authority.</summary>+public sealed record MidsurfacePatchGraph(+ ThinWallAnalysisSourceKind AnalysisSource,+ string SheetMetalBody,+ double ThicknessMeters,+ string Material,+ IReadOnlyList<MidsurfacePatch> Patches,+ IReadOnlyList<MidsurfacePatchInterface> Interfaces,+ int OpeningCount,+ string SourceAuthority)+{+ public int PanelPatchCount => Patches.Count(x => x.Kind == MidsurfacePatchKind.PlanarPanel);+ public int BendPatchCount => Patches.Count(x => x.Kind == MidsurfacePatchKind.CylindricalBend);+}++public sealed record ThinWallAuthorityProjection(MidsurfacePatchGraph? Graph,IReadOnlyList<AnalysisDiagnostic> Diagnostics)+{+ public bool IsSuccess => Graph is not null && Diagnostics.All(x => x.Severity != AnalysisDiagnosticSeverity.Error);+}++public static class ThinWallAnalysisAuthority+{+ private const double MillimetersToMeters = .001;+ private const double CoincidenceToleranceMeters = 1e-8;++ public static ThinWallAuthorityProjection Project(SheetMetalPartIr part,AnalysisProvenance provenance)+ {+ ArgumentNullException.ThrowIfNull(part);+ var diagnostics=new List<AnalysisDiagnostic>();+ AnalysisDiagnostic Error(string code,string message)=>new(code,AnalysisDiagnosticSeverity.Error,message,provenance);+ if(part.RecognitionStatus!=SheetMetalRecognitionStatus.Complete)+ diagnostics.Add(Error("thinwall-sheetmetal-incomplete","Native sheet-metal analysis requires Complete semantic SheetMetal authority."));+ if(!part.Provenance.Contains("Authored",StringComparison.OrdinalIgnoreCase))+ diagnostics.Add(Error("thinwall-sheetmetal-source-unsupported","X1 admits authored native SheetMetal AIR only; recovered or reconstructed BRep evidence is not analysis authority."));+ if(!double.IsFinite(part.Thickness)||part.Thickness<=0)+ diagnostics.Add(Error("thinwall-thickness-invalid","Native SheetMetal thickness must be finite and positive."));+ if(string.IsNullOrWhiteSpace(part.Material))+ diagnostics.Add(Error("fea-missing-material","Native SheetMetal has no semantic material assignment."));+ if(diagnostics.Count>0)return new(null,diagnostics);++ var thickness=part.Thickness*MillimetersToMeters;+ var patches=new List<MidsurfacePatch>();+ foreach(var region in part.Regions.OrderBy(x=>x.StableId,StringComparer.Ordinal))+ {+ switch(region.Kind)+ {+ case SheetRegionKind.Planar when region.Plane is not null:+ patches.Add(ProjectPlanar(part,region,thickness,part.Material!));+ break;+ case SheetRegionKind.CylindricalBend when region.Cylinder is not null:+ try{patches.Add(ProjectCylinder(part,region,thickness,part.Material!));}+ catch(InvalidOperationException ex){diagnostics.Add(Error("thinwall-sheetmetal-cylinder-invalid",$"Patch '{region.StableId}' cannot be parameterized: {ex.Message}"));}+ break;+ default:+ diagnostics.Add(Error("thinwall-sheetmetal-region-unsupported",$"Sheet region '{region.StableId}' has unsupported kind '{region.Kind}' or incomplete analytic surface authority."));+ break;+ }+ }+ if(diagnostics.Count>0)return new(null,diagnostics);++ var interfaces=new List<MidsurfacePatchInterface>();+ foreach(var bend in part.Bends.OrderBy(x=>x.StableId,StringComparer.Ordinal))+ {+ var bendRegionId=(part.Correspondence??[]).SingleOrDefault(x=>x.Kind.Equals("Bend",StringComparison.OrdinalIgnoreCase)&&x.SemanticId.Equals(bend.StableId,StringComparison.Ordinal))?.FormedId;+ if(string.IsNullOrWhiteSpace(bendRegionId))+ {+ diagnostics.Add(Error("thinwall-sheetmetal-adjacency-invalid",$"Bend '{bend.StableId}' has no exact semantic bend-region correspondence."));continue;+ }+ var bendPatch=patches.SingleOrDefault(x=>x.Identity==bendRegionId);+ var panelA=patches.SingleOrDefault(x=>x.Identity==bend.AdjacentRegionA);+ var panelB=patches.SingleOrDefault(x=>x.Identity==bend.AdjacentRegionB);+ if(bendPatch is null||panelA is null||panelB is null)+ {+ diagnostics.Add(Error("thinwall-sheetmetal-adjacency-invalid",$"Bend '{bend.StableId}' adjacency does not resolve to its two planar patches and cylindrical patch."));continue;+ }+ AddInterface(bend,bendPatch,MidsurfacePatchEdge.SMinimum,panelA,"A");+ AddInterface(bend,bendPatch,MidsurfacePatchEdge.SMaximum,panelB,"B");+ }+ if(diagnostics.Count>0)return new(null,diagnostics);+ var graph=new MidsurfacePatchGraph(ThinWallAnalysisSourceKind.NativeSheetMetal,part.StableId,thickness,part.Material!,patches,interfaces,part.Features.Count,+ "SheetMetalPartIr semantic AIR; geometric midsurface t/2; no BRep reverse engineering; manufacturing neutral-axis policy excluded");+ return new(graph,diagnostics);++ void AddInterface(SheetBendIr bend,MidsurfacePatch bendPatch,MidsurfacePatchEdge bendEdge,MidsurfacePatch panel,string suffix)+ {+ var b=EdgeEndpoints(bendPatch,bendEdge);var candidates=Enum.GetValues<MidsurfacePatchEdge>().Select(edge=>(Edge:edge,Ends:EdgeEndpoints(panel,edge))).ToArray();+ var selected=candidates.Select(x=>+ {+ var same=double.Max(Distance(b.Start,x.Ends.Start),Distance(b.End,x.Ends.End));+ var reversed=double.Max(Distance(b.Start,x.Ends.End),Distance(b.End,x.Ends.Start));+ return(x.Edge,Orientation:same<=reversed?PatchInterfaceOrientation.Same:PatchInterfaceOrientation.Reversed,Mismatch:double.Min(same,reversed));+ }).OrderBy(x=>x.Mismatch).First();+ if(selected.Mismatch>CoincidenceToleranceMeters)+ {+ diagnostics.Add(Error("thinwall-sheetmetal-interface-mismatch",$"Bend '{bend.StableId}' and panel '{panel.Identity}' do not share the same midsurface curve; mismatch {selected.Mismatch:R} m."));return;+ }+ interfaces.Add(new($"{bend.StableId}.{suffix}",bendPatch.Identity,bendEdge,panel.Identity,selected.Edge,selected.Orientation,b.Start,b.End,selected.Mismatch,bend.StableId));+ }+ }++ public static (Point3D Start,Point3D End) EdgeEndpoints(MidsurfacePatch patch,MidsurfacePatchEdge edge)+ {+ var b=patch.ParameterDomain.Bounds;+ return edge switch+ {+ MidsurfacePatchEdge.RMinimum=>(Evaluate(patch,b.Min.X,b.Min.Y,0).Position,Evaluate(patch,b.Min.X,b.Max.Y,0).Position),+ MidsurfacePatchEdge.RMaximum=>(Evaluate(patch,b.Max.X,b.Min.Y,0).Position,Evaluate(patch,b.Max.X,b.Max.Y,0).Position),+ MidsurfacePatchEdge.SMinimum=>(Evaluate(patch,b.Min.X,b.Min.Y,0).Position,Evaluate(patch,b.Max.X,b.Min.Y,0).Position),+ _=>(Evaluate(patch,b.Min.X,b.Max.Y,0).Position,Evaluate(patch,b.Max.X,b.Max.Y,0).Position)+ };+ }++ public static ThinWallMapEvaluation Evaluate(MidsurfacePatch patch,double r,double s,double t)+ {+ var m=patch.SurfaceMap;var half=patch.ThicknessMeters/2;+ if(m.Kind==MidsurfacePatchKind.PlanarPanel)+ return new(m.Origin+m.AxisR*r+m.AxisS*s,m.AxisR,m.AxisS,m.MaterialNormal*half);+ var sign=m.AngleRadians.Sign();var theta=s/m.RadiusMeters;var radial=m.AxisS*double.Cos(theta)+m.AxisR.Cross(m.AxisS)*(sign*double.Sin(theta));+ // AxisS is the geometric start radial. MaterialNormal may be its negative;+ // rotating both by the same signed angular direction preserves material side.+ var tangent=m.AxisR.Cross(radial)*sign;+ var normal0=m.MaterialNormal;var normal=normal0*double.Cos(theta)+m.AxisR.Cross(normal0)*(sign*double.Sin(theta));var tangentNormal=m.AxisR.Cross(normal)*sign;+ var current=m.RadiusMeters*radial+t*half*normal;+ return new(m.Origin+m.AxisR*r+current,m.AxisR,tangent+(t*half/m.RadiusMeters)*tangentNormal,normal*half);+ }++ private static MidsurfacePatch ProjectPlanar(SheetMetalPartIr part,SheetRegionIr region,double thickness,string material)+ {+ var p=region.Plane!;var u=Unit(p.UAxis);var v=Unit(p.VAxis);var n=Unit(p.Normal);var rSign=u.Cross(v).Dot(n)>=0?1d:-1d;+ var local=region.Boundary3D.Select(x=>(R:(x-p.Origin).Dot(u)*rSign*MillimetersToMeters,S:(x-p.Origin).Dot(v)*MillimetersToMeters)).ToArray();+ var bounds=new BoundingBox3D(new(local.Min(x=>x.R),local.Min(x=>x.S),-1),new(local.Max(x=>x.R),local.Max(x=>x.S),1));+ var contours=new List<ResolvedProfile2D>();+ if(region.ExactContour is not null)contours.Add(PlanarContourKernel.ToResolvedProfile(region.ExactContour,region.StableId));+ var features=part.Features.Where(x=>x.OwningRegionId==region.StableId).OrderBy(x=>x.StableId,StringComparer.Ordinal).ToArray();+ foreach(var feature in features)+ {+ if(feature.ExactContour is not null)contours.Add(PlanarContourKernel.ToResolvedProfile(feature.ExactContour,feature.StableId));+ else if(feature.Kind==SheetFeatureKind.CircularHole&&feature.Diameter is { } diameter)+ contours.Add(CircleProfile(feature.StableId,((feature.Center-p.Origin).Dot(u),(feature.Center-p.Origin).Dot(v)),diameter/2));+ }+ IContinuumRegion domain=contours.Count==0+ ?new PolygonParameterRegion(new(region.StableId+":parameter"),bounds,region.Boundary3D.Select(x=>((x-p.Origin).Dot(u),(x-p.Origin).Dot(v))).ToArray(),[],MillimetersToMeters,rSign)+ :new PolygonParameterRegion(new(region.StableId+":parameter"),bounds,null,contours,MillimetersToMeters,rSign);+ return new(region.StableId,MidsurfacePatchKind.PlanarPanel,new(MidsurfacePatchKind.PlanarPanel,Scale(p.Origin),u*rSign,v,n),domain,thickness,material,features.Length,"SheetRegionIr.Plane + exact semantic contour/features");+ }++ private static MidsurfacePatch ProjectCylinder(SheetMetalPartIr part,SheetRegionIr region,double thickness,string material)+ {+ if(region.Boundary3D.Count!=4)throw new InvalidOperationException("cylindrical bend boundary must contain four semantic corners");+ var c=region.Cylinder!;var length=c.AxisLength*MillimetersToMeters;var radius=c.GeometricMidRadius*MillimetersToMeters;+ if(radius<=thickness/2||length<=0||c.AngularSpanRadians<=0)throw new InvalidOperationException("radius, span, and axial length must be positive");+ var panelA=part.Bends.SingleOrDefault(x=>(part.Correspondence??[]).Any(y=>y.Kind=="Bend"&&y.SemanticId==x.StableId&&y.FormedId==region.StableId)) is { } bend+ ?part.Regions.SingleOrDefault(x=>x.StableId==bend.AdjacentRegionA):null;+ if(panelA?.Plane is null)throw new InvalidOperationException("material-normal orientation cannot be obtained from the semantic parent panel");+ var normal=Unit(panelA.Plane.Normal);var center=Scale(c.AxisOrigin);var originalAxis=Unit(c.AxisDirection);+ var corners=region.Boundary3D.Select(Scale).ToArray();+ foreach(var reverseAxis in new[]{false,true})+ {+ var axis=reverseAxis?-originalAxis:originalAxis;var start=reverseAxis?corners[1]:corners[0];var end=reverseAxis?corners[2]:corners[3];+ var axisOrigin=center-axis*(length/2);var radial=Unit(start-axisOrigin);var target=Unit(end-axisOrigin);+ foreach(var sign in new[]{1d,-1d})+ {+ var predicted=radial*double.Cos(c.AngularSpanRadians)+axis.Cross(radial)*(sign*double.Sin(c.AngularSpanRadians));+ if((predicted-target).Length>1e-7)continue;+ var tangent=axis.Cross(radial)*sign;+ if(axis.Cross(tangent).Dot(normal)<=0)continue;+ var bounds=new BoundingBox3D(new(0,0,-1),new(length,radius*c.AngularSpanRadians,1));+ var domain=new Aetheris.Continuum.Regions.Analytic.AxisAlignedBoxRegion(new(region.StableId+":parameter"),bounds);+ return new(region.StableId,MidsurfacePatchKind.CylindricalBend,new(MidsurfacePatchKind.CylindricalBend,axisOrigin,axis,radial,normal,radius,sign*c.AngularSpanRadians),domain,thickness,material,0,"SheetRegionIr.Cylinder.GeometricMidRadius + semantic bend boundary");+ }+ }+ throw new InvalidOperationException("semantic bend corners, axis, angle, and parent material normal do not define a positive analytic map");+ }++ private static ResolvedProfile2D CircleProfile(string id,(double X,double Y) center,double radius)+ {+ var provenance=new ProfileSegmentProvenance(id,id,id,"SheetMetal semantic circular opening","SheetRegionLocal[u,v]");+ return new(id,"SheetRegionLocal[u,v]",[new(id+".loop",false,[new(id,new LineArcFullCircle2D(center,radius),provenance)])]);+ }+ private static Point3D Scale(Point3D value)=>new(value.X*MillimetersToMeters,value.Y*MillimetersToMeters,value.Z*MillimetersToMeters);+ private static Vector3D Unit(Vector3D value){var l=value.Length;if(!double.IsFinite(l)||l<=0)throw new InvalidOperationException("zero or nonfinite direction");return value*(1/l);}+ private static double Distance(Point3D a,Point3D b)=>(a-b).Length;+ private static double Sign(this double value)=>value<0?-1:1;+}++internal sealed class PolygonParameterRegion : IContinuumRegion,IBoundsClassificationCapability+{+ private readonly IReadOnlyList<(double X,double Y)>? polygonMillimeters;+ private readonly IReadOnlyList<ResolvedProfile2D> profiles;+ private readonly double scale;+ private readonly double rSign;+ public PolygonParameterRegion(RegionId id,BoundingBox3D bounds,IReadOnlyList<(double X,double Y)>? polygonMillimeters,IReadOnlyList<ResolvedProfile2D> profiles,double scale,double rSign)+ {Id=id;Bounds=bounds;this.polygonMillimeters=polygonMillimeters;this.profiles=profiles;this.scale=scale;this.rSign=rSign;}+ public RegionId Id { get; }+ public BoundingBox3D Bounds { get; }+ public ContinuumPointClassification Classify(Point3D point,double tolerance=1e-9)+ {+ if(point.X<Bounds.Min.X-tolerance||point.X>Bounds.Max.X+tolerance||point.Y<Bounds.Min.Y-tolerance||point.Y>Bounds.Max.Y+tolerance)return ContinuumPointClassification.Outside;+ var p=(point.X/scale*rSign,point.Y/scale);+ if(profiles.Count>0)+ {+ var outer=ProfileArrangementBuilder.PointInProfile(profiles[0],p);if(outer==ArrangementPointLocation.Outside)return ContinuumPointClassification.Outside;+ if(profiles.Skip(1).Any(x=>ProfileArrangementBuilder.PointInProfile(x,p)!=ArrangementPointLocation.Outside))return ContinuumPointClassification.Outside;+ return outer==ArrangementPointLocation.OnBoundary?ContinuumPointClassification.Boundary:ContinuumPointClassification.Inside;+ }+ var inside=false;var poly=polygonMillimeters!;+ for(var i=0;i<poly.Count;i++)if(DistanceToSegment(p,poly[i],poly[(i+1)%poly.Count])<=tolerance/scale)return ContinuumPointClassification.Boundary;+ for(int i=0,j=poly.Count-1;i<poly.Count;j=i++)if((poly[i].Y>p.Item2)!=(poly[j].Y>p.Item2)&&p.Item1<(poly[j].X-poly[i].X)*(p.Item2-poly[i].Y)/(poly[j].Y-poly[i].Y)+poly[i].X)inside=!inside;+ return inside?ContinuumPointClassification.Inside:ContinuumPointClassification.Outside;+ }+ public ContinuumBoundsClassification ClassifyBounds(BoundingBox3D bounds,double tolerance=1e-9)+ {+ if(bounds.Max.X<Bounds.Min.X||bounds.Min.X>Bounds.Max.X||bounds.Max.Y<Bounds.Min.Y||bounds.Min.Y>Bounds.Max.Y)return ContinuumBoundsClassification.Outside;+ var points=new[]{new Point3D(bounds.Min.X,bounds.Min.Y,0),new(bounds.Max.X,bounds.Min.Y,0),new(bounds.Max.X,bounds.Max.Y,0),new(bounds.Min.X,bounds.Max.Y,0),new((bounds.Min.X+bounds.Max.X)/2,(bounds.Min.Y+bounds.Max.Y)/2,0)};+ var states=points.Select(x=>Classify(x,tolerance)).ToArray();+ // Boundary-free rectangles are the common panel case. Profile-bearing cells+ // remain conservatively cut near the exact line/arc boxes.+ if(states.All(x=>x==ContinuumPointClassification.Inside)&&!MayMeetBoundary(bounds))return ContinuumBoundsClassification.Inside;+ if(states.All(x=>x==ContinuumPointClassification.Outside)&&!MayMeetBoundary(bounds))return ContinuumBoundsClassification.Outside;+ return ContinuumBoundsClassification.Cut;+ }+ private bool MayMeetBoundary(BoundingBox3D box)+ {+ if(profiles.Count==0){var polygon=polygonMillimeters!;return polygon.Zip(polygon.Skip(1).Append(polygon[0]),(a,b)=>(a,b)).Any(x=>Overlaps(box,x.a.X*scale*rSign,x.a.Y*scale,x.b.X*scale*rSign,x.b.Y*scale));}+ return profiles.SelectMany(x=>x.Loops).SelectMany(x=>x.Segments).Any(segment=>+ {+ var g=segment.Geometry;return g switch+ {+ LineArcLineSegment2D line=>Overlaps(box,line.Start.X*scale*rSign,line.Start.Y*scale,line.End.X*scale*rSign,line.End.Y*scale),+ LineArcCircularArc2D arc=>Overlaps(box,(arc.Center.X-arc.Radius)*scale*rSign,(arc.Center.Y-arc.Radius)*scale,(arc.Center.X+arc.Radius)*scale*rSign,(arc.Center.Y+arc.Radius)*scale),+ LineArcFullCircle2D circle=>Overlaps(box,(circle.Center.X-circle.Radius)*scale*rSign,(circle.Center.Y-circle.Radius)*scale,(circle.Center.X+circle.Radius)*scale*rSign,(circle.Center.Y+circle.Radius)*scale),+ _=>true+ };+ });+ }+ private static bool Overlaps(BoundingBox3D b,double x0,double y0,double x1,double y1)=>double.Max(x0,x1)>=b.Min.X&&double.Min(x0,x1)<=b.Max.X&&double.Max(y0,y1)>=b.Min.Y&&double.Min(y0,y1)<=b.Max.Y;+ private static double DistanceToSegment((double X,double Y) p,(double X,double Y) a,(double X,double Y) b){var dx=b.X-a.X;var dy=b.Y-a.Y;var d=dx*dx+dy*dy;if(d==0)return double.Sqrt((p.X-a.X)*(p.X-a.X)+(p.Y-a.Y)*(p.Y-a.Y));var t=double.Clamp(((p.X-a.X)*dx+(p.Y-a.Y)*dy)/d,0,1);var x=a.X+t*dx;var y=a.Y+t*dy;return double.Sqrt((p.X-x)*(p.X-x)+(p.Y-y)*(p.Y-y));}+}diff --git a/Aetheris.FEA/Firmament/FirmamentAnalysisCompiler.cs b/Aetheris.FEA/Firmament/FirmamentAnalysisCompiler.csindex dab88f49..838a5bec 100644--- a/Aetheris.FEA/Firmament/FirmamentAnalysisCompiler.cs+++ b/Aetheris.FEA/Firmament/FirmamentAnalysisCompiler.cs@@ -13,6 +13,7 @@ using Aetheris.Kernel.Core.Topology;using Aetheris.Semantics;using Aetheris.Kernel.StandardLibrary.Materials;using Aetheris.FEA.Geometry;+using Aetheris.SheetMetal;using System.Security.Cryptography;using System.Text;@@ -35,12 +36,29 @@ public static class FirmamentAnalysisCompilervar 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 modeText=Scalar(block,"mode")??nameof(AnalysisMode.ProductionSolid);+ if(!Enum.TryParse<AnalysisMode>(modeText,true,out var mode)){diagnostics.Add(Error("fea-analysis-mode-invalid",$"Analysis mode '{modeText}' is unsupported.",sourcePath));return Done(null,diagnostics,started);}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);+ 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);MidsurfacePatchGraph? midsurfacePatchGraph=null;SheetMetalPartIr? sheetMetalPart=null;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||inlineCall.Success)+ if(SheetMetalFirmament.LooksLikeSheetMetal(stripped))+ {+ if(mode!=AnalysisMode.ExperimentalShell){diagnostics.Add(Error("thinwall-mode-required","Native SheetMetal analysis requires explicit Mode: ExperimentalShell.",sourcePath));return Done(null,diagnostics,started);}+ var authored=SheetMetalFirmament.Compile(stripped,sourcePath??"<memory>");+ if(!authored.IsSuccess||authored.Part is null){diagnostics.AddRange(authored.Diagnostics.Select(x=>new AnalysisDiagnostic(x.Code,AnalysisDiagnosticSeverity.Error,x.Message,analysisSpan)));return Done(null,diagnostics,started);}+ sheetMetalPart=authored.Part;bodyId=bodyName;sourceKind=nameof(AnalysisGeometrySourceKind.NativeSheetMetal);+ var expectedBody=sheetMetalPart.StableId.StartsWith("sheetmetal-",StringComparison.Ordinal)?sheetMetalPart.StableId[11..]:sheetMetalPart.StableId;+ if(!bodyId.Equals(expectedBody,StringComparison.Ordinal)){diagnostics.Add(Error("thinwall-sheetmetal-body-mismatch",$"Analysis Body '{bodyId}' does not name native SheetMetal body '{expectedBody}'.",sourcePath));return Done(null,diagnostics,started);}+ var projected=ThinWallAnalysisAuthority.Project(sheetMetalPart,analysisSpan);diagnostics.AddRange(projected.Diagnostics);+ if(!projected.IsSuccess)return Done(null,diagnostics,started);+ midsurfacePatchGraph=projected.Graph;+ var combined=midsurfacePatchGraph!.Patches.Select(x=>x.ParameterDomain.Bounds).ToArray();+ var maxR=combined.Max(x=>x.Max.X-x.Min.X);var maxS=combined.Max(x=>x.Max.Y-x.Min.Y);+ region=new AxisAlignedBoxRegion(new RegionId(bodyId+":sheetmetal-analysis-projection"),new(new(0,0,-1),new(maxR,maxS,1)));+ }+ else if(resourceName.Length>0||directInline is not null||inlineCall.Success){bodyId=bodyName.Length>0?bodyName:resourceName;sourceKind="InlineStep";FirmamentAnalysisResource resource;@@ -149,7 +167,7 @@ public static class FirmamentAnalysisCompilerbodyId=bodyName;sourceKind="FirmamentNative";}var materialBlock=Nested(block,"material",out var materialName,out var materialStart);- var materialReference=materialBlock is null?Scalar(block,"material"):null;+ var materialReference=materialBlock is null?(Scalar(block,"material")??sheetMetalPart?.Material):null;if(materialBlock is null&&string.IsNullOrWhiteSpace(materialReference)){diagnostics.Add(Error("fea-missing-material","Analysis has no material declaration or catalog material reference.",sourcePath));return Done(null,diagnostics,started);}LinearElasticMaterialIr material;if(materialBlock is not null)@@ -162,7 +180,7 @@ public static class FirmamentAnalysisCompiler{materialReference=materialReference!.Trim();var referenceOffset=block.IndexOf(materialReference,StringComparison.Ordinal);var materialProv=new AnalysisProvenance(sourcePath??"<memory>",open+1+referenceOffset,materialReference.Length,"material: "+materialReference);- var resolution=(materialResolver??new MaterialResolver()).Resolve(materialReference);+ var materialLookup=sheetMetalPart is null?materialReference:NativeSheetMetalMaterialReference(materialReference);var resolution=(materialResolver??new MaterialResolver()).Resolve(materialLookup);if(!resolution.IsSuccess){var code=resolution.Error switch{MaterialResolutionError.UnknownMaterial=>"firmament-material-unknown",MaterialResolutionError.AmbiguousMaterial=>"firmament-material-ambiguous",MaterialResolutionError.MissingRequiredStructuralProperty=>"fea-material-missing-structural-properties",_=>"firmament-material-invalid"};@@ -174,6 +192,14 @@ public static class FirmamentAnalysisCompiler}(SemanticRegionBinding? Region,AnalysisDiagnostic? Diagnostic) NormalizeRegion(string path,AnalysisProvenance provenance){+ if(midsurfacePatchGraph is not null)+ {+ var prefix=bodyId+".";var relative=path.StartsWith(prefix,StringComparison.Ordinal)?path[prefix.Length..]:path;+ var split=relative.LastIndexOf('.');+ if(split>0&&midsurfacePatchGraph.Patches.Any(x=>x.Identity.Equals(relative[..split],StringComparison.Ordinal))&&TryPatchEdge(relative[(split+1)..],out _))+ return(new(bodyId,path,Provenance:provenance,SemanticStableId:relative,CapabilityEvidence:["NativeSheetMetal","ExactPatchEdge"],ExactBindingKind:"MidsurfacePatchEdge"),null);+ return(null,new("thinwall-sheetmetal-boundary-unknown",AnalysisDiagnosticSeverity.Error,$"Native SheetMetal boundary '{path}' must identify an exact patch edge as '<Body>.<Patch>.r-min|r-max|s-min|s-max'.",provenance));+ }if(namedRegions.TryGetValue(path,out var semantic)){var span=new SemanticSourceSpan(provenance.Source,provenance.Start,provenance.Length);var normalized=AnalysisSemanticRegionNormalizer.Normalize(new(semantic,[new(path,span)],span));@@ -196,16 +222,20 @@ public static class FirmamentAnalysisCompilervar 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 bodyForces=new List<BodyForceIr>();+ foreach(var nested in NestedAll(block,"BodyForce"))+ {+ var prov=new AnalysisProvenance(sourcePath??"<memory>",open+nested.Start,nested.Length,"BodyForce "+nested.Name);+ bodyForces.Add(new(nested.Name,Acceleration(Scalar(nested.Body,"acceleration")),prov));+ }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 modeText=Scalar(block,"mode")??nameof(AnalysisMode.ProductionSolid);- if(!Enum.TryParse<AnalysisMode>(modeText,true,out var mode)){diagnostics.Add(Error("fea-analysis-mode-invalid",$"Analysis mode '{modeText}' is unsupported.",sourcePath));return Done(null,diagnostics,started);}ExperimentalShellSettings? shellSettings=null;if(mode==AnalysisMode.ExperimentalShell){var thicknessText=Scalar(block,"thickness");- if(string.IsNullOrWhiteSpace(thicknessText)){diagnostics.Add(Error("thinwall-thickness-missing","ExperimentalShell requires an explicit Thickness for synthetic/native Box geometry in X0.",sourcePath));return Done(null,diagnostics,started);}+ if(string.IsNullOrWhiteSpace(thicknessText)&&sheetMetalPart is null){diagnostics.Add(Error("thinwall-thickness-missing","ExperimentalShell requires an explicit Thickness for synthetic/native Box geometry in X0.",sourcePath));return Done(null,diagnostics,started);}var masterValues=Numbers(Scalar(block,"masterGrid"));if(masterValues.Length!=2||masterValues.Any(value=>!double.IsInteger(value)||value<1)){diagnostics.Add(Error("thinwall-master-grid-invalid","ExperimentalShell MasterGrid must contain exactly two positive integer dimensions.",sourcePath));return Done(null,diagnostics,started);}var orderText=Scalar(block,"order");var order=OptionalInteger(orderText,3);@@ -215,16 +245,19 @@ public static class FirmamentAnalysisCompilervar mapText=Scalar(block,"geometryMap")??nameof(ThinWallGeometryMapKind.Flat);if(!Enum.TryParse<ThinWallGeometryMapKind>(mapText,true,out var map)){diagnostics.Add(Error("thinwall-geometry-unsupported",$"ExperimentalShell geometry map '{mapText}' is unsupported.",sourcePath));return Done(null,diagnostics,started);}var radiusText=Scalar(block,"cylinderRadius");var angleText=Scalar(block,"cylinderAngle");- shellSettings=new ExperimentalShellSettings(Length(thicknessText),order,(int)masterValues[0],(int)masterValues[1],alpha,depth,quadrature,map,+ var resolvedThickness=sheetMetalPart is null?Length(thicknessText):sheetMetalPart.Thickness*.001;+ shellSettings=new ExperimentalShellSettings(resolvedThickness,order,(int)masterValues[0],(int)masterValues[1],alpha,depth,quadrature,map,string.IsNullOrWhiteSpace(radiusText)?null:Length(radiusText),string.IsNullOrWhiteSpace(angleText)?null:Angle(angleText));lattice=new LatticeSpec(region.Bounds,shellSettings.MasterCellsR,shellSettings.MasterCellsS,1);- var sourceThickness=region.Bounds.Max.Z-region.Bounds.Min.Z;+ var sourceThickness=sheetMetalPart is null?region.Bounds.Max.Z-region.Bounds.Min.Z:sheetMetalPart.Thickness*.001;if(double.IsFinite(shellSettings.ThicknessMeters)&&double.Abs(sourceThickness-shellSettings.ThicknessMeters)>double.Max(1e-12,sourceThickness*1e-9))diagnostics.Add(Error("thinwall-thickness-source-mismatch",$"ExperimentalShell Thickness ({shellSettings.ThicknessMeters:R} m) must match the native/synthetic body's semantic thickness ({sourceThickness:R} m) in X0.",sourcePath));+ if(sheetMetalPart is not null&&!string.IsNullOrWhiteSpace(thicknessText)&&double.Abs(Length(thicknessText)-sourceThickness)>double.Max(1e-12,sourceThickness*1e-9))+ diagnostics.Add(Error("thinwall-thickness-source-mismatch",$"Analysis Thickness must not override native SheetMetal thickness {sourceThickness:R} m.",sourcePath));}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,mode,shellSettings);+ 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,mode,shellSettings,midsurfacePatchGraph,bodyForces);diagnostics.AddRange(AnalysisIrValidator.Validate(ir));return Done(ir,diagnostics,started);}@@ -243,7 +276,14 @@ public static class FirmamentAnalysisCompilerprivate 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;}private static double[] Numbers(string? text)=>Regex.Matches(text??"",@"[-+0-9.eE]+").Select(m=>Number(m.Value)).ToArray();private static Vector3D Vector(string? text,bool force){var parts=(text??"").Trim('[',']').Split(',',StringSplitOptions.TrimEntries);if(parts.Length!=3)return new(double.NaN,double.NaN,double.NaN);double Parse(string p){var m=Regex.Match(p,@"^(?<v>[-+0-9.eE]+)\s*(?<u>N|Pa)$",RegexOptions.IgnoreCase);return m.Success&&((force&&m.Groups["u"].Value.Equals("N",StringComparison.OrdinalIgnoreCase))||(!force&&m.Groups["u"].Value.Equals("Pa",StringComparison.OrdinalIgnoreCase)))?Number(m.Groups["v"].Value):double.NaN;}return new(Parse(parts[0]),Parse(parts[1]),Parse(parts[2]));}+ private static Vector3D Acceleration(string? text){var parts=(text??"").Trim('[',']').Split(',',StringSplitOptions.TrimEntries);if(parts.Length!=3)return new(double.NaN,double.NaN,double.NaN);double Parse(string p){var m=Regex.Match(p,@"^(?<v>[-+0-9.eE]+)\s*m/s(?:\^?2|²)$",RegexOptions.IgnoreCase);return m.Success?Number(m.Groups["v"].Value):double.NaN;}return new(Parse(parts[0]),Parse(parts[1]),Parse(parts[2]));}private static HashSet<DisplacementComponent> Components(string? text){var result=new HashSet<DisplacementComponent>();foreach(var item in (text??"").Trim('[',']').Split(',',StringSplitOptions.RemoveEmptyEntries|StringSplitOptions.TrimEntries))if(Enum.TryParse<DisplacementComponent>(item,true,out var value))result.Add(value);return result;}+ private static bool TryPatchEdge(string token,out MidsurfacePatchEdge edge)=>Enum.TryParse(token.Replace("-minimum","Minimum",StringComparison.OrdinalIgnoreCase).Replace("-maximum","Maximum",StringComparison.OrdinalIgnoreCase).Replace("-min","Minimum",StringComparison.OrdinalIgnoreCase).Replace("-max","Maximum",StringComparison.OrdinalIgnoreCase),true,out edge);+ private static string NativeSheetMetalMaterialReference(string reference)+ {+ if(reference.Contains("5052",StringComparison.OrdinalIgnoreCase)&&reference.Contains("H32",StringComparison.OrdinalIgnoreCase)&&(reference.Contains("Aluminum",StringComparison.OrdinalIgnoreCase)||reference.Contains("Aluminium",StringComparison.OrdinalIgnoreCase)))return "Standard.Materials.Aluminum.5052_H32";+ return reference;+ }private static FirmamentAnalysisCompilation Done(LinearElasticAnalysisIr? ir,IReadOnlyList<AnalysisDiagnostic> d,long started)=>new(ir,d,System.Diagnostics.Stopwatch.GetElapsedTime(started));private static AnalysisDiagnostic Error(string code,string message,string? source)=>new(code,AnalysisDiagnosticSeverity.Error,message,new(source??"<memory>",0,0,code));}diff --git a/Aetheris.FEA/Mechanics/LinearElasticSolver.cs b/Aetheris.FEA/Mechanics/LinearElasticSolver.csindex 02ddc15f..00c417b6 100644--- a/Aetheris.FEA/Mechanics/LinearElasticSolver.cs+++ b/Aetheris.FEA/Mechanics/LinearElasticSolver.cs@@ -15,7 +15,9 @@ public sealed record MechanicsSolveOptions(int? MaximumIterations = null,Transform3D? DomainTransform = null,bool PreserveNominalCellVolumeUnderTransform = false,- bool RetryEmptyCutCells = true);+ bool RetryEmptyCutCells = true,+ ExperimentalPreconditionerKind? ExperimentalPreconditioner = null,+ bool? ExperimentalSymmetricEquilibration = null);public static class LinearElasticSolver{diff --git a/Aetheris.FEA/Mechanics/MechanicsModels.cs b/Aetheris.FEA/Mechanics/MechanicsModels.csindex 3479b147..1eb8d974 100644--- a/Aetheris.FEA/Mechanics/MechanicsModels.cs+++ b/Aetheris.FEA/Mechanics/MechanicsModels.cs@@ -18,6 +18,7 @@ public sealed record MechanicsBoundaryQuadraturePlan(string RegionPath,string Bopublic int QuadraturePointCount=>Fragments.Sum(item=>item.Points.Count);}public sealed record BoundaryLoadEvidence(string LoadId,string RegionPath,string BoundaryId,string? ExactBrepFaceId,double ExactArea,double IntegratedArea,Vector3D ExpectedResultant,Vector3D IntegratedResultant,Vector3D ExpectedMoment,Vector3D IntegratedMoment,double ResultantResidual,double MomentResidual,int OwnedFragments,int QuadraturePoints,string MaterialSideEvidence);+public sealed record BodyLoadEvidence(string LoadId,Vector3D AccelerationMetersPerSecondSquared,double DensityKilogramsPerCubicMeter,double IntegratedVolumeCubicMeters,Vector3D IntegratedResultantNewton,Vector3D IntegratedMomentNewtonMeters,int QuadraturePoints,string IntegrationPolicy);public 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);@@ -26,7 +27,7 @@ public sealed record CellStrainResult(int I,int J,int K,Point3D Position,Symmetrpublic 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);+public sealed record SolverConvergence(bool Converged, int Iterations, double InitialResidual, double FinalResidual, IReadOnlyList<double> ResidualHistory, TimeSpan Runtime,IReadOnlyList<double>? PreconditionedResidualHistory=null);public sealed record MechanicsPerformance(TimeSpan DomainSetup,TimeSpan QuadratureSetup,TimeSpan Assembly,TimeSpan BoundaryAssembly,TimeSpan Solve,TimeSpan Recovery,long SparseBytes,long ResultBytes,@@ -37,6 +38,38 @@ public sealed record SparseSystemMetrics(int DegreesOfFreedom, int Nonzeros, doupublic sealed record EquilibriumResult(Vector3D AppliedForceNewton, Vector3D ReactionForceNewton, Vector3D ResidualNewton);public sealed record StrainEnergyConsistency(double AlgebraicJoule,double IntegratedContinuumJoule,double AbsoluteResidualJoule,double RelativeResidual);public sealed record ExactStressProbe(string Label,Point3D Position,SymmetricTensor StressPascal,double HoopStressPascal,double KirschReferencePascal,double AbsoluteErrorPascal,string ReferenceAssumptions);+public enum ExperimentalPreconditionerKind { Identity, Jacobi, BlockJacobi3, IncompleteCholeskyZero }+public sealed record ExperimentalLinearSolverEvidence(+ bool SymmetricDiagonalEquilibration,+ double MinimumScale,+ double MaximumScale,+ string Preconditioner,+ double DiagonalShift,+ int FactorizationRetries,+ TimeSpan PreconditionerBuildTime,+ string ConvergenceReason,+ int? StagnationOnsetIteration,+ double InitialSolverResidual,+ double FinalSolverResidual,+ double FinalPhysicalResidual,+ IReadOnlyList<double> SolverResidualHistory,+ string SelectionPolicy="Explicit",+ double? SelectedUtility=null,+ IReadOnlyList<string>? RejectedCandidates=null,+ IReadOnlyList<double>? PreconditionedResidualHistory=null);+public sealed record NativeSheetMetalShellEvidence(+ string AnalysisSource,+ string SheetMetalBody,+ string Material,+ int PatchCount,+ int PanelPatchCount,+ int BendPatchCount,+ int OpeningCount,+ int InterfaceCount,+ int SharedDisplacementDegreesOfFreedom,+ double MaximumInterfaceMismatchMeters,+ IReadOnlyList<string> PatchIdentities,+ IReadOnlyList<string> InterfaceOrientations);public sealed record ExperimentalShellEvidence(string Qualification,string GeometryMapType,@@ -57,7 +90,9 @@ public sealed record ExperimentalShellEvidence(double MinimumJacobianDeterminant,double MaximumJacobianDeterminant,IReadOnlyList<double> StressEvaluationThroughThicknessCoordinates,- string DeterministicDiscretizationHash);+ string DeterministicDiscretizationHash,+ ExperimentalLinearSolverEvidence? Solver=null,+ NativeSheetMetalShellEvidence? NativeSheetMetal=null);public enum ImmersedBasisTreatmentKind { Ordinary, Aggregated }public enum BoundaryEnforcementKind { StrongNearestNode, SymmetricNitsche }@@ -86,7 +121,8 @@ public sealed record LinearElasticAnalysisResult(IReadOnlyList<ExactStressProbe>? StressProbes=null,IReadOnlyList<CellStrainResult>? StrainFields=null,IReadOnlyList<CellStressResult>? StressFields=null,- ExperimentalShellEvidence? ExperimentalShell=null)+ ExperimentalShellEvidence? ExperimentalShell=null,+ IReadOnlyList<BodyLoadEvidence>? BodyLoads=null){public double MaximumDisplacementMeters => Displacements.Count == 0 ? 0 : Displacements.Max(item => item.DisplacementMeters.Length);public double MaximumVonMisesPascal => StressFields is { Count: >0 }?StressFields.Max(item=>item.VonMisesPascal):CellFields.Count == 0 ? 0 : CellFields.Max(item => item.VonMisesPascal);diff --git a/Aetheris.FEA/Mechanics/SparseSymmetricMatrix.cs b/Aetheris.FEA/Mechanics/SparseSymmetricMatrix.csindex cac0acb3..13c8be0b 100644--- a/Aetheris.FEA/Mechanics/SparseSymmetricMatrix.cs+++ b/Aetheris.FEA/Mechanics/SparseSymmetricMatrix.cs@@ -91,6 +91,9 @@ public sealed class SparseSymmetricMatrixpublic static class PreconditionedConjugateGradient{public static (double[] Solution, SolverConvergence Convergence) Solve(SparseSymmetricMatrix matrix, double[] rhs, double relativeTolerance = 1e-9, int? maximumIterations = null)+ =>Solve(matrix,rhs,new JacobiPreconditioner(matrix),relativeTolerance,maximumIterations);++ public static (double[] Solution, SolverConvergence Convergence) Solve(SparseSymmetricMatrix matrix,double[] rhs,ISpdPreconditioner preconditioner,double relativeTolerance=1e-9,int? maximumIterations=null){var started = System.Diagnostics.Stopwatch.GetTimestamp();var n = matrix.Size;@@ -100,8 +103,8 @@ public static class PreconditionedConjugateGradientvar initial = Norm(r);var history = new List<double> { initial };if (initial == 0) return (x, new(true, 0, 0, 0, history, System.Diagnostics.Stopwatch.GetElapsedTime(started)));- var z = new double[n];- for (var i = 0; i < n; i++) z[i] = r[i] / SafeDiagonal(matrix[i, i]);+ var z = preconditioner.Apply(r);+ var preconditionedHistory=new List<double>{double.Sqrt(double.Max(0,Dot(r,z)))};var p = (double[])z.Clone();var rz = Dot(r, z);var converged = false;@@ -115,17 +118,115 @@ public static class PreconditionedConjugateGradientfor (var i = 0; i < n; i++) { x[i] += alpha * p[i]; r[i] -= alpha * ap[i]; }var residual = Norm(r);history.Add(residual);+ z=preconditioner.Apply(r);+ preconditionedHistory.Add(double.Sqrt(double.Max(0,Dot(r,z))));if (residual <= relativeTolerance * initial) { converged = true; iteration++; break; }- for (var i = 0; i < n; i++) z[i] = r[i] / SafeDiagonal(matrix[i, i]);var nextRz = Dot(r, z);var beta = nextRz / rz;for (var i = 0; i < n; i++) p[i] = z[i] + beta * p[i];rz = nextRz;}- return (x, new(converged, iteration, initial, history[^1], history, System.Diagnostics.Stopwatch.GetElapsedTime(started)));+ return (x, new(converged, iteration, initial, history[^1], history, System.Diagnostics.Stopwatch.GetElapsedTime(started),preconditionedHistory));}- private static double SafeDiagonal(double value) => double.Abs(value) < 1e-30 ? 1 : value;private static double Dot(IReadOnlyList<double> a, IReadOnlyList<double> b) { var sum = 0d; for (var i = 0; i < a.Count; i++) sum += a[i] * b[i]; return sum; }private static double Norm(IReadOnlyList<double> a) => double.Sqrt(Dot(a, a));}++public interface ISpdPreconditioner+{+ string Name { get; }+ double[] Apply(IReadOnlyList<double> residual);+}++public sealed class IdentityPreconditioner(int size):ISpdPreconditioner+{+ public string Name=>"Identity";+ public double[] Apply(IReadOnlyList<double> residual){if(residual.Count!=size)throw new ArgumentException("Residual length does not match preconditioner.",nameof(residual));return residual.ToArray();}+}++public sealed class JacobiPreconditioner:ISpdPreconditioner+{+ private readonly double[] inverseDiagonal;+ public JacobiPreconditioner(SparseSymmetricMatrix matrix)+ {+ inverseDiagonal=new double[matrix.Size];+ for(var i=0;i<matrix.Size;i++){var diagonal=matrix[i,i];if(!double.IsFinite(diagonal)||diagonal<=0)throw new InvalidOperationException($"Jacobi requires a finite positive diagonal at row {i}; got {diagonal:R}.");inverseDiagonal[i]=1/diagonal;}+ }+ public string Name=>"Jacobi";+ public double[] Apply(IReadOnlyList<double> residual){var result=new double[inverseDiagonal.Length];for(var i=0;i<result.Length;i++)result[i]=residual[i]*inverseDiagonal[i];return result;}+}++public sealed class BlockJacobi3Preconditioner:ISpdPreconditioner+{+ private readonly double[][] lower;+ public BlockJacobi3Preconditioner(SparseSymmetricMatrix matrix)+ {+ if(matrix.Size%3!=0)throw new InvalidOperationException("3x3 block Jacobi requires three displacement components per geometric basis mode.");lower=new double[matrix.Size/3][];+ for(var block=0;block<lower.Length;block++)+ {+ var i=3*block;var l00=Root(matrix[i,i],block);var l10=matrix[i+1,i]/l00;var l20=matrix[i+2,i]/l00;var l11=Root(matrix[i+1,i+1]-l10*l10,block);var l21=(matrix[i+2,i+1]-l20*l10)/l11;var l22=Root(matrix[i+2,i+2]-l20*l20-l21*l21,block);lower[block]=[l00,l10,l20,l11,l21,l22];+ }+ }+ public string Name=>"BlockJacobi3";+ public double[] Apply(IReadOnlyList<double> residual)+ {+ var result=new double[residual.Count];for(var block=0;block<lower.Length;block++)+ {+ var i=3*block;var l=lower[block];var y0=residual[i]/l[0];var y1=(residual[i+1]-l[1]*y0)/l[3];var y2=(residual[i+2]-l[2]*y0-l[4]*y1)/l[5];result[i+2]=y2/l[5];result[i+1]=(y1-l[4]*result[i+2])/l[3];result[i]=(y0-l[1]*result[i+1]-l[2]*result[i+2])/l[0];+ }return result;+ }+ private static double Root(double value,int block){if(!double.IsFinite(value)||value<=0)throw new InvalidOperationException($"3x3 block Jacobi encountered a nonpositive pivot in block {block}: {value:R}.");return double.Sqrt(value);}+}++public sealed class IncompleteCholeskyZeroPreconditioner:ISpdPreconditioner+{+ private readonly SortedDictionary<int,double>[] lower;+ private readonly List<(int Row,double Value)>[] columnEntries;+ public IncompleteCholeskyZeroPreconditioner(SparseSymmetricMatrix matrix,double diagonalShift=0)+ {+ if(!double.IsFinite(diagonalShift)||diagonalShift<0)throw new ArgumentOutOfRangeException(nameof(diagonalShift));+ lower=Enumerable.Range(0,matrix.Size).Select(_=>new SortedDictionary<int,double>()).ToArray();+ for(var i=0;i<matrix.Size;i++)+ {+ foreach(var j in matrix.Rows[i].Keys.Where(j=>j<i))+ {+ var sum=matrix[i,j];+ foreach(var left in lower[i].Where(item=>item.Key<j))if(lower[j].TryGetValue(left.Key,out var right))sum-=left.Value*right;+ var pivot=lower[j].GetValueOrDefault(j);if(!double.IsFinite(pivot)||pivot<=0)throw new InvalidOperationException($"IC(0) encountered an invalid pivot at row {j}.");+ lower[i][j]=sum/pivot;+ }+ var diagonal=matrix[i,i]+diagonalShift;+ foreach(var value in lower[i].Values)diagonal-=value*value;+ if(!double.IsFinite(diagonal)||diagonal<=0)throw new InvalidOperationException($"IC(0) encountered a nonpositive pivot at row {i}: {diagonal:R}.");+ lower[i][i]=double.Sqrt(diagonal);+ }+ columnEntries=Enumerable.Range(0,matrix.Size).Select(_=>new List<(int,double)>()).ToArray();+ for(var row=0;row<matrix.Size;row++)foreach(var item in lower[row])if(item.Key<row)columnEntries[item.Key].Add((row,item.Value));+ DiagonalShift=diagonalShift;+ }+ public string Name=>"IC(0)";+ public double DiagonalShift { get; }+ public double[] Apply(IReadOnlyList<double> residual)+ {+ var y=new double[lower.Length];+ for(var i=0;i<y.Length;i++){var value=residual[i];foreach(var item in lower[i]){if(item.Key>=i)break;value-=item.Value*y[item.Key];}y[i]=value/lower[i][i];}+ var result=new double[lower.Length];+ for(var i=result.Length-1;i>=0;i--){var value=y[i];foreach(var item in columnEntries[i])value-=item.Value*result[item.Row];result[i]=value/lower[i][i];}+ return result;+ }+}++public sealed record SymmetricDiagonalScaling(SparseSymmetricMatrix Matrix,double[] RightHandSide,double[] Scale,double MinimumScale,double MaximumScale)+{+ public static SymmetricDiagonalScaling Create(SparseSymmetricMatrix source,IReadOnlyList<double> rhs)+ {+ var scale=new double[source.Size];+ for(var i=0;i<source.Size;i++){var diagonal=source[i,i];if(!double.IsFinite(diagonal)||diagonal<=0)throw new InvalidOperationException($"Symmetric equilibration requires a finite positive diagonal at row {i}; got {diagonal:R}.");scale[i]=1/double.Sqrt(diagonal);}+ var matrix=new SparseSymmetricMatrix(source.Size);+ for(var row=0;row<source.Size;row++)foreach(var item in source.Rows[row])matrix.Add(row,item.Key,item.Value*scale[row]*scale[item.Key]);+ var load=new double[source.Size];for(var i=0;i<load.Length;i++)load[i]=rhs[i]*scale[i];+ return new(matrix,load,scale,scale.Min(),scale.Max());+ }+ public double[] Recover(IReadOnlyList<double> scaledSolution){var result=new double[Scale.Length];for(var i=0;i<result.Length;i++)result[i]=Scale[i]*scaledSolution[i];return result;}+}diff --git a/Aetheris.FEA/Mechanics/ThinWallDebugArtifacts.cs b/Aetheris.FEA/Mechanics/ThinWallDebugArtifacts.csindex 5a1e2bee..e9e59966 100644--- a/Aetheris.FEA/Mechanics/ThinWallDebugArtifacts.cs+++ b/Aetheris.FEA/Mechanics/ThinWallDebugArtifacts.cs@@ -13,6 +13,7 @@ public static class ThinWallDebugArtifactspublic static string ParameterDomainSvg(LinearElasticAnalysisIr analysis){var settings=analysis.ExperimentalShell??throw new ArgumentException("ExperimentalShell settings are required.",nameof(analysis));+ if(analysis.MidsurfacePatchGraph is not null)return NativeParameterDomainSvg(analysis,settings);var bounds=analysis.Body.ContinuumRegion.Bounds;var classifier=(IBoundsClassificationCapability)analysis.Body.ContinuumRegion;const double ox=50,oy=35,w=520,h=340;var dx=(bounds.Max.X-bounds.Min.X)/settings.MasterCellsR;var dy=(bounds.Max.Y-bounds.Min.Y)/settings.MasterCellsS;double X(double value)=>ox+(value-bounds.Min.X)/(bounds.Max.X-bounds.Min.X)*w;@@ -33,28 +34,53 @@ public static class ThinWallDebugArtifactspublic static string MappedAndDeformedSvg(LinearElasticAnalysisIr analysis,LinearElasticAnalysisResult result){var settings=analysis.ExperimentalShell??throw new ArgumentException("ExperimentalShell settings are required.",nameof(analysis));var bounds=analysis.Body.ContinuumRegion.Bounds;- var map=new ThinWallGeometryMap(settings,bounds);const double ox=55,oy=330,w=760,h=255;var maxU=double.Max(result.MaximumDisplacementMeters,1e-30);var span=double.Max(bounds.Max.X-bounds.Min.X,bounds.Max.Y-bounds.Min.Y);var scale=.12*span/maxU;- (double X,double Y) Project(Point3D p)=>(ox+(p.X+.25*p.Y-bounds.Min.X)/span*w,oy-p.Z/span*h*8);- var displacements=result.Displacements.ToDictionary(item=>Round(item.Position),item=>item.DisplacementMeters);var svg=Start("Mapped cells and amplified deformation",880,390);- for(var j=0;j<=settings.MasterCellsS;j++)for(var i=0;i<settings.MasterCellsR;i++)Line(i,j,i+1,j);- for(var i=0;i<=settings.MasterCellsR;i++)for(var j=0;j<settings.MasterCellsS;j++)Line(i,j,i,j+1);+ var synthetic=analysis.MidsurfacePatchGraph is null?new ThinWallGeometryMap(settings,bounds):null;+ var patches=analysis.MidsurfacePatchGraph?.Patches??[];const double ox=55,oy=330,w=760,h=255;var maxU=double.Max(result.MaximumDisplacementMeters,1e-30);+ var physical=patches.Count>0?patches.SelectMany(p=>Corners(p)).ToArray():new[]{synthetic!.Evaluate(bounds.Min.X,bounds.Min.Y,0).Position,synthetic.Evaluate(bounds.Max.X,bounds.Max.Y,0).Position};+ var minX=physical.Min(x=>x.X+.25*x.Y);var maxX=physical.Max(x=>x.X+.25*x.Y);var minZ=physical.Min(x=>x.Z);var maxZ=physical.Max(x=>x.Z);var span=double.Max(maxX-minX,maxZ-minZ);var scale=.12*span/maxU;+ (double X,double Y) Project(Point3D p)=>(ox+(p.X+.25*p.Y-minX)/span*w,oy-(p.Z-minZ)/span*h);+ var displacements=result.Displacements.GroupBy(item=>Round(item.Position)).ToDictionary(group=>group.Key,group=>group.First().DisplacementMeters);var svg=Start("Mapped cells and amplified deformation",880,390);+ if(patches.Count==0)DrawPatch(bounds,(r,s,t)=>synthetic!.Evaluate(r,s,t));else foreach(var patch in patches)DrawPatch(patch.ParameterDomain.Bounds,(r,s,t)=>ThinWallAnalysisAuthority.Evaluate(patch,r,s,t));svg.Append(Invariant($"<text x='55' y='370' font-size='13'>blue: mapped midsurface; red: deformation amplified {scale:R}x (diagnostic only)</text></g></svg>"));return svg.ToString();- void Line(int i0,int j0,int i1,int j1)+ void DrawPatch(BoundingBox3D patchBounds,Func<double,double,double,ThinWallMapEvaluation> map){- var r0=bounds.Min.X+(bounds.Max.X-bounds.Min.X)*i0/settings.MasterCellsR;var s0=bounds.Min.Y+(bounds.Max.Y-bounds.Min.Y)*j0/settings.MasterCellsS;- var r1=bounds.Min.X+(bounds.Max.X-bounds.Min.X)*i1/settings.MasterCellsR;var s1=bounds.Min.Y+(bounds.Max.Y-bounds.Min.Y)*j1/settings.MasterCellsS;- var p0=map.Evaluate(r0,s0,0).Position;var p1=map.Evaluate(r1,s1,0).Position;var a=Project(p0);var b=Project(p1);+ for(var j=0;j<=settings.MasterCellsS;j++)for(var i=0;i<settings.MasterCellsR;i++)Line(i,j,i+1,j);+ for(var i=0;i<=settings.MasterCellsR;i++)for(var j=0;j<settings.MasterCellsS;j++)Line(i,j,i,j+1);+ void Line(int i0,int j0,int i1,int j1)+ {+ var r0=patchBounds.Min.X+(patchBounds.Max.X-patchBounds.Min.X)*i0/settings.MasterCellsR;var s0=patchBounds.Min.Y+(patchBounds.Max.Y-patchBounds.Min.Y)*j0/settings.MasterCellsS;+ var r1=patchBounds.Min.X+(patchBounds.Max.X-patchBounds.Min.X)*i1/settings.MasterCellsR;var s1=patchBounds.Min.Y+(patchBounds.Max.Y-patchBounds.Min.Y)*j1/settings.MasterCellsS;+ var p0=map(r0,s0,0).Position;var p1=map(r1,s1,0).Position;var a=Project(p0);var b=Project(p1);svg.Append(Invariant($"<line x1='{a.X}' y1='{a.Y}' x2='{b.X}' y2='{b.Y}' stroke='#2563eb' stroke-width='2'/>") );- var d0=Displacement(r0,s0,p0);var d1=Displacement(r1,s1,p1);var da=Project(p0+d0*scale);var db=Project(p1+d1*scale);+ var d0=Displacement(r0,s0,p0,map);var d1=Displacement(r1,s1,p1,map);var da=Project(p0+d0*scale);var db=Project(p1+d1*scale);svg.Append(Invariant($"<line x1='{da.X}' y1='{da.Y}' x2='{db.X}' y2='{db.Y}' stroke='#dc2626' stroke-width='2'/>") );+ }}- Vector3D Displacement(double r,double s,Point3D p)+ Vector3D Displacement(double r,double s,Point3D p,Func<double,double,double,ThinWallMapEvaluation> map){- var top=map.Evaluate(r,s,1).Position;+ var top=map(r,s,1).Position;if(displacements.TryGetValue(Round(top),out var value))return value;return result.Displacements.OrderBy(item=>(item.Position-p).LengthSquared).FirstOrDefault()?.DisplacementMeters??Vector3D.Zero;}+ static IEnumerable<Point3D> Corners(MidsurfacePatch patch){var b=patch.ParameterDomain.Bounds;yield return ThinWallAnalysisAuthority.Evaluate(patch,b.Min.X,b.Min.Y,0).Position;yield return ThinWallAnalysisAuthority.Evaluate(patch,b.Max.X,b.Min.Y,0).Position;yield return ThinWallAnalysisAuthority.Evaluate(patch,b.Max.X,b.Max.Y,0).Position;yield return ThinWallAnalysisAuthority.Evaluate(patch,b.Min.X,b.Max.Y,0).Position;}+ }++ private static string NativeParameterDomainSvg(LinearElasticAnalysisIr analysis,ExperimentalShellSettings settings)+ {+ var graph=analysis.MidsurfacePatchGraph!;const double left=35,top=50,panelWidth=230,panelHeight=245,gap=25;var width=(int)(70+graph.Patches.Count*(panelWidth+gap));var svg=Start("Native SheetMetal midsurface patch graph",width,350);+ for(var index=0;index<graph.Patches.Count;index++)+ {+ var patch=graph.Patches[index];var b=patch.ParameterDomain.Bounds;var ox=left+index*(panelWidth+gap);var dx=(b.Max.X-b.Min.X)/settings.MasterCellsR;var ds=(b.Max.Y-b.Min.Y)/settings.MasterCellsS;+ double X(double r)=>ox+(r-b.Min.X)/(b.Max.X-b.Min.X)*panelWidth;double Y(double s)=>top+panelHeight-(s-b.Min.Y)/(b.Max.Y-b.Min.Y)*panelHeight;+ for(var j=0;j<settings.MasterCellsS;j++)for(var i=0;i<settings.MasterCellsR;i++)+ {+ var cell=new BoundingBox3D(new(b.Min.X+i*dx,b.Min.Y+j*ds,b.Min.Z),new(b.Min.X+(i+1)*dx,b.Min.Y+(j+1)*ds,b.Max.Z));var kind=((IBoundsClassificationCapability)patch.ParameterDomain).ClassifyBounds(cell);var fill=kind switch{ContinuumBoundsClassification.Inside=>"#b7e4c7",ContinuumBoundsClassification.Outside=>"#e5e7eb",_=>"#ffd166"};+ svg.Append(Invariant($"<rect x='{X(cell.Min.X)}' y='{Y(cell.Max.Y)}' width='{panelWidth/settings.MasterCellsR}' height='{panelHeight/settings.MasterCellsS}' fill='{fill}' stroke='#334155' stroke-width='1.5'/>") );+ }+ svg.Append(Invariant($"<text x='{ox}' y='315' font-size='12'>{patch.Identity} | {patch.Kind} | openings {patch.OpeningCount}</text>"));+ }+ svg.Append(Invariant($"<text x='{left}' y='338' font-size='12'>interfaces {graph.Interfaces.Count}; exact C0 shared trace DOFs; grid {settings.MasterCellsR}x{settings.MasterCellsS}; p={settings.PolynomialOrder}</text></g></svg>"));return svg.ToString();}private static string Round(Point3D p)=>Invariant($"{p.X:F12}|{p.Y:F12}|{p.Z:F12}");diff --git a/Aetheris.FEA/Mechanics/ThinWallFiniteCellSolver.cs b/Aetheris.FEA/Mechanics/ThinWallFiniteCellSolver.csindex 83e40e41..7930975e 100644--- a/Aetheris.FEA/Mechanics/ThinWallFiniteCellSolver.cs+++ b/Aetheris.FEA/Mechanics/ThinWallFiniteCellSolver.cs@@ -5,6 +5,7 @@ using System.Text;using Aetheris.Continuum.Cir;using Aetheris.Kernel.Core.Math;using Aetheris.FEA.Analysis;+using Aetheris.Kernel.Core.Judgment;namespace Aetheris.FEA.Mechanics;@@ -15,10 +16,15 @@ namespace Aetheris.FEA.Mechanics;public static class ThinWallFiniteCellSolver{private readonly record struct AxisKey(bool IsVertex,int Location,int Mode);- private readonly record struct BasisKey(AxisKey R,AxisKey S,AxisKey T);+ private readonly record struct BasisKey(string Patch,AxisKey R,AxisKey S,AxisKey T);+ private readonly record struct GlobalBasis(int Id,double Sign);private readonly record struct LocalMode(int R,int S,int T);private readonly record struct QuadraturePoint(double Xi,double Eta,double Zeta,Point3D Position,double Weight,Vector3D GradXi,Vector3D GradEta,Vector3D GradZeta,bool Physical,double ElementDeterminant);- private sealed record CellPlan(int I,int J,double R0,double R1,double S0,double S1,int[] Global,IReadOnlyList<QuadraturePoint> Points,ContinuumBoundsClassification Classification,double PhysicalFraction,int CutLeaves);+ private sealed record PatchContext(string Id,BoundingBox3D Bounds,IContinuumRegion Region,IBoundsClassificationCapability Classifier,ThinWallGeometryMap? SyntheticMap,MidsurfacePatch? NativePatch)+ {+ public ThinWallMapEvaluation Evaluate(double r,double s,double t)=>SyntheticMap?.Evaluate(r,s,t)??ThinWallAnalysisAuthority.Evaluate(NativePatch!,r,s,t);+ }+ private sealed record CellPlan(PatchContext Patch,int I,int J,double R0,double R1,double S0,double S1,GlobalBasis[] Global,IReadOnlyList<QuadraturePoint> Points,ContinuumBoundsClassification Classification,double PhysicalFraction,int CutLeaves);private readonly record struct BoundaryFace(int Axis,bool Maximum,string Token);public static LinearElasticAnalysisResult Solve(LinearElasticAnalysisIr analysis,MechanicsSolveOptions? options=null)@@ -35,33 +41,64 @@ public static class ThinWallFiniteCellSolverdiagnostics.Add(new("thinwall-geometry-unsupported",AnalysisDiagnosticSeverity.Error,"ExperimentalShell X0 does not apply the production world-space lattice rotation option.",analysis.Provenance));return Failure(analysis,diagnostics);}- if(analysis.Body.ContinuumRegion is not IBoundsClassificationCapability classifier)+ if(analysis.MidsurfacePatchGraph is null&&analysis.Body.ContinuumRegion is not IBoundsClassificationCapability){diagnostics.Add(new("thinwall-boundary-invalid",AnalysisDiagnosticSeverity.Error,"ExperimentalShell X0 requires exact parameter-space bounds classification.",analysis.Body.Provenance));return Failure(analysis,diagnostics);}- var settings=analysis.ExperimentalShell;var bounds=analysis.Body.ContinuumRegion.Bounds;- ThinWallGeometryMap geometry;- try{geometry=new(settings,bounds);}catch(ThinWallMapException ex){diagnostics.Add(new(ex.Code,AnalysisDiagnosticSeverity.Error,ex.Message,analysis.Provenance));return Failure(analysis,diagnostics);}+ var settings=analysis.ExperimentalShell;var bounds=analysis.Body.ContinuumRegion.Bounds;var patchContexts=new List<PatchContext>();+ if(analysis.MidsurfacePatchGraph is null)+ {+ try{var geometry=new ThinWallGeometryMap(settings,bounds);patchContexts.Add(new("",bounds,analysis.Body.ContinuumRegion,(IBoundsClassificationCapability)analysis.Body.ContinuumRegion,geometry,null));}+ catch(ThinWallMapException ex){diagnostics.Add(new(ex.Code,AnalysisDiagnosticSeverity.Error,ex.Message,analysis.Provenance));return Failure(analysis,diagnostics);}+ }+ else foreach(var patch in analysis.MidsurfacePatchGraph.Patches)+ {+ if(patch.ParameterDomain is not IBoundsClassificationCapability classifier){diagnostics.Add(new("thinwall-boundary-invalid",AnalysisDiagnosticSeverity.Error,$"Native patch '{patch.Identity}' has no exact parameter-space bounds classification.",analysis.Body.Provenance));continue;}+ patchContexts.Add(new(patch.Identity,patch.ParameterDomain.Bounds,patch.ParameterDomain,classifier,null,patch));+ }+ if(diagnostics.Any(x=>x.Severity==AnalysisDiagnosticSeverity.Error))return Failure(analysis,diagnostics);var p=settings.PolynomialOrder;var qOrder=settings.QuadratureOrder??p+1;var modes=LocalModesFor(p);var nx=settings.MasterCellsR;var ny=settings.MasterCellsS;- var dr=(bounds.Max.X-bounds.Min.X)/nx;var ds=(bounds.Max.Y-bounds.Min.Y)/ny;var allKeys=new List<BasisKey>();- for(var j=0;j<ny;j++)for(var i=0;i<nx;i++)foreach(var mode in modes)allKeys.Add(Key(i,j,mode));- var orderedKeys=allKeys.Distinct().OrderBy(k=>AxisSort(k.T)).ThenBy(k=>AxisSort(k.S)).ThenBy(k=>AxisSort(k.R)).ToArray();- var globalId=orderedKeys.Select((key,index)=>(key,index)).ToDictionary(x=>x.key,x=>x.index);+ foreach(var patch in patchContexts)for(var j=0;j<ny;j++)for(var i=0;i<nx;i++)foreach(var mode in modes)allKeys.Add(Key(patch.Id,i,j,mode));+ var uniqueKeys=allKeys.Distinct().OrderBy(k=>k.Patch,StringComparer.Ordinal).ThenBy(k=>AxisSort(k.T)).ThenBy(k=>AxisSort(k.S)).ThenBy(k=>AxisSort(k.R)).ToArray();+ var unions=new SignedBasisUnion(uniqueKeys);+ if(analysis.MidsurfacePatchGraph is not null)+ {+ foreach(var item in analysis.MidsurfacePatchGraph.Interfaces)+ {+ var a=patchContexts.Single(x=>x.Id==item.PatchA);var b=patchContexts.Single(x=>x.Id==item.PatchB);+ var countA=EdgeCellCount(item.EdgeA,nx,ny);var countB=EdgeCellCount(item.EdgeB,nx,ny);+ var spanA=EdgeSpan(a,item.EdgeA);var spanB=EdgeSpan(b,item.EdgeB);+ if(countA!=countB||double.Abs(spanA-spanB)>double.Max(1e-10,spanA*1e-8))+ {diagnostics.Add(new("thinwall-sheetmetal-interface-nonconforming",AnalysisDiagnosticSeverity.Error,$"Interface '{item.Identity}' requires equal edge partitions and spans; got {countA}/{countB} cells and {spanA:R}/{spanB:R} m.",analysis.Provenance));continue;}+ var normalA=NormalOnEdge(a,item.EdgeA);var normalB=NormalOnEdge(b,item.EdgeB);+ if(Normalize(normalA).Dot(Normalize(normalB))<1-1e-8){diagnostics.Add(new("thinwall-sheetmetal-interface-thickness-orientation",AnalysisDiagnosticSeverity.Error,$"Interface '{item.Identity}' has inconsistent material-normal orientation.",analysis.Provenance));continue;}+ foreach(var tangent in UniqueAxisKeys(countA,p))foreach(var through in UniqueAxisKeys(1,p))+ {+ var mapped=item.Orientation==PatchInterfaceOrientation.Same?(Key:tangent,Sign:1d):Reverse(tangent,countA);+ unions.Join(EdgeBasis(a.Id,item.EdgeA,tangent,through,nx,ny),EdgeBasis(b.Id,item.EdgeB,mapped.Key,through,nx,ny),mapped.Sign);+ }+ }+ }+ if(diagnostics.Any(x=>x.Severity==AnalysisDiagnosticSeverity.Error))return Failure(analysis,diagnostics);+ var representatives=uniqueKeys.Select(unions.Find).Select(x=>x.Root).Distinct().OrderBy(x=>x.Patch,StringComparer.Ordinal).ThenBy(x=>AxisSort(x.T)).ThenBy(x=>AxisSort(x.S)).ThenBy(x=>AxisSort(x.R)).ToArray();+ var globalId=representatives.Select((key,index)=>(key,index)).ToDictionary(x=>x.key,x=>x.index);var basisMap=uniqueKeys.ToDictionary(x=>x,x=>{var found=unions.Find(x);return new GlobalBasis(globalId[found.Root],found.Sign);});var domainStart=Stopwatch.GetTimestamp();var plans=new List<CellPlan>();var minDet=double.PositiveInfinity;var maxDet=double.NegativeInfinity;- for(var j=0;j<ny;j++)for(var i=0;i<nx;i++)+ foreach(var patch in patchContexts)for(var j=0;j<ny;j++)for(var i=0;i<nx;i++){- var r0=bounds.Min.X+i*dr;var r1=r0+dr;var s0=bounds.Min.Y+j*ds;var s1=s0+ds;- var classification=classifier.ClassifyBounds(new(new(r0,s0,bounds.Min.Z),new(r1,s1,bounds.Max.Z)));+ var patchBounds=patch.Bounds;var classifier=patch.Classifier;var geometry=patch;+ var dr=(patchBounds.Max.X-patchBounds.Min.X)/nx;var ds=(patchBounds.Max.Y-patchBounds.Min.Y)/ny;+ var r0=patchBounds.Min.X+i*dr;var r1=r0+dr;var s0=patchBounds.Min.Y+j*ds;var s1=s0+ds;+ var classification=classifier.ClassifyBounds(new(new(r0,s0,patchBounds.Min.Z),new(r1,s1,patchBounds.Max.Z)));var points=new List<QuadraturePoint>();var physicalVolume=0d;var totalVolume=0d;var cutLeaves=0;try{IntegrateRectangle(r0,r1,s0,s1,0,classification==ContinuumBoundsClassification.Cut?null:classification==ContinuumBoundsClassification.Inside,points,ref physicalVolume,ref totalVolume,ref cutLeaves);}catch(ThinWallMapException ex){diagnostics.Add(new(ex.Code,AnalysisDiagnosticSeverity.Error,ex.Message,analysis.Provenance));return Failure(analysis,diagnostics);}foreach(var point in points){minDet=double.Min(minDet,point.ElementDeterminant);maxDet=double.Max(maxDet,point.ElementDeterminant);}- var globals=modes.Select(mode=>globalId[Key(i,j,mode)]).ToArray();- plans.Add(new(i,j,r0,r1,s0,s1,globals,points,classification,totalVolume==0?0:physicalVolume/totalVolume,cutLeaves));+ var globals=modes.Select(mode=>basisMap[Key(patch.Id,i,j,mode)]).ToArray();+ plans.Add(new(patch,i,j,r0,r1,s0,s1,globals,points,classification,totalVolume==0?0:physicalVolume/totalVolume,cutLeaves));void IntegrateRectangle(double ar0,double ar1,double as0,double as1,int depth,bool? allPhysical,List<QuadraturePoint> target,ref double physical,ref double total,ref int leaves){@@ -71,7 +108,7 @@ public static class ThinWallFiniteCellSolvervar rm=(ar0+ar1)/2;var sm=(as0+as1)/2;foreach(var child in new[]{(ar0,rm,as0,sm),(rm,ar1,as0,sm),(ar0,rm,sm,as1),(rm,ar1,sm,as1)}){- var c=classifier.ClassifyBounds(new(new(child.Item1,child.Item3,bounds.Min.Z),new(child.Item2,child.Item4,bounds.Max.Z)));+ var c=classifier.ClassifyBounds(new(new(child.Item1,child.Item3,patchBounds.Min.Z),new(child.Item2,child.Item4,patchBounds.Max.Z)));IntegrateRectangle(child.Item1,child.Item2,child.Item3,child.Item4,depth+1,c==ContinuumBoundsClassification.Cut?null:c==ContinuumBoundsClassification.Inside,target,ref physical,ref total,ref leaves);}return;@@ -81,7 +118,7 @@ public static class ThinWallFiniteCellSolverforeach(var gr in gauss)foreach(var gs in gauss)foreach(var gt in gauss){var r=(ar0+ar1)/2+gr.X*(ar1-ar0)/2;var s=(as0+as1)/2+gs.X*(as1-as0)/2;var t=gt.X;- var isPhysical=state??analysis.Body.ContinuumRegion.Classify(new(r,s,(bounds.Min.Z+bounds.Max.Z)/2))!=ContinuumPointClassification.Outside;+ var isPhysical=state??patch.Region.Classify(new(r,s,(patchBounds.Min.Z+patchBounds.Max.Z)/2))!=ContinuumPointClassification.Outside;var mapped=geometry.Evaluate(r,s,t);var a=mapped.DerivativeR*(dr/2);var b=mapped.DerivativeS*(ds/2);var c=mapped.DerivativeT;var det=a.Dot(b.Cross(c));if(!double.IsFinite(det)||det==0)throw new ThinWallMapException("thinwall-map-singular",$"Thin-wall map Jacobian is singular or nonfinite at ({r:R},{s:R},{t:R}).");if(det<0)throw new ThinWallMapException("thinwall-map-inverted",$"Thin-wall map Jacobian is inverted at ({r:R},{s:R},{t:R}); det(J)={det:R}.");@@ -96,8 +133,8 @@ public static class ThinWallFiniteCellSolvervar domainTime=Stopwatch.GetElapsedTime(domainStart);if(diagnostics.Any(x=>x.Severity==AnalysisDiagnosticSeverity.Error)||plans.Count==0)return Failure(analysis,diagnostics);- var dofs=checked(orderedKeys.Length*3);var matrix=new SparseSymmetricMatrix(dofs);var load=new double[dofs];var constitutive=Constitutive(analysis.Materials.Single().YoungsModulusPascal,analysis.Materials.Single().PoissonRatio);- var assemblyStart=Stopwatch.GetTimestamp();+ var dofs=checked(representatives.Length*3);var matrix=new SparseSymmetricMatrix(dofs);var load=new double[dofs];var constitutive=Constitutive(analysis.Materials.Single().YoungsModulusPascal,analysis.Materials.Single().PoissonRatio);+ var assemblyStart=Stopwatch.GetTimestamp();var bodyLoadEvidence=new List<BodyLoadEvidence>();var bodyApplied=Vector3D.Zero;try{foreach(var cell in plans)@@ -111,28 +148,44 @@ public static class ThinWallFiniteCellSolver{var value=0d;for(var k=0;k<6;k++)value+=b[k,row]*db[k,column];local[row,column]+=value*point.Weight;}+ if((analysis.BodyForces?.Count??0)>0)+ {+ var values=BasisValues(p,modes,point.Xi,point.Eta,point.Zeta);var density=analysis.Materials.Single().DensityKilogramsPerCubicMeter!.Value;+ foreach(var bodyForce in analysis.BodyForces!)for(var n=0;n<modes.Count;n++)+ {+ var force=bodyForce.AccelerationMetersPerSecondSquared*(density*values[n]*point.Weight*cell.Global[n].Sign);var id=cell.Global[n].Id;+ load[3*id]+=force.X;load[3*id+1]+=force.Y;load[3*id+2]+=force.Z;+ }+ }}- for(var a=0;a<modes.Count;a++)for(var ca=0;ca<3;ca++)for(var b=0;b<modes.Count;b++)for(var cb=0;cb<3;cb++)matrix.Add(3*cell.Global[a]+ca,3*cell.Global[b]+cb,local[3*a+ca,3*b+cb]);+ for(var a=0;a<modes.Count;a++)for(var ca=0;ca<3;ca++)for(var b=0;b<modes.Count;b++)for(var cb=0;cb<3;cb++)matrix.Add(3*cell.Global[a].Id+ca,3*cell.Global[b].Id+cb,cell.Global[a].Sign*cell.Global[b].Sign*local[3*a+ca,3*b+cb]);+ }+ foreach(var bodyForce in analysis.BodyForces??[])+ {+ var density=analysis.Materials.Single().DensityKilogramsPerCubicMeter!.Value;var volume=0d;var resultant=Vector3D.Zero;var moment=Vector3D.Zero;var points=0;+ foreach(var cell in plans)foreach(var point in cell.Points){var force=bodyForce.AccelerationMetersPerSecondSquared*(density*point.Weight);volume+=point.Weight;resultant+=force;moment+=new Vector3D(point.Position.X,point.Position.Y,point.Position.Z).Cross(force);points++;}+ bodyApplied+=resultant;bodyLoadEvidence.Add(new(bodyForce.Id,bodyForce.AccelerationMetersPerSecondSquared,density,volume,resultant,moment,points,"FCM volume quadrature; fictitious-domain contribution scaled by alpha"));}}catch(ArithmeticException ex){diagnostics.Add(new("thinwall-cut-integration-failed",AnalysisDiagnosticSeverity.Error,ex.Message,analysis.Provenance));return Failure(analysis,diagnostics);}var assemblyTime=Stopwatch.GetElapsedTime(assemblyStart);var volumeMatrix=matrix.Copy();- var boundaryStart=Stopwatch.GetTimestamp();var loadEvidence=new List<BoundaryLoadEvidence>();var applied=Vector3D.Zero;+ var boundaryStart=Stopwatch.GetTimestamp();var loadEvidence=new List<BoundaryLoadEvidence>();var applied=bodyApplied;foreach(var item in analysis.Loads){- if(!TryFace(item.Region.Path,out var face)){diagnostics.Add(new("thinwall-boundary-condition-unsupported",AnalysisDiagnosticSeverity.Error,$"ExperimentalShell X0 boundary '{item.Region.Path}' is not an exact master-domain face.",item.Provenance));continue;}+ if(!TryBoundary(item.Region.Path,analysis,patchContexts,out var selectedPatch,out var face)){diagnostics.Add(new("thinwall-boundary-condition-unsupported",AnalysisDiagnosticSeverity.Error,$"ExperimentalShell boundary '{item.Region.Path}' is not an exact parameter-domain face.",item.Provenance));continue;}var weights=new Dictionary<int,double>();var pressureForces=new Dictionary<int,Vector3D>();var area=0d;var firstMoment=Vector3D.Zero;var pressureResultant=Vector3D.Zero;var pressureMoment=Vector3D.Zero;- foreach(var cell in BoundaryCells(plans,face,nx,ny))+ var boundaryCells=BoundaryCells(plans,selectedPatch,face,nx,ny);+ foreach(var cell in boundaryCells){- foreach(var sample in BoundarySamples(cell,face,qOrder,geometry,bounds))+ foreach(var sample in BoundarySamples(cell,face,qOrder)){- if(analysis.Body.ContinuumRegion.Classify(new(sample.R,sample.S,(bounds.Min.Z+bounds.Max.Z)/2))==ContinuumPointClassification.Outside)continue;+ if(selectedPatch.Region.Classify(new(sample.R,sample.S,(selectedPatch.Bounds.Min.Z+selectedPatch.Bounds.Max.Z)/2))==ContinuumPointClassification.Outside)continue;area+=sample.Weight;firstMoment+=new Vector3D(sample.Position.X,sample.Position.Y,sample.Position.Z)*sample.Weight;var values=BasisValues(p,modes,sample.Xi,sample.Eta,sample.Zeta);for(var n=0;n<modes.Count;n++){- var shape=values[n];if(double.Abs(shape)<1e-15)continue;var id=cell.Global[n];weights[id]=weights.GetValueOrDefault(id)+shape*sample.Weight;+ var shape=values[n]*cell.Global[n].Sign;if(double.Abs(shape)<1e-15)continue;var id=cell.Global[n].Id;weights[id]=weights.GetValueOrDefault(id)+shape*sample.Weight;if(item.Kind==BoundaryLoadKind.Pressure){var f=sample.Normal*(-item.PressurePascal*shape*sample.Weight);pressureForces[id]=pressureForces.GetValueOrDefault(id)+f;@@ -155,40 +208,70 @@ public static class ThinWallFiniteCellSolverresultant=traction*area;var centroid=firstMoment/area;moment=centroid.Cross(resultant);}applied+=resultant;- loadEvidence.Add(new(item.Id,item.Region.Path,face.Token,null,area,area,resultant,resultant,moment,moment,0,0,BoundaryCells(plans,face,nx,ny).Count,qOrder*qOrder*BoundaryCells(plans,face,nx,ny).Count,"Exact master-face quadrature with semantic parameter-space trimming"));+ loadEvidence.Add(new(item.Id,item.Region.Path,face.Token,null,area,area,resultant,resultant,moment,moment,0,0,boundaryCells.Count,qOrder*qOrder*boundaryCells.Count,"Exact patch-face quadrature with semantic parameter-space trimming"));}var prescribed=new Dictionary<int,double>();var constrainedById=new Dictionary<string,HashSet<int>>(StringComparer.Ordinal);foreach(var constraint in analysis.Constraints){- if(!TryFace(constraint.Region.Path,out var face)){diagnostics.Add(new("thinwall-boundary-condition-unsupported",AnalysisDiagnosticSeverity.Error,$"ExperimentalShell X0 constraint '{constraint.Region.Path}' is not an exact master-domain face.",constraint.Provenance));continue;}- var selected=orderedKeys.Select((key,id)=>(key,id)).Where(x=>OnFace(x.key,face,nx,ny)).Select(x=>x.id).ToHashSet();+ if(!TryBoundary(constraint.Region.Path,analysis,patchContexts,out var selectedPatch,out var face)){diagnostics.Add(new("thinwall-boundary-condition-unsupported",AnalysisDiagnosticSeverity.Error,$"ExperimentalShell constraint '{constraint.Region.Path}' is not an exact parameter-domain face.",constraint.Provenance));continue;}+ var selected=uniqueKeys.Where(key=>key.Patch==selectedPatch.Id&&OnFace(key,face,nx,ny)).Select(key=>basisMap[key].Id).ToHashSet();if(selected.Count==0){diagnostics.Add(new("thinwall-boundary-invalid",AnalysisDiagnosticSeverity.Error,$"Constraint '{constraint.Id}' selected no basis trace.",constraint.Provenance));continue;}constrainedById[constraint.Id]=selected;foreach(var id in selected)foreach(var component in constraint.Components)- prescribed[3*id+(int)component]=orderedKeys[id].R.IsVertex&&orderedKeys[id].S.IsVertex&&orderedKeys[id].T.IsVertex?Component(constraint.ValueMeters,component):0;+ prescribed[3*id+(int)component]=representatives[id].R.IsVertex&&representatives[id].S.IsVertex&&representatives[id].T.IsVertex?Component(constraint.ValueMeters,component):0;}var boundaryTime=Stopwatch.GetElapsedTime(boundaryStart);if(diagnostics.Any(x=>x.Severity==AnalysisDiagnosticSeverity.Error))return Failure(analysis,diagnostics);- var rawMatrix=matrix.Copy();var rawLoad=(double[])load.Clone();matrix.ApplyDirichlet(prescribed,load);var solveStart=Stopwatch.GetTimestamp();- var (solution,convergence)=PreconditionedConjugateGradient.Solve(matrix,load,options.RelativeResidualTolerance,options.MaximumIterations);var solveTime=Stopwatch.GetElapsedTime(solveStart);- if(!convergence.Converged){diagnostics.Add(new("thinwall-linear-solve-failed",AnalysisDiagnosticSeverity.Error,$"ExperimentalShell PCG did not converge after {convergence.Iterations} iterations; residual {convergence.FinalResidual:R}.",analysis.Provenance));return Failure(analysis,diagnostics,convergence);}+ var rawMatrix=matrix.Copy();var rawLoad=(double[])load.Clone();matrix.ApplyDirichlet(prescribed,load);+ var useScaling=options.ExperimentalSymmetricEquilibration??true;var preconditionerKind=options.ExperimentalPreconditioner??ExperimentalPreconditionerKind.IncompleteCholeskyZero;+ SymmetricDiagonalScaling? scaling=null;var solverMatrix=matrix;var solverLoad=load;var minScale=1d;var maxScale=1d;+ try{if(useScaling){scaling=SymmetricDiagonalScaling.Create(matrix,load);solverMatrix=scaling.Matrix;solverLoad=scaling.RightHandSide;minScale=scaling.MinimumScale;maxScale=scaling.MaximumScale;}}+ catch(InvalidOperationException ex){diagnostics.Add(new("thinwall-preconditioner-nonspd",AnalysisDiagnosticSeverity.Error,ex.Message,analysis.Provenance));return Failure(analysis,diagnostics);}+ var preconditionerStart=Stopwatch.GetTimestamp();ISpdPreconditioner preconditioner;var diagonalShift=0d;var factorizationRetries=0;var selectionPolicy="Explicit";double? selectedUtility=null;IReadOnlyList<string> rejectedCandidates=[];+ try+ {+ if(preconditionerKind==ExperimentalPreconditionerKind.Identity)preconditioner=new IdentityPreconditioner(solverMatrix.Size);+ else if(preconditionerKind==ExperimentalPreconditionerKind.Jacobi)preconditioner=new JacobiPreconditioner(solverMatrix);+ else if(preconditionerKind==ExperimentalPreconditionerKind.BlockJacobi3)preconditioner=new BlockJacobi3Preconditioner(solverMatrix);+ else+ {+ var maximumDiagonal=Enumerable.Range(0,solverMatrix.Size).Max(i=>solverMatrix[i,i]);var factors=new Dictionary<string,IncompleteCholeskyZeroPreconditioner?>(StringComparer.Ordinal);var failures=new Dictionary<string,string>(StringComparer.Ordinal);var shifts=new[]{0d,maximumDiagonal*1e-8,maximumDiagonal*1e-6,maximumDiagonal*1e-4,maximumDiagonal*1e-2,maximumDiagonal};+ for(var index=0;index<shifts.Length;index++)+ {+ var name=$"shift-{index}";try{factors[name]=new IncompleteCholeskyZeroPreconditioner(solverMatrix,shifts[index]);}+ catch(InvalidOperationException ex){factors[name]=null;failures[name]=ex.Message;factorizationRetries++;}+ }+ var candidates=shifts.Select((shift,index)=>new JudgmentCandidate<IReadOnlyDictionary<string,IncompleteCholeskyZeroPreconditioner?>>($"shift-{index}",c=>c[$"shift-{index}"] is not null,_=>1d-index/(double)shifts.Length,_=>failures.GetValueOrDefault($"shift-{index}")??"IC(0) pivot admission failed.",index)).ToArray();+ var judgment=new JudgmentEngine<IReadOnlyDictionary<string,IncompleteCholeskyZeroPreconditioner?>>().Evaluate(factors,candidates);+ if(!judgment.IsSuccess)throw new InvalidOperationException($"IC(0) failed after the documented shifts [0, 1e-8, 1e-6, 1e-4, 1e-2, 1] times max diagonal. {string.Join("; ",judgment.Rejections.Select(x=>x.CandidateName+": "+x.Reason))}");+ var chosen=judgment.Selection!.Value;var chosenIndex=int.Parse(chosen.Candidate.Name.AsSpan("shift-".Length),CultureInfo.InvariantCulture);preconditioner=factors[chosen.Candidate.Name]!;diagonalShift=shifts[chosenIndex];selectionPolicy="JudgmentEngine bounded shifted-IC admission; utility prefers the smallest SPD-admissible shift";selectedUtility=chosen.Score;rejectedCandidates=failures.OrderBy(x=>x.Key,StringComparer.Ordinal).Select(x=>$"{x.Key}: {x.Value}").ToArray();+ }+ }+ catch(InvalidOperationException ex){diagnostics.Add(new("thinwall-preconditioner-failed",AnalysisDiagnosticSeverity.Error,ex.Message,analysis.Provenance));return Failure(analysis,diagnostics);}+ var preconditionerTime=Stopwatch.GetElapsedTime(preconditionerStart);var solveStart=Stopwatch.GetTimestamp();+ var (solverSolution,convergence)=PreconditionedConjugateGradient.Solve(solverMatrix,solverLoad,preconditioner,options.RelativeResidualTolerance,options.MaximumIterations);var solveTime=Stopwatch.GetElapsedTime(solveStart);+ var solution=scaling is null?solverSolution:scaling.Recover(solverSolution);var physicalResidual=matrix.Multiply(solution);for(var i=0;i<physicalResidual.Length;i++)physicalResidual[i]-=load[i];var finalPhysicalResidual=Norm(physicalResidual);+ var stagnation=StagnationOnset(convergence.ResidualHistory);+ if(!convergence.Converged){diagnostics.Add(new(stagnation is null?"thinwall-linear-solve-failed":"thinwall-linear-solve-stagnated",AnalysisDiagnosticSeverity.Error,$"ExperimentalShell PCG with {preconditioner.Name} did not converge after {convergence.Iterations} iterations; solver residual {convergence.FinalResidual:R}, physical residual {finalPhysicalResidual:R}.",analysis.Provenance));return Failure(analysis,diagnostics,convergence);}if(solution.Any(x=>!double.IsFinite(x))){diagnostics.Add(new("thinwall-result-nonfinite",AnalysisDiagnosticSeverity.Error,"ExperimentalShell solve produced a nonfinite displacement coefficient.",analysis.Provenance));return Failure(analysis,diagnostics,convergence);}var recoveryStart=Stopwatch.GetTimestamp();var displacements=new List<NodalDisplacement>();- foreach(var pair in orderedKeys.Select((key,id)=>(key,id)).Where(x=>x.key.R.IsVertex&&x.key.S.IsVertex&&x.key.T.IsVertex))+ var emittedNodes=new HashSet<int>();+ foreach(var key in uniqueKeys.Where(x=>x.R.IsVertex&&x.S.IsVertex&&x.T.IsVertex)){- var r=bounds.Min.X+pair.key.R.Location*dr;var s=bounds.Min.Y+pair.key.S.Location*ds;var t=pair.key.T.Location==0?-1d:1d;var position=geometry.Evaluate(r,s,t).Position;- displacements.Add(new(pair.id,position,new(solution[3*pair.id],solution[3*pair.id+1],solution[3*pair.id+2])));+ var global=basisMap[key];if(!emittedNodes.Add(global.Id))continue;var patch=patchContexts.Single(x=>x.Id==key.Patch);var dr=(patch.Bounds.Max.X-patch.Bounds.Min.X)/nx;var ds=(patch.Bounds.Max.Y-patch.Bounds.Min.Y)/ny;+ var r=patch.Bounds.Min.X+key.R.Location*dr;var s=patch.Bounds.Min.Y+key.S.Location*ds;var t=key.T.Location==0?-1d:1d;var position=patch.Evaluate(r,s,t).Position;+ displacements.Add(new(global.Id,position,new(solution[3*global.Id]*global.Sign,solution[3*global.Id+1]*global.Sign,solution[3*global.Id+2]*global.Sign)));}var fields=new List<CellFieldResult>();foreach(var cell in plans.Where(x=>x.PhysicalFraction>0))foreach(var t in new[]{-1d,0d,1d}){- var r=(cell.R0+cell.R1)/2;var s=(cell.S0+cell.S1)/2;if(analysis.Body.ContinuumRegion.Classify(new(r,s,(bounds.Min.Z+bounds.Max.Z)/2))==ContinuumPointClassification.Outside)continue;- var mapped=geometry.Evaluate(r,s,t);var a=mapped.DerivativeR*(dr/2);var b=mapped.DerivativeS*(ds/2);var c=mapped.DerivativeT;var det=a.Dot(b.Cross(c));+ var r=(cell.R0+cell.R1)/2;var s=(cell.S0+cell.S1)/2;if(cell.Patch.Region.Classify(new(r,s,(cell.Patch.Bounds.Min.Z+cell.Patch.Bounds.Max.Z)/2))==ContinuumPointClassification.Outside)continue;+ var dr=(cell.Patch.Bounds.Max.X-cell.Patch.Bounds.Min.X)/nx;var ds=(cell.Patch.Bounds.Max.Y-cell.Patch.Bounds.Min.Y)/ny;var mapped=cell.Patch.Evaluate(r,s,t);var a=mapped.DerivativeR*(dr/2);var b=mapped.DerivativeS*(ds/2);var c=mapped.DerivativeT;var det=a.Dot(b.Cross(c));if(det<=0||!double.IsFinite(det)){diagnostics.Add(new(det<0?"thinwall-map-inverted":"thinwall-map-singular",AnalysisDiagnosticSeverity.Error,"Thin-wall recovery encountered an invalid Jacobian.",analysis.Provenance));return Failure(analysis,diagnostics,convergence);}var point=new QuadraturePoint(0,0,t,mapped.Position,0,b.Cross(c)*(1/det),c.Cross(a)*(1/det),a.Cross(b)*(1/det),true,det);var bm=BMatrix(p,modes,point);var strain=new double[6];- for(var row=0;row<6;row++)for(var n=0;n<modes.Count;n++)for(var component=0;component<3;component++)strain[row]+=bm[row,3*n+component]*solution[3*cell.Global[n]+component];+ for(var row=0;row<6;row++)for(var n=0;n<modes.Count;n++)for(var component=0;component<3;component++)strain[row]+=bm[row,3*n+component]*cell.Global[n].Sign*solution[3*cell.Global[n].Id+component];var stress=Multiply(constitutive,strain);var st=new SymmetricTensor(stress[0],stress[1],stress[2],stress[3],stress[4],stress[5]);var et=new SymmetricTensor(strain[0],strain[1],strain[2],strain[3],strain[4],strain[5]);fields.Add(new(cell.I,cell.J,t<0?-1:t>0?1:0,mapped.Position,et,st,VonMises(st)));}@@ -196,7 +279,7 @@ public static class ThinWallFiniteCellSolverforeach(var constraint in analysis.Constraints){var ids=constrainedById.GetValueOrDefault(constraint.Id,[]);var reaction=Vector3D.Zero;- foreach(var id in ids.Where(id=>orderedKeys[id].R.IsVertex&&orderedKeys[id].S.IsVertex&&orderedKeys[id].T.IsVertex))+ foreach(var id in ids.Where(id=>representatives[id].R.IsVertex&&representatives[id].S.IsVertex&&representatives[id].T.IsVertex)){if(constraint.Components.Contains(DisplacementComponent.X))reaction+=new Vector3D(rawResidual[3*id],0,0);if(constraint.Components.Contains(DisplacementComponent.Y))reaction+=new Vector3D(0,rawResidual[3*id+1],0);@@ -209,28 +292,49 @@ public static class ThinWallFiniteCellSolverforeach(var cell in plans)foreach(var point in cell.Points){var bm=BMatrix(p,modes,point);var strain=new double[6];- for(var row=0;row<6;row++)for(var n=0;n<modes.Count;n++)for(var component=0;component<3;component++)strain[row]+=bm[row,3*n+component]*solution[3*cell.Global[n]+component];+ for(var row=0;row<6;row++)for(var n=0;n<modes.Count;n++)for(var component=0;component<3;component++)strain[row]+=bm[row,3*n+component]*cell.Global[n].Sign*solution[3*cell.Global[n].Id+component];var stress=Multiply(constitutive,strain);integratedEnergy+=.5*Dot(strain,stress)*point.Weight;}var energyAbsolute=double.Abs(energyValue-integratedEnergy);var energyRelative=energyAbsolute/double.Max(double.Abs(energyValue),1e-30);var energy=new StrainEnergyConsistency(energyValue,integratedEnergy,energyAbsolute,energyRelative);var recoveryTime=Stopwatch.GetElapsedTime(recoveryStart);var conditioning=rawMatrix.ConditioningProxy();var cut=plans.Where(x=>x.Classification==ContinuumBoundsClassification.Cut).ToArray();var fractions=plans.Select(x=>x.PhysicalFraction).Order().ToArray();var system=new SparseSystemMetrics(dofs,rawMatrix.Nonzeros,rawMatrix.MaximumAsymmetry(),rawMatrix.IsFinite(),true,applied.Length,0,cut.Length,null,dofs,prescribed.Count,0,conditioning.MinimumDiagonal,conditioning.MaximumDiagonal,conditioning.DiagonalRatio,conditioning.MinimumRowNorm,conditioning.MaximumRowNorm,conditioning.RowNormRatio);- var integrationFingerprint=string.Join(";",plans.Select(cell=>$"{cell.I},{cell.J},{cell.Classification},{cell.PhysicalFraction:R},{cell.Points.Count},{cell.Points.Count(point=>point.Physical)}"));- var hash=Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(string.Join("|",orderedKeys)+$"|{nx}|{ny}|{p}|{qOrder}|{settings.FictitiousStiffnessFactor:R}|{settings.MaxSubdivisionDepth}|{settings.GeometryMap}|{integrationFingerprint}"))).ToLowerInvariant();- var evidence=new ExperimentalShellEvidence("Experimental - not production-qualified",settings.GeometryMap.ToString(),bounds,nx,ny,p,"Tensor hierarchical integrated-Legendre p-space",settings.ThicknessMeters,settings.FictitiousStiffnessFactor,qOrder,settings.MaxSubdivisionDepth,- plans.Count(x=>x.Classification==ContinuumBoundsClassification.Inside),cut.Length,plans.Count(x=>x.Classification==ContinuumBoundsClassification.Outside),plans.Sum(x=>x.CutLeaves),cut.Length==0?1:cut.Min(x=>x.PhysicalFraction),minDet,maxDet,[-1,0,1],hash);+ var integrationFingerprint=string.Join(";",plans.Select(cell=>$"{cell.Patch.Id},{cell.I},{cell.J},{cell.Classification},{cell.PhysicalFraction:R},{cell.Points.Count},{cell.Points.Count(point=>point.Physical)}"));+ var hash=Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(string.Join("|",representatives)+$"|{nx}|{ny}|{p}|{qOrder}|{settings.FictitiousStiffnessFactor:R}|{settings.MaxSubdivisionDepth}|{settings.GeometryMap}|{integrationFingerprint}"))).ToLowerInvariant();+ var solverEvidence=new ExperimentalLinearSolverEvidence(useScaling,minScale,maxScale,preconditioner.Name,diagonalShift,factorizationRetries,preconditionerTime,"RelativeResidualSatisfied",stagnation,convergence.InitialResidual,convergence.FinalResidual,finalPhysicalResidual,convergence.ResidualHistory,selectionPolicy,selectedUtility,rejectedCandidates,convergence.PreconditionedResidualHistory);+ var nativeEvidence=analysis.MidsurfacePatchGraph is null?null:new NativeSheetMetalShellEvidence(+ analysis.MidsurfacePatchGraph.AnalysisSource.ToString(),analysis.MidsurfacePatchGraph.SheetMetalBody,analysis.MidsurfacePatchGraph.Material,analysis.MidsurfacePatchGraph.Patches.Count,+ analysis.MidsurfacePatchGraph.PanelPatchCount,analysis.MidsurfacePatchGraph.BendPatchCount,analysis.MidsurfacePatchGraph.OpeningCount,analysis.MidsurfacePatchGraph.Interfaces.Count,+ (uniqueKeys.Length-representatives.Length)*3,analysis.MidsurfacePatchGraph.Interfaces.Count==0?0:analysis.MidsurfacePatchGraph.Interfaces.Max(x=>x.MaximumMismatchMeters),+ analysis.MidsurfacePatchGraph.Patches.Select(x=>x.Identity).ToArray(),analysis.MidsurfacePatchGraph.Interfaces.Select(x=>$"{x.Identity}:{x.Orientation}").ToArray());+ var evidence=new ExperimentalShellEvidence("Experimental - not production-qualified",analysis.MidsurfacePatchGraph is null?settings.GeometryMap.ToString():"NativeSheetMetalPatchGraph",bounds,nx,ny,p,"Tensor hierarchical integrated-Legendre p-space",settings.ThicknessMeters,settings.FictitiousStiffnessFactor,qOrder,settings.MaxSubdivisionDepth,+ plans.Count(x=>x.Classification==ContinuumBoundsClassification.Inside),cut.Length,plans.Count(x=>x.Classification==ContinuumBoundsClassification.Outside),plans.Sum(x=>x.CutLeaves),cut.Length==0?1:cut.Min(x=>x.PhysicalFraction),minDet,maxDet,[-1,0,1],hash,solverEvidence,nativeEvidence);diagnostics.Add(new("thinwall-experimental",AnalysisDiagnosticSeverity.Warning,"ExperimentalShell is a research discretization and is not production-qualified FEA.",analysis.Provenance));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(x=>new CellStrainResult(x.I,x.J,x.K,x.Position,x.Strain)).ToArray():[];var stressFields=wantsStress?fields.Select(x=>new CellStressResult(x.I,x.J,x.K,x.Position,x.StressPascal,x.VonMisesPascal)).ToArray():[];return new(analysis.Id,true,convergence,reportedDisplacements,reportedFields,analysis.RequestedFields.Contains(AnalysisResultField.ReactionForce)?reactions:[],equilibrium,system,new(fractions.Length==0?0:fractions[0],fractions.Count(x=>x<.01),fractions.Count(x=>x<.05),fractions.Count(x=>x<.1),fractions),- new(domainTime,TimeSpan.Zero,assemblyTime,boundaryTime,solveTime,recoveryTime,(long)rawMatrix.Nonzeros*(sizeof(double)+sizeof(int)),(long)(displacements.Count+fields.Count)*64),diagnostics,loadEvidence,null,energy,[],strainFields,stressFields,evidence);+ new(domainTime,TimeSpan.Zero,assemblyTime,boundaryTime,solveTime,recoveryTime,(long)rawMatrix.Nonzeros*(sizeof(double)+sizeof(int)),(long)(displacements.Count+fields.Count)*64),diagnostics,loadEvidence,null,energy,[],strainFields,stressFields,evidence,bodyLoadEvidence);}private static IReadOnlyList<LocalMode> LocalModesFor(int p){var result=new List<LocalMode>();for(var t=0;t<=p;t++)for(var s=0;s<=p;s++)for(var r=0;r<=p;r++)result.Add(new(r,s,t));return result;}- private static BasisKey Key(int i,int j,LocalMode m)=>new(Axis(i,m.R),Axis(j,m.S),Axis(0,m.T));+ private static BasisKey Key(string patch,int i,int j,LocalMode m)=>new(patch,Axis(i,m.R),Axis(j,m.S),Axis(0,m.T));private static AxisKey Axis(int cell,int mode)=>mode switch{0=>new(true,cell,0),1=>new(true,cell+1,0),_=>new(false,cell,mode)};+ private static IReadOnlyList<AxisKey> UniqueAxisKeys(int cells,int p)=>Enumerable.Range(0,cells+1).Select(x=>new AxisKey(true,x,0)).Concat(Enumerable.Range(0,cells).SelectMany(cell=>Enumerable.Range(2,Math.Max(0,p-1)).Select(mode=>new AxisKey(false,cell,mode)))).ToArray();+ private static (AxisKey Key,double Sign) Reverse(AxisKey key,int cells)=>key.IsVertex?(new(true,cells-key.Location,0),1):(new(false,cells-1-key.Location,key.Mode),key.Mode%2==0?1:-1);+ private static BasisKey EdgeBasis(string patch,MidsurfacePatchEdge edge,AxisKey tangent,AxisKey through,int nx,int ny)=>edge switch+ {+ MidsurfacePatchEdge.RMinimum=>new(patch,new(true,0,0),tangent,through),+ MidsurfacePatchEdge.RMaximum=>new(patch,new(true,nx,0),tangent,through),+ MidsurfacePatchEdge.SMinimum=>new(patch,tangent,new(true,0,0),through),+ _=>new(patch,tangent,new(true,ny,0),through)+ };+ private static int EdgeCellCount(MidsurfacePatchEdge edge,int nx,int ny)=>edge is MidsurfacePatchEdge.RMinimum or MidsurfacePatchEdge.RMaximum?ny:nx;+ private static double EdgeSpan(PatchContext patch,MidsurfacePatchEdge edge)=>edge is MidsurfacePatchEdge.RMinimum or MidsurfacePatchEdge.RMaximum?patch.Bounds.Max.Y-patch.Bounds.Min.Y:patch.Bounds.Max.X-patch.Bounds.Min.X;+ private static Vector3D NormalOnEdge(PatchContext patch,MidsurfacePatchEdge edge)+ {+ var b=patch.Bounds;var r=edge switch{MidsurfacePatchEdge.RMinimum=>b.Min.X,MidsurfacePatchEdge.RMaximum=>b.Max.X,_=>(b.Min.X+b.Max.X)/2};var s=edge switch{MidsurfacePatchEdge.SMinimum=>b.Min.Y,MidsurfacePatchEdge.SMaximum=>b.Max.Y,_=>(b.Min.Y+b.Max.Y)/2};return patch.Evaluate(r,s,0).DerivativeT;+ }private static string AxisSort(AxisKey key)=>$"{key.Location:D6}:{(key.IsVertex?0:1)}:{key.Mode:D3}";private static double Component(Vector3D value,DisplacementComponent component)=>component switch{DisplacementComponent.X=>value.X,DisplacementComponent.Y=>value.Y,_=>value.Z};@@ -269,6 +373,8 @@ public static class ThinWallFiniteCellSolverprivate static double[,] Constitutive(double e,double nu){var d=new double[6,6];var factor=e/((1+nu)*(1-2*nu));var a=(1-nu)*factor;var b=nu*factor;var g=e/(2*(1+nu));d[0,0]=d[1,1]=d[2,2]=a;d[0,1]=d[0,2]=d[1,0]=d[1,2]=d[2,0]=d[2,1]=b;d[3,3]=d[4,4]=d[5,5]=g;return d;}private static double[] Multiply(double[,] matrix,IReadOnlyList<double> vector){var result=new double[matrix.GetLength(0)];for(var i=0;i<result.Length;i++)for(var j=0;j<vector.Count;j++)result[i]+=matrix[i,j]*vector[j];return result;}private static double Dot(IReadOnlyList<double> a,IReadOnlyList<double> b){var result=0d;for(var i=0;i<a.Count;i++)result+=a[i]*b[i];return result;}+ private static double Norm(IReadOnlyList<double> values)=>double.Sqrt(Dot(values,values));+ private static int? StagnationOnset(IReadOnlyList<double> history){const int window=100;for(var i=window;i<history.Count;i++)if(history[i]>history[i-window]*.999)return i-window;return null;}private static double VonMises(SymmetricTensor s)=>double.Sqrt(.5*(double.Pow(s.XX-s.YY,2)+double.Pow(s.YY-s.ZZ,2)+double.Pow(s.ZZ-s.XX,2))+3*(s.XY*s.XY+s.YZ*s.YZ+s.XZ*s.XZ));private static bool TryFace(string path,out BoundaryFace face)@@ -281,22 +387,57 @@ public static class ThinWallFiniteCellSolverif(path.Contains("+Z",StringComparison.OrdinalIgnoreCase)||path.Contains("z-max",StringComparison.OrdinalIgnoreCase)){face=new(2,true,"t-max");return true;}face=default;return false;}+ private static bool TryBoundary(string path,LinearElasticAnalysisIr analysis,IReadOnlyList<PatchContext> patches,out PatchContext patch,out BoundaryFace face)+ {+ if(analysis.MidsurfacePatchGraph is null){patch=patches.Single();return TryFace(path,out face);}+ var prefix=analysis.Body.Id+".";var relative=path.StartsWith(prefix,StringComparison.Ordinal)?path[prefix.Length..]:path;var split=relative.LastIndexOf('.');+ var found=split>0?patches.SingleOrDefault(x=>x.Id.Equals(relative[..split],StringComparison.Ordinal)):null;if(found is not null&&TryPatchFace(relative[(split+1)..],out face)){patch=found;return true;}+ patch=null!;face=default;return false;+ }+ private static bool TryPatchFace(string token,out BoundaryFace face)+ {+ switch(token.ToLowerInvariant())+ {+ case "r-min":case "rminimum":face=new(0,false,"r-min");return true;+ case "r-max":case "rmaximum":face=new(0,true,"r-max");return true;+ case "s-min":case "sminimum":face=new(1,false,"s-min");return true;+ case "s-max":case "smaximum":face=new(1,true,"s-max");return true;+ case "t-min":case "tminimum":face=new(2,false,"t-min");return true;+ case "t-max":case "tmaximum":face=new(2,true,"t-max");return true;+ default:face=default;return false;+ }+ }private static bool OnFace(BasisKey key,BoundaryFace face,int nx,int ny){var axis=face.Axis switch{0=>key.R,1=>key.S,_=>key.T};var max=face.Axis switch{0=>nx,1=>ny,_=>1};return axis.IsVertex&&axis.Location==(face.Maximum?max:0);}- private static IReadOnlyList<CellPlan> BoundaryCells(IReadOnlyList<CellPlan> plans,BoundaryFace face,int nx,int ny)=>plans.Where(x=>face.Axis switch{0=>x.I==(face.Maximum?nx-1:0),1=>x.J==(face.Maximum?ny-1:0),_=>true}).ToArray();+ private static IReadOnlyList<CellPlan> BoundaryCells(IReadOnlyList<CellPlan> plans,PatchContext patch,BoundaryFace face,int nx,int ny)=>plans.Where(x=>x.Patch==patch&&(face.Axis switch{0=>x.I==(face.Maximum?nx-1:0),1=>x.J==(face.Maximum?ny-1:0),_=>true})).ToArray();private readonly record struct BoundarySample(double R,double S,double Xi,double Eta,double Zeta,Point3D Position,Vector3D Normal,double Weight);- private static IEnumerable<BoundarySample> BoundarySamples(CellPlan cell,BoundaryFace face,int order,ThinWallGeometryMap map,BoundingBox3D bounds)+ private static IEnumerable<BoundarySample> BoundarySamples(CellPlan cell,BoundaryFace face,int order){var gauss=Gauss(order);foreach(var a in gauss)foreach(var b in gauss){double r,s,t,xi,eta,zeta,scale;Vector3D tangentA,tangentB;- if(face.Axis==0){r=face.Maximum?cell.R1:cell.R0;s=(cell.S0+cell.S1)/2+a.X*(cell.S1-cell.S0)/2;t=b.X;xi=face.Maximum?1:-1;eta=a.X;zeta=b.X;var e=map.Evaluate(r,s,t);tangentA=e.DerivativeS;tangentB=e.DerivativeT;scale=(cell.S1-cell.S0)/2;var cross=tangentA.Cross(tangentB);var normal=Normalize(cross);if(!face.Maximum)normal=-normal;yield return new(r,s,xi,eta,zeta,e.Position,normal,a.W*b.W*scale*cross.Length);}- else if(face.Axis==1){r=(cell.R0+cell.R1)/2+a.X*(cell.R1-cell.R0)/2;s=face.Maximum?cell.S1:cell.S0;t=b.X;xi=a.X;eta=face.Maximum?1:-1;zeta=b.X;var e=map.Evaluate(r,s,t);tangentA=e.DerivativeT;tangentB=e.DerivativeR;scale=(cell.R1-cell.R0)/2;var cross=tangentA.Cross(tangentB);var normal=Normalize(cross);if(!face.Maximum)normal=-normal;yield return new(r,s,xi,eta,zeta,e.Position,normal,a.W*b.W*scale*cross.Length);}- else{r=(cell.R0+cell.R1)/2+a.X*(cell.R1-cell.R0)/2;s=(cell.S0+cell.S1)/2+b.X*(cell.S1-cell.S0)/2;t=face.Maximum?1:-1;xi=a.X;eta=b.X;zeta=t;var e=map.Evaluate(r,s,t);tangentA=e.DerivativeR;tangentB=e.DerivativeS;scale=(cell.R1-cell.R0)*(cell.S1-cell.S0)/4;var cross=tangentA.Cross(tangentB);var normal=Normalize(cross);if(!face.Maximum)normal=-normal;yield return new(r,s,xi,eta,zeta,e.Position,normal,a.W*b.W*scale*cross.Length);}+ if(face.Axis==0){r=face.Maximum?cell.R1:cell.R0;s=(cell.S0+cell.S1)/2+a.X*(cell.S1-cell.S0)/2;t=b.X;xi=face.Maximum?1:-1;eta=a.X;zeta=b.X;var e=cell.Patch.Evaluate(r,s,t);tangentA=e.DerivativeS;tangentB=e.DerivativeT;scale=(cell.S1-cell.S0)/2;var cross=tangentA.Cross(tangentB);var normal=Normalize(cross);if(!face.Maximum)normal=-normal;yield return new(r,s,xi,eta,zeta,e.Position,normal,a.W*b.W*scale*cross.Length);}+ else if(face.Axis==1){r=(cell.R0+cell.R1)/2+a.X*(cell.R1-cell.R0)/2;s=face.Maximum?cell.S1:cell.S0;t=b.X;xi=a.X;eta=face.Maximum?1:-1;zeta=b.X;var e=cell.Patch.Evaluate(r,s,t);tangentA=e.DerivativeT;tangentB=e.DerivativeR;scale=(cell.R1-cell.R0)/2;var cross=tangentA.Cross(tangentB);var normal=Normalize(cross);if(!face.Maximum)normal=-normal;yield return new(r,s,xi,eta,zeta,e.Position,normal,a.W*b.W*scale*cross.Length);}+ else{r=(cell.R0+cell.R1)/2+a.X*(cell.R1-cell.R0)/2;s=(cell.S0+cell.S1)/2+b.X*(cell.S1-cell.S0)/2;t=face.Maximum?1:-1;xi=a.X;eta=b.X;zeta=t;var e=cell.Patch.Evaluate(r,s,t);tangentA=e.DerivativeR;tangentB=e.DerivativeS;scale=(cell.R1-cell.R0)*(cell.S1-cell.S0)/4;var cross=tangentA.Cross(tangentB);var normal=Normalize(cross);if(!face.Maximum)normal=-normal;yield return new(r,s,xi,eta,zeta,e.Position,normal,a.W*b.W*scale*cross.Length);}}}private static Vector3D Normalize(Vector3D value){var length=value.Length;if(!double.IsFinite(length)||length<=0)throw new ThinWallMapException("thinwall-map-singular","Thin-wall boundary map produced a singular surface Jacobian.");return value*(1/length);}+ private sealed class SignedBasisUnion+ {+ private readonly Dictionary<BasisKey,BasisKey> parent;private readonly Dictionary<BasisKey,double> weight;+ public SignedBasisUnion(IEnumerable<BasisKey> keys){parent=keys.ToDictionary(x=>x,x=>x);weight=keys.ToDictionary(x=>x,_=>1d);}+ public (BasisKey Root,double Sign) Find(BasisKey key)+ {+ var p=parent[key];if(p==key)return(key,1);var found=Find(p);weight[key]*=found.Sign;parent[key]=found.Root;return(found.Root,weight[key]);+ }+ public void Join(BasisKey a,BasisKey b,double parity)+ {+ var fa=Find(a);var fb=Find(b);if(fa.Root==fb.Root){if(double.Abs(fb.Sign-parity*fa.Sign)>1e-12)throw new ThinWallMapException("thinwall-sheetmetal-interface-orientation","Patch interface orientation constraints are inconsistent at a multipatch junction.");return;}+ parent[fb.Root]=fa.Root;weight[fb.Root]=parity*fa.Sign/fb.Sign;+ }+ }+private static LinearElasticAnalysisResult Failure(LinearElasticAnalysisIr analysis,IReadOnlyList<AnalysisDiagnostic> diagnostics,SolverConvergence? convergence=null)=>new(analysis.Id,false,convergence??new(false,0,0,0,[],TimeSpan.Zero),[],[],[],new(Vector3D.Zero,Vector3D.Zero,Vector3D.Zero),new(0,0,0,true,true,0,0),new(0,0,0,0,[]),new(TimeSpan.Zero,TimeSpan.Zero,TimeSpan.Zero,TimeSpan.Zero,TimeSpan.Zero,TimeSpan.Zero,0,0),diagnostics);}diff --git a/Aetheris.SheetMetal/SheetMetalAuthoredLowering.cs b/Aetheris.SheetMetal/SheetMetalAuthoredLowering.csindex 47f60aa9..a15690cd 100644--- a/Aetheris.SheetMetal/SheetMetalAuthoredLowering.cs+++ b/Aetheris.SheetMetal/SheetMetalAuthoredLowering.cs@@ -160,7 +160,9 @@ internal static class AuthoredSheetMetalCompilerreliefWidth > 0 ? reliefWidth : null, reliefDepth > 0 ? reliefDepth : null,spanLength > 0 ? spanLength : null, spanOffset,startTermination,endTermination));}- if (flanges.Count == 0) return Fail("At least one Flange is required.");+ // A flat blank is still a complete native SheetMetal part. Keeping it in+ // the same AIR is important for manufacturing and analysis parity; bends+ // are capabilities of a sheet-metal part, not a validity requirement.var duplicate = flanges.GroupBy(f => (f.ParentRegion.ToLowerInvariant(), f.EdgeName.ToLowerInvariant())).FirstOrDefault(g => g.Count() > 1);if (duplicate is not null)return Fail($"Multiple flanges target {duplicate.First().ParentRegion}.{duplicate.First().EdgeName}.", SheetMetalDiagnosticCodes.DuplicateFlange);diff --git a/docs/public/firmament/fea.md b/docs/public/firmament/fea.mdindex 30d15996..3d0a04f7 100644--- a/docs/public/firmament/fea.md+++ b/docs/public/firmament/fea.md@@ -41,3 +41,34 @@ Native selectors preserve the body identifier: the example uses `Beam.face(-X)`Native Box analysis also consumes one canonical face-local `Hole<Shaft>` with `On: +Z` or `On: -Z` and `End: ThroughAll`. The analysis compiler uses the parsed diameter and center, so the opening removes occupied material. It maps the Box-centered CAD coordinates into the existing native analysis `[0, Size]` coordinate frame. Multiple semantic holes, side holes, counterbores, blind holes, construction-plane placements, and mixed hole/edge-finish modifications require the exported STEP analysis route and fail with `firmament-analysis-native-feature-unsupported` in this native lane. The complete [investor plate witness](../../../fixtures/InvestorPitch/loaded-plate-native.firmament) exercises this path.The `build` command consumes geometry sources, while `fea` consumes sources containing `Analysis`. For a shared geometry and analysis demonstration, export the geometry file first and analyze that exact file with `inlineSTEP`; the report records the geometry hash. See [the reproducible investor demonstration](../investor-pitch.md).++## Experimental thin-wall analysis of native Sheet Metal++`Mode: ExperimentalShell` is a separate research lane. For an authored native `SheetMetal` body it derives thickness, material, planar panels, finite-radius cylindrical bends, openings, and adjacency from semantic Sheet Metal authority. Do not repeat thickness or construct a midsurface in the `Analysis` block. Imported/reconstructed BRep is not accepted as native thin-wall authority.++```firmament+Analysis LinearElastic NativeBracketLoad {+ Body: LBracket+ Mode: ExperimentalShell+ MasterGrid: [2, 2]+ Order: 2+ Fixed Clamp { Region: LBracket.Main.r-max }+ Force Tip {+ Region: LBracket.Wall.s-max+ Vector: [0N, 0N, -10N]+ }+ Results: [Displacement, Strain, Stress, ReactionForce, StrainEnergy]+}+```++Native patch boundaries use `<Body>.<Patch>.r-min|r-max|s-min|s-max`. Adjacent conforming panel/bend traces share global displacement degrees of freedom; opposite edge orientation is handled explicitly. Unsupported partial-edge interfaces and openings crossing a bend fail rather than being approximated.++Uniform gravity-like loading is available in this experimental lane when the material has density:++```firmament+BodyForce Gravity {+ Acceleration: [0m/s2, 0m/s2, -9.81m/s2]+}+```++The default experimental solver uses symmetric diagonal equilibration and bounded shifted IC(0). These are solver policy, not ordinary authoring choices. CLI-only diagnostic overrides can compare `identity`, `jacobi`, `block-jacobi`, and `ic0`. Output remains labeled `Experimental - not production-qualified` and includes the midsurface patch graph, selected solver policy, residual trace, and deterministic SVG/JSON diagnostics.diff --git a/docs/release/FEA-SHELL-X1.md b/docs/release/FEA-SHELL-X1.mdnew file mode 100644index 00000000..eee4bfc3--- /dev/null+++ b/docs/release/FEA-SHELL-X1.md@@ -0,0 +1,126 @@+# FEA-SHELL-X1 — native sheet-metal authority and thin-wall conditioning++## Executive verdict++**Accepted for the explicitly experimental lane.** `ExperimentalShell` now consumes authored native `SheetMetalPartIr`, projects a read-only analytic midsurface patch graph with finite-radius bends, shares conforming C0 displacement modes across patch interfaces, and solves the formerly failing `L/t=200` system in 1,592 iterations. It remains labeled experimental and does not change or replace production solid FEA.++The real investor bracket was attempted without duplicating its geometry. It fails closed because its rounded bend terminations create partial-edge interfaces that X1's conforming full-edge coupling cannot represent. This is a precise X2 nonconforming/subdivision requirement, not a reason to weaken native authority.++## Frozen X0 baseline++The X0 mechanics are unchanged: the same three-displacement 3D strain operator, isotropic constitutive law, thin-wall map equation, hierarchical integrated-Legendre basis, alpha semantics, and recursive cut quadrature remain authoritative.++| Witness | Frozen X0 result | X1 regression |+|---|---:|---:|+| Perforated plate, 2x2, p=1/2/3/4, scaled energy | 0.479279 / 0.585525 / 0.659484 / 0.689749 | focused regression passes |+| Perforated plate p=4 reference error | 1.77% vs screenshot-derived 0.7021812127 | unchanged |+| Flat cantilever p=3 | 1.21026 mm; 3.18% low | 1.21026 mm |+| Thickness sweep L/t=10/50/100 | 1.08% / 3.18% / 3.56% error | unchanged physical results |+| Alpha 1e-8/1e-10/1e-12 | relative energy spread below 1.1e-8 | focused regression passes |+| Production solid cantilever | 5.39309699e-5 m; 56 iterations | unchanged |++No X0 formulation defect was found or corrected in X1.++## Sheet-metal authority audit++| Question | Existing authority used by analysis |+|---|---|+| Thickness | `SheetMetalPartIr.Thickness`; converted once from mm to m |+| Flat panel reference surface | `SheetRegionIr.Plane` plus its exact semantic contour |+| Bend axis/radius/angle | `SheetBendIr` and the corresponding `SheetRegionIr.Cylinder` |+| Structural midsurface radius | `inside radius + thickness/2`, exposed as `GeometricMidRadius` |+| Adjacency | `SheetBendIr.AdjacentRegionA/B` plus semantic region correspondence |+| Openings | `SheetFeatureIr` ownership and analytic profile, lowered as trim exclusions |+| Formed versus flat relation | existing region/bend identities and SheetMetal flattening correspondence; the analysis consumes formed authority |+| Semantic versus reconstructed geometry | only authored, `Complete` native SheetMetal AIR is admitted; recovered/reconstructed BRep is rejected |++The structural surface is the geometric material midsurface. The manufacturing K-factor locates the neutral axis used for bend allowance and is deliberately not used as the structural midsurface. Native analysis never pairs STEP faces, measures opposite BRep faces, or infers adjacency by proximity.++## Analysis projection and coupling++`ThinWallAnalysisAuthority` projects, but does not own, product geometry:++`SheetMetalPartIr -> MidsurfacePatchGraph -> analytic patch maps/trims -> X0 finite cells -> shared global 3D displacement system`++Planar patches use deterministic local frames. Cylindrical patches use axial coordinate `r`, arc-length coordinate `s`, and normalized thickness coordinate `t` in `[-1,+1]`. Both sides of every semantic interface are mapped and compared within `1e-8 m`; mismatch fails with `thinwall-sheetmetal-interface-mismatch`.++Conforming edge modes are unioned before global numbering. Reversed parameter directions explicitly reverse vertex order and apply hierarchical-mode parity. Thus `u_A = u_B` by construction; no duplicate edge solutions are averaged. Material-normal consistency is independently checked. X1 intentionally rejects unequal edge spans/partitions, crossing openings, and nonmanifold ambiguity.++| Witness | Patches | Interfaces/orientation | Openings | Shared displacement DOFs | DOFs | Iterations | Max displacement | Equilibrium residual |+|---|---:|---|---:|---:|---:|---:|---:|---:|+| Native flat | 1 panel | none | 0 | 0 | 624 | 154 | 1.21026155e-3 m | 3.55e-7 N |+| Native L bracket | 2 panels + 1 bend | Same, Same | 0 | 90 | 585 | 260 | 1.82293756e-3 m | 6.57e-7 N |+| Native U channel | 3 panels + 2 bends | Same, Same, Reversed, Same | 2 | 180 | 945 | 1,519 | 4.25714580e-4 m | 3.61e-8 N |++The native-flat displacement differs from the synthetic X0 flat result by only `2.79e-8` relative. Shared identity makes interface displacement jump numerically zero. Stress is retained per patch and sampled at `t=-1,0,+1`; no bend-gradient averaging or classical shell resultant is introduced.++## Conditioning evidence++The `L/t` sweep keeps the X0 grid at 4 cells, p=3, and 624 DOFs. Matrix metrics, residual history, scaling range, IC shift/retries, and timing are emitted in JSON. The X1 default is symmetric diagonal equilibration followed by shifted IC(0).++| L/t | Policy | Iterations | Final solver residual | Displacement | Reference error | Equilibrium | Verdict |+|---:|---|---:|---:|---:|---:|---:|---|+| 50 | Jacobi, unscaled | 1,385 | 5.06e-8 | 1.21026158e-3 m | 3.18% | 5.25e-8 N | baseline passes |+| 50 | equilibration + IC(0) | 1,009 | 7.58e-13 | 1.21026158e-3 m | 3.18% | 5.89e-8 N | passes |+| 100 | Jacobi, unscaled | 4,916 | 4.52e-8 | 9.64360013e-3 m | 3.56% | 1.78e-7 N | baseline passes |+| 100 | equilibration + IC(0) | 3,216 | 4.83e-13 | 9.64360010e-3 m | 3.56% | 1.27e-7 N | passes |+| 200 | Jacobi, unscaled | 10,000 | 2.29e-4 | none | — | — | stalls |+| 200 | equilibration + IC(0) | **1,592** | 3.52e-13 | 7.70232642e-2 m | 3.72% | 7.99e-6 N | **qualifies** |+| 500 | Jacobi, unscaled | 10,000 | 1.83e2 | none | — | — | stalls |+| 500 | equilibration + IC(0) | 6,729 | 2.44e-13 | 1.20278659 m | 3.78% | 6.74e-4 N | algebraic solve only; equilibrium not qualified |++At L/t=200, identity, Jacobi, equilibration alone, equilibration+Jacobi, and equilibration+3x3 block Jacobi all reach the 10,000-iteration cap. Block Jacobi is useful evidence, not the winner: at L/t=100 it takes 6,073 iterations versus 6,612 for equilibration+Jacobi and 3,216 for equilibration+IC(0).++IC stabilization is a bounded policy decision. Six fixed candidates use shifts `[0, 1e-8, 1e-6, 1e-4, 1e-2, 1] * max(diagonal)`. Every candidate is factored deterministically; admissibility is successful positive-pivot construction. `JudgmentEngine` selects the smallest admissible shift by utility and the report records the selected utility, failed candidates, chosen shift, and retry count. It chooses policy only; it never changes geometry, mechanics, or engineering intent.++The p=2..6 L/t=100 study converges in 324 / 3,216 / 764 / 842 / 910 iterations, with displacements 9.36861 / 9.64360 / 9.73460 / 9.76148 / 9.77806 mm. The p=3 shift requires the largest bounded stabilization in this set; this non-monotonic conditioning is exactly why selection is measured rather than inferred from p alone.++## Curved trim and body force++`BodyForce` now integrates `density * acceleration` using the same mapped volume quadrature, physical Jacobian, trim classification, and alpha-scaled fictitious contribution as stiffness assembly. The curved 40-degree, R=200 mm, t=2 mm perforated witness passes with finite continuum fields and reaction equilibrium. The complete modified Scordelis–Lo result is not claimed: a trustworthy paper comparison still requires verified symmetry-coordinate assignment and benchmark reference extraction beyond the supplied screenshot-level information.++## Investor bracket attempt++| Field | Result |+|---|---|+| Native sheet authority | yes; original authored fixture reused unchanged |+| Patch/DOF/solve results | unavailable because projection correctly fails before discretization |+| Blocker | `thinwall-sheetmetal-interface-mismatch` |+| Evidence | both bend-to-panel curves differ by 0.0020000000000000018 m |+| Cause | rounded bend terminations make the cylindrical interface a proper subset of the unsplit panel edge |+| Overall verdict | not qualified; needs semantic panel-edge subdivision or nonconforming coupling |++DFM status remains independent. No benchmark-only midsurface, nearest-edge match, or geometry averaging was added.++## CLI and artifacts++Ordinary authors select only `Mode: ExperimentalShell`; the qualified solver policy is automatic. Debug-only CLI switches are `--experimental-preconditioner identity|jacobi|block-jacobi|ic0` and `--experimental-equilibration true|false`.++```powershell+dotnet run --project Aetheris.CLI -c Release -- fea fixtures/Canonical/FEA/ExperimentalShell/native-l-bracket.firmament --out-dir artifacts/local/fea-shell-x1/native-l-bracket --json+powershell -ExecutionPolicy Bypass -File scripts/qualify-fea-shell-x1.ps1+powershell -ExecutionPolicy Bypass -File scripts/qualify-fea-shell-x1-investor.ps1+```++Per-run output includes `analysis-ir.json`, `midsurface-patch-graph.json`, solver/system/residual JSON, parameter-domain and mapped/deformed SVGs, boundary/body-force quadrature, and continuum result summaries. Generated evidence remains under ignored `artifacts/local/fea-shell-x1/`.++## Remaining evidence-driven limits++- X2: semantic edge subdivision or nonconforming coupling for partial-edge bend interfaces, proven by the investor bracket.+- X2: tiny-cut stabilization/aggregation only if a dedicated worsening cut-fraction sweep shows IC/equilibration is insufficient. The offset-cut regression remains finite; no ghost penalty was justified in X1.+- Complete modified Scordelis–Lo reference qualification after its exact symmetry and reference data are independently verified.+- General imported thin-wall recognition, nonlinear geometry, buckling, plasticity, and contact remain out of scope.++## Validation++Validation completed on 2026-09-12:++- Release solution build: passed with zero warnings and zero errors.+- Complete FEA regression: 43/43 passed, including all X0 cases, native flat parity, single/multi-bend coupling, alpha, offset cut, curved trim/body force, equilibrium, deterministic repeat, and typed invalid authority.+- Complete solution test run, serialized: 3,391 tests passed across the test-bearing projects; `Aetheris.FrictionLab.Tests` contains no discoverable tests. A prior parallel run transiently failed one unrelated tessellation determinism test, which passed immediately alone and again in the serialized 961-test Kernel.Core run.+- Production cantilever: unchanged at 56 iterations and 5.393096992e-5 m; equilibrium residual 2.30e-9 N.+- Canonical qualification: 167/167 fixtures passed.+- Fresh CLI publish outside the repository: native single bend passed in 260 iterations; L/t=200 passed in 1,592 iterations at 0.0770232642 m.+- Curved body-force CLI witness: 753 iterations, 9.57344e-5 m, 8.32342 N gravity resultant, and 2.88e-8 N equilibrium residual.+- Conditioning matrix, p study, investor attempt, native debug artifacts, and deterministic rerun: completed under ignored `artifacts/local/fea-shell-x1/`.+- Modified-document link resolution, repository layout guard (4,030 tracked files), and `git diff --check`: passed.diff --git a/fixtures/Canonical/FEA/ExperimentalShell/curved-body-force-shell.firmament b/fixtures/Canonical/FEA/ExperimentalShell/curved-body-force-shell.firmamentnew file mode 100644index 00000000..1037fc8b--- /dev/null+++ b/fixtures/Canonical/FEA/ExperimentalShell/curved-body-force-shell.firmament@@ -0,0 +1,35 @@+Model CurvedBodyForceWitness {+ Units: mm+ Box Patch { Size: [400mm, 139.626340159546mm, 2mm] }+ Modify Patch {+ Hole<Shaft> Opening {+ On: +Z+ Center: Point2(0mm, 0mm)+ Diameter: 60mm+ End: ThroughAll+ }+ }++ Analysis LinearElastic CurvedBodyForceShell {+ Mode: ExperimentalShell+ Body: Patch+ Material: Standard.Materials.Steel.ASTM_A36+ Thickness: 2mm+ MasterGrid: [4, 4]+ Order: 2+ AlphaFictitious: 1e-12+ MaxSubdivisionDepth: 5+ GeometryMap: Cylindrical+ CylinderRadius: 200mm+ CylinderAngle: 40deg++ Fixed Root {+ Region: Patch.face(-X)+ Components: [X, Y, Z]+ }+ BodyForce Gravity {+ Acceleration: [0m/s2, 0m/s2, -10m/s2]+ }+ Results: [Displacement, Strain, Stress, ReactionForce, StrainEnergy]+ }+}diff --git a/fixtures/Canonical/FEA/ExperimentalShell/native-flat-cantilever.firmament b/fixtures/Canonical/FEA/ExperimentalShell/native-flat-cantilever.firmamentnew file mode 100644index 00000000..dd21d3f0--- /dev/null+++ b/fixtures/Canonical/FEA/ExperimentalShell/native-flat-cantilever.firmament@@ -0,0 +1,21 @@+SheetMetal NativeFlatPlate {+ Thickness: 2mm;+ Material: "Standard.Materials.Steel.ASTM_A36";+ KFactor: 0.42;+ Base Plate { Profile: Rectangle { Width: 100mm; Height: 20mm; }; }+}++Analysis LinearElastic NativeFlatCantilever {+ Body: NativeFlatPlate+ Mode: ExperimentalShell+ MasterGrid: [4, 1]+ Order: 3+ AlphaFictitious: 1e-12+ MaxSubdivisionDepth: 4+ Fixed Root { Region: NativeFlatPlate.Plate.r-min }+ Force Tip {+ Region: NativeFlatPlate.Plate.r-max+ Vector: [0N, 0N, -10N]+ }+ Results: [Displacement, Strain, Stress, ReactionForce, StrainEnergy]+}diff --git a/fixtures/Canonical/FEA/ExperimentalShell/native-l-bracket.firmament b/fixtures/Canonical/FEA/ExperimentalShell/native-l-bracket.firmamentnew file mode 100644index 00000000..851329a0--- /dev/null+++ b/fixtures/Canonical/FEA/ExperimentalShell/native-l-bracket.firmament@@ -0,0 +1,29 @@+// Native SheetMetal AIR is the sole geometry, thickness, material, and adjacency authority.+SheetMetal LBracket {+ Thickness: 1.5mm;+ Material: "Standard.Materials.Aluminum.5052_H32";+ KFactor: 0.42;+ Base Main { Profile: Rectangle { Width: 80mm; Height: 40mm; }; }+ Flange Wall {+ From: Main.Left;+ Length: 25mm;+ Angle: 90deg;+ InsideRadius: 2mm;+ Direction: Up;+ }+}++Analysis LinearElastic NativeLBracket {+ Body: LBracket+ Mode: ExperimentalShell+ MasterGrid: [2, 2]+ Order: 2+ AlphaFictitious: 1e-12+ MaxSubdivisionDepth: 4+ Fixed Clamp { Region: LBracket.Main.r-max }+ Force Tip {+ Region: LBracket.Wall.s-max+ Vector: [0N, 0N, -10N]+ }+ Results: [Displacement, Strain, Stress, ReactionForce, StrainEnergy]+}diff --git a/fixtures/Canonical/FEA/ExperimentalShell/native-u-channel.firmament b/fixtures/Canonical/FEA/ExperimentalShell/native-u-channel.firmamentnew file mode 100644index 00000000..78f2f7bf--- /dev/null+++ b/fixtures/Canonical/FEA/ExperimentalShell/native-u-channel.firmament@@ -0,0 +1,36 @@+SheetMetal NativeUChannel {+ Thickness: 1.5mm;+ Material: "Standard.Materials.Aluminum.5052_H32";+ KFactor: 0.42;+ Base Base { Profile: Rectangle { Width: 100mm; Height: 60mm; }; }+ Flange LeftFlange {+ From: Base.Left;+ Length: 25mm;+ Angle: 90deg;+ InsideRadius: 2mm;+ Direction: Up;+ }+ Flange RightFlange {+ From: Base.Right;+ Length: 20mm;+ Angle: 90deg;+ InsideRadius: 2mm;+ Direction: Up;+ }+ Hole MountA { On: Base; Center: (25mm, 30mm); Diameter: 8mm; }+ Hole MountB { On: Base; Center: (75mm, 30mm); Diameter: 8mm; }+}++Analysis LinearElastic NativeUChannelLoad {+ Body: NativeUChannel+ Mode: ExperimentalShell+ MasterGrid: [2, 2]+ Order: 2+ MaxSubdivisionDepth: 4+ Fixed Clamp { Region: NativeUChannel.Base.s-min }+ Force Tip {+ Region: NativeUChannel.LeftFlange.s-max+ Vector: [0N, 0N, -10N]+ }+ Results: [Displacement, Strain, Stress, ReactionForce, StrainEnergy]+}diff --git a/fixtures/Invalid/FEA/ExperimentalShell/native-sheetmetal-partial-edge-interface.firmament b/fixtures/Invalid/FEA/ExperimentalShell/native-sheetmetal-partial-edge-interface.firmamentnew file mode 100644index 00000000..c85af4e6--- /dev/null+++ b/fixtures/Invalid/FEA/ExperimentalShell/native-sheetmetal-partial-edge-interface.firmament@@ -0,0 +1,27 @@+SheetMetal PartialEdgeBracket {+ Thickness: 2mm;+ Material: "Standard.Materials.Aluminum.5052_H32";+ Base BasePlate { Profile: Rectangle { Width: 100mm; Height: 70mm; }; }+ Flange Upright {+ From: BasePlate.Rear;+ Height: 60mm;+ Angle: 90deg;+ Radius: 3mm;+ Direction: Up;+ StartTermination: Rounded;+ StartTerminationRadius: 2mm;+ EndTermination: Rounded;+ EndTerminationRadius: 2mm;+ }+}++Analysis LinearElastic PartialEdgeAnalysis {+ Body: PartialEdgeBracket+ Mode: ExperimentalShell+ MasterGrid: [2, 2]+ Fixed Clamp { Region: PartialEdgeBracket.BasePlate.s-min }+ Force Tip {+ Region: PartialEdgeBracket.Upright.s-max+ Vector: [0N, 0N, -10N]+ }+}diff --git a/fixtures/Invalid/FEA/ExperimentalShell/native-sheetmetal-thickness-override.firmament b/fixtures/Invalid/FEA/ExperimentalShell/native-sheetmetal-thickness-override.firmamentnew file mode 100644index 00000000..268d58ff--- /dev/null+++ b/fixtures/Invalid/FEA/ExperimentalShell/native-sheetmetal-thickness-override.firmament@@ -0,0 +1,16 @@+SheetMetal InvalidNativeThickness {+ Thickness: 2mm;+ Material: "Standard.Materials.Steel.ASTM_A36";+ Base Plate { Profile: Rectangle { Width: 100mm; Height: 20mm; }; }+}+Analysis LinearElastic InvalidNativeThicknessAnalysis {+ Body: InvalidNativeThickness+ Mode: ExperimentalShell+ Thickness: 3mm+ MasterGrid: [2, 1]+ Fixed Root { Region: InvalidNativeThickness.Plate.r-min }+ Force Tip {+ Region: InvalidNativeThickness.Plate.r-max+ Vector: [0N, 0N, -1N]+ }+}diff --git a/fixtures/Invalid/FEA/ExperimentalShell/native-sheetmetal-unresolved-material.firmament b/fixtures/Invalid/FEA/ExperimentalShell/native-sheetmetal-unresolved-material.firmamentnew file mode 100644index 00000000..8320bc83--- /dev/null+++ b/fixtures/Invalid/FEA/ExperimentalShell/native-sheetmetal-unresolved-material.firmament@@ -0,0 +1,15 @@+SheetMetal InvalidNativeMaterial {+ Thickness: 2mm;+ Material: "Mystery Alloy QX-999";+ Base Plate { Profile: Rectangle { Width: 100mm; Height: 20mm; }; }+}+Analysis LinearElastic InvalidNativeMaterialAnalysis {+ Body: InvalidNativeMaterial+ Mode: ExperimentalShell+ MasterGrid: [2, 1]+ Fixed Root { Region: InvalidNativeMaterial.Plate.r-min }+ Force Tip {+ Region: InvalidNativeMaterial.Plate.r-max+ Vector: [0N, 0N, -1N]+ }+}diff --git a/scripts/qualify-fea-shell-x1-investor.ps1 b/scripts/qualify-fea-shell-x1-investor.ps1new file mode 100644index 00000000..24905bd4--- /dev/null+++ b/scripts/qualify-fea-shell-x1-investor.ps1@@ -0,0 +1,29 @@+param([string]$OutputDirectory = "artifacts/local/fea-shell-x1/investor-bracket")+$ErrorActionPreference = "Stop"+$repo = Split-Path -Parent $PSScriptRoot+$output = [System.IO.Path]::GetFullPath((Join-Path $repo $OutputDirectory))+New-Item -ItemType Directory -Force -Path $output | Out-Null+$nativeSource = Get-Content -LiteralPath (Join-Path $repo "fixtures/InvestorPitch/sheet-metal-bracket.firmament") -Raw+$analysis = @'++Analysis LinearElastic NativeInvestorBracketServiceLoad {+ Body: InvestorBracket+ Mode: ExperimentalShell+ MasterGrid: [2, 2]+ Order: 2+ MaxSubdivisionDepth: 4+ Fixed BaseFront { Region: InvestorBracket.BasePlate.s-min }+ Force UprightServiceLoad {+ Region: InvestorBracket.Upright.s-max+ Vector: [0N, -250N, 0N]+ }+ Results: [Displacement, Strain, Stress, ReactionForce, StrainEnergy]+}+'@+$casePath = Join-Path $output "native-investor-bracket-analysis.firmament"+Set-Content -LiteralPath $casePath -Value ($nativeSource + $analysis) -NoNewline+$raw = & dotnet run --project (Join-Path $repo "Aetheris.CLI") -c Release --no-build -- fea $casePath --out-dir $output --json 2>&1 | Out-String+$exitCode = $LASTEXITCODE+Set-Content -LiteralPath (Join-Path $output "investor-attempt.json") -Value $raw.TrimEnd()+$raw.TrimEnd()+exit $exitCodediff --git a/scripts/qualify-fea-shell-x1.ps1 b/scripts/qualify-fea-shell-x1.ps1new file mode 100644index 00000000..5754b13d--- /dev/null+++ b/scripts/qualify-fea-shell-x1.ps1@@ -0,0 +1,89 @@+param(+ [string]$OutputDirectory = "artifacts/local/fea-shell-x1/conditioning"+)++$ErrorActionPreference = "Stop"+$repo = Split-Path -Parent $PSScriptRoot+$output = [System.IO.Path]::GetFullPath((Join-Path $repo $OutputDirectory))+$sourcePath = Join-Path $repo "fixtures/Canonical/FEA/ExperimentalShell/flat-cantilever.firmament"+$source = Get-Content -LiteralPath $sourcePath -Raw+New-Item -ItemType Directory -Force -Path $output | Out-Null++function Invoke-Case([string]$name,[string]$caseSource,[string[]]$arguments) {+ $casePath = Join-Path $output "$name.firmament"+ Set-Content -LiteralPath $casePath -Value $caseSource -NoNewline+ $raw = & dotnet run --project (Join-Path $repo "Aetheris.CLI") -c Release --no-build -- fea $casePath --json @arguments 2>&1 | Out-String+ $exitCode = $LASTEXITCODE+ Set-Content -LiteralPath (Join-Path $output "$name.json") -Value $raw.TrimEnd()+ try { $report = $raw | ConvertFrom-Json } catch { throw "Case '$name' did not return JSON: $raw" }+ $reference = $null+ $referenceError = $null+ if ($name -match '^lt(?<ratio>\d+)-') {+ $ratio = [double]$Matches.ratio+ $thickness = 0.1 / $ratio+ $reference = 10.0 * [Math]::Pow(0.1,3) / (3.0 * 200e9 * (0.02 * [Math]::Pow($thickness,3) / 12.0))+ if ($null -ne $report.maximumDisplacementMeters) { $referenceError = [Math]::Abs($report.maximumDisplacementMeters - $reference) / $reference }+ }+ [pscustomobject]@{+ name = $name+ success = if ($null -ne $report.success) { [bool]$report.success } else { $exitCode -eq 0 }+ iterations = $report.solver.iterations+ finalSolverResidual = $report.solver.finalResidual+ finalPhysicalResidual = $report.experimentalShell.solver.finalPhysicalResidual+ preconditioner = $report.experimentalShell.solver.preconditioner+ equilibration = $report.experimentalShell.solver.symmetricDiagonalEquilibration+ diagonalShift = $report.experimentalShell.solver.diagonalShift+ factorizationRetries = $report.experimentalShell.solver.factorizationRetries+ minimumScale = $report.experimentalShell.solver.minimumScale+ maximumScale = $report.experimentalShell.solver.maximumScale+ degreesOfFreedom = $report.system.degreesOfFreedom+ minimumDiagonal = $report.system.minimumDiagonal+ maximumDiagonal = $report.system.maximumDiagonal+ diagonalRatio = $report.system.diagonalRatio+ minimumRowNorm = $report.system.minimumRowNorm+ maximumRowNorm = $report.system.maximumRowNorm+ rowNormRatio = $report.system.rowNormRatio+ displacementMeters = $report.maximumDisplacementMeters+ referenceDisplacementMeters = $reference+ relativeReferenceError = $referenceError+ equilibriumResidualNewton = $report.equilibrium.residualNewton.length+ energyJoule = $report.strainEnergy.algebraicJoule+ diagnosticCodes = @($report.diagnostics | ForEach-Object { $_.code } | Where-Object { $null -ne $_ })+ }+}++$policies = @(+ @{ Name = "identity"; Arguments = @("--experimental-preconditioner","identity","--experimental-equilibration","false") },+ @{ Name = "jacobi"; Arguments = @("--experimental-preconditioner","jacobi","--experimental-equilibration","false") },+ @{ Name = "equil"; Arguments = @("--experimental-preconditioner","identity","--experimental-equilibration","true") },+ @{ Name = "equil-jacobi"; Arguments = @("--experimental-preconditioner","jacobi","--experimental-equilibration","true") },+ @{ Name = "equil-block-jacobi"; Arguments = @("--experimental-preconditioner","block-jacobi","--experimental-equilibration","true") },+ @{ Name = "equil-ic0"; Arguments = @("--experimental-preconditioner","ic0","--experimental-equilibration","true") }+)+$matrix = @()+foreach ($ratio in @(50,100,200,500)) {+ $thicknessMillimeters = 100.0 / $ratio+ $token = $thicknessMillimeters.ToString("0.############",[System.Globalization.CultureInfo]::InvariantCulture) + "mm"+ $caseSource = $source.Replace("2mm]",$token + "]").Replace("Thickness: 2mm","Thickness: $token")+ foreach ($policy in $policies) {+ $matrix += Invoke-Case "lt$ratio-$($policy.Name)" $caseSource $policy.Arguments+ }+}++$pStudy = @()+$thinSource = $source.Replace("2mm]","1mm]").Replace("Thickness: 2mm","Thickness: 1mm")+foreach ($order in 2..6) {+ $caseSource = $thinSource.Replace("Order: 3","Order: $order")+ $pStudy += Invoke-Case "p$order-lt100-equil-ic0" $caseSource @("--experimental-preconditioner","ic0","--experimental-equilibration","true")+}++$evidence = [ordered]@{+ schema = "fea-shell-x1-conditioning-v1"+ source = "flat-cantilever.firmament with only semantic thickness/body-thickness and order substitutions"+ fixedMasterGrid = @(4,1)+ maximumIterations = 10000+ matrix = $matrix+ pStudy = $pStudy+}+$evidence | ConvertTo-Json -Depth 8 | Set-Content -LiteralPath (Join-Path $output "conditioning-matrix.json")+$evidence | ConvertTo-Json -Depth 8