From a9dd3e70e23a7449e92bfd99bcd3510a46c02c0c Mon Sep 17 00:00:00 2001 From: hzhang Date: Fri, 21 Jun 2024 23:50:03 +0800 Subject: [PATCH] m6 --- .gitignore | 5 ++ UnitTest1.cs | 17 ++++ VirtualChemistryTest.csproj | 21 +++++ VirtualChemistryTest.sln | 22 +++++ global.json | 7 ++ tests/AtomSoupTest.cs | 80 +++++++++++++++++ tests/AtomTests.cs | 159 +++++++++++++++++++++++++++++++++ tests/BondConnectionTest.cs | 96 ++++++++++++++++++++ tests/MixtureDegenerateTest.cs | 39 ++++++++ tests/ResolvabilityTest.cs | 59 ++++++++++++ tests/Usings.cs | 10 +++ 11 files changed, 515 insertions(+) create mode 100644 .gitignore create mode 100644 UnitTest1.cs create mode 100644 VirtualChemistryTest.csproj create mode 100644 VirtualChemistryTest.sln create mode 100644 global.json create mode 100644 tests/AtomSoupTest.cs create mode 100644 tests/AtomTests.cs create mode 100644 tests/BondConnectionTest.cs create mode 100644 tests/MixtureDegenerateTest.cs create mode 100644 tests/ResolvabilityTest.cs create mode 100644 tests/Usings.cs diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..add57be --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +bin/ +obj/ +/packages/ +riderModule.iml +/_ReSharper.Caches/ \ No newline at end of file diff --git a/UnitTest1.cs b/UnitTest1.cs new file mode 100644 index 0000000..0d2bb48 --- /dev/null +++ b/UnitTest1.cs @@ -0,0 +1,17 @@ +using NUnit.Framework; + +namespace VirtualChemistryTest; + +public class Tests +{ + [SetUp] + public void Setup() + { + } + + [Test] + public void Test1() + { + Assert.Pass(); + } +} \ No newline at end of file diff --git a/VirtualChemistryTest.csproj b/VirtualChemistryTest.csproj new file mode 100644 index 0000000..3048162 --- /dev/null +++ b/VirtualChemistryTest.csproj @@ -0,0 +1,21 @@ + + + + net6.0 + enable + + false + + + + + + + + + + + + + + diff --git a/VirtualChemistryTest.sln b/VirtualChemistryTest.sln new file mode 100644 index 0000000..8efada3 --- /dev/null +++ b/VirtualChemistryTest.sln @@ -0,0 +1,22 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VirtualChemistryTest", "VirtualChemistryTest.csproj", "{D8A30C42-A49B-4096-BF53-32A82B492233}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VirtualChemistry", "..\VirtualChemistry\VirtualChemistry.csproj", "{C1C0E45F-59D4-44C3-A55F-80F44DF2935D}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {D8A30C42-A49B-4096-BF53-32A82B492233}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D8A30C42-A49B-4096-BF53-32A82B492233}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D8A30C42-A49B-4096-BF53-32A82B492233}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D8A30C42-A49B-4096-BF53-32A82B492233}.Release|Any CPU.Build.0 = Release|Any CPU + {C1C0E45F-59D4-44C3-A55F-80F44DF2935D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C1C0E45F-59D4-44C3-A55F-80F44DF2935D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C1C0E45F-59D4-44C3-A55F-80F44DF2935D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C1C0E45F-59D4-44C3-A55F-80F44DF2935D}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection +EndGlobal diff --git a/global.json b/global.json new file mode 100644 index 0000000..1bcf6c0 --- /dev/null +++ b/global.json @@ -0,0 +1,7 @@ +{ + "sdk": { + "version": "6.0.0", + "rollForward": "latestMinor", + "allowPrerelease": false + } +} \ No newline at end of file diff --git a/tests/AtomSoupTest.cs b/tests/AtomSoupTest.cs new file mode 100644 index 0000000..400c351 --- /dev/null +++ b/tests/AtomSoupTest.cs @@ -0,0 +1,80 @@ +using System; +using System.Linq; +using VirtualChemistry.Chemistry.Atoms.Implements; +using VirtualChemistry.Chemistry.Atoms.Resolver; +using VirtualChemistry.Chemistry.Compounds.Implements; +using VirtualChemistry.Chemistry.Containers; +using VirtualChemistry.Chemistry.Mixtures.Implements; +using VirtualChemistry.Constants; + +namespace VirtualChemistryTest; + +public static class AtomSoupTest +{ + private static BaseAtom[] AllAtoms() => + ChemistryConstant.ElementSymbols.Select(AtomResolver.Resolve).ToArray(); + private class Container : IChemicalContainer + { + public Container(HeterogeneousMixture h) => Content = h; + public double Volume() => 200; + public HeterogeneousMixture Content { get; set; } + public double EnvironmentPressure { get; set; } + public double EnvironmentTemperature { get; set; } + } + [Test] + public static void AtomSoupTest1() + { + HeterogeneousMixture h = new (); + h.Container = new Container(h); + HomogeneousMixture m = new(); + h.AddLayer(m); + foreach (BaseAtom a in AllAtoms()) + { + Compound c = a.GrabCompound; + a.Compound = c; + c.Amount = 1; + m.AddCompound(c); + } + m.Volume = m.FreeVolume; + h.Container.EnvironmentTemperature = 4.4; + for (int i = 1; i < 50; i++) + h.OneStep(); + Console.WriteLine($"{h.Layers.Count} {h.Layers.Sum(x => x.Volume)} --- {h.FreeVolume}"); + foreach (HomogeneousMixture mx in h.Layers) + { + Console.WriteLine($"{mx.Temperature} ====={mx.FreeVolume}==={mx.Density}={mx.Volume}={mx.CompressionStiffness}"); + foreach (Compound cx in mx.Compounds) + { + var b = cx.Atoms.First().NextUnconnected("m"); + Console.WriteLine($"{cx.Expression}\t\tAMT:{cx.Amount}\t\tRes:{mx.Resolvability(cx)}\t\tE:{b.Energy}"); + } + } + m.RPC(); + } + [Test] + public static void SoTest1() + { + HeterogeneousMixture h = new (); + h.Container = new Container(h); + HomogeneousMixture m = new(); + h.AddLayer(m); + BaseAtom a = new SoAtom(); + a.C(); + Compound c = a.GrabCompound; + a.Compound = c; + c.Amount = 1; + m.AddCompound(c); + m.Volume = m.FreeVolume; + h.Container.EnvironmentTemperature = 2.4; + h.OneStep(); + foreach (HomogeneousMixture mx in h.Layers) + { + Console.WriteLine($"{mx.Temperature} ==================="); + foreach (Compound cx in mx.Compounds) + { + var b = cx.Atoms.First().NextUnconnected("m"); + Console.WriteLine($"{cx.Expression}\t\tAMT:{cx.Amount}\t\tRes:{mx.Resolvability(cx)}\t\tE:{b.Energy}"); + } + } + } +} \ No newline at end of file diff --git a/tests/AtomTests.cs b/tests/AtomTests.cs new file mode 100644 index 0000000..995ef88 --- /dev/null +++ b/tests/AtomTests.cs @@ -0,0 +1,159 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Numerics; +using VirtualChemistry.Chemistry.Atoms.Implements; +using VirtualChemistry.Chemistry.Atoms.Resolver; +using VirtualChemistry.Chemistry.Bonds.Implements; +using VirtualChemistry.Constants; + +namespace VirtualChemistryTest; + +public static class AtomTests +{ + [DatapointSource] + private static readonly BaseAtom[] DataSource = + ChemistryConstant.ElementSymbols.Select(AtomResolver.Resolve).ToArray(); + + private static readonly Action OnFailReport = + atom => Console.WriteLine($" Fail - {atom.Element} - {atom.AtomicNumber}"); + + [Test] + public static void AtomQStepByStep() + { + QAtom atom = new QAtom(); + atom.C(); + MBond b = (atom.Bonds.First() as MBond)!; + Assert.IsNotNull(b); + + SU3 s = b.EigenStateMatrix; + LieSU3 tx = atom.LogEigenState.Get; + Console.WriteLine(tx.PythonRepresentation); + Console.WriteLine(atom.StateMatrix.Get.PythonRepresentation); + var evs = tx.EigenValues(); + foreach (Complex ev in evs) + { + Console.WriteLine($"ev - {ev}"); + } + + evs = atom.StateMatrix.Get.EigenValues(); + foreach (Complex ev in evs) + { + Console.WriteLine($"ev x - {ev}"); + } + + + Console.WriteLine(s.CSharpRepresentation); + Assert.IsTrue(b.StateMatrix.Get.IsEqualApprox(b.EigenStateMatrix)); + Assert.IsTrue(b.LogState.Get.IsEqualApprox(b.StateMatrix.Get.Log())); + Assert.IsTrue(atom.BondInformationMatrix.Get.IsEqualApprox(b.StateMatrix.Get)); + Assert.IsTrue(atom.LogEigenState.Get.IsEqualApprox(atom.EigenStateMatrix.Log())); + Assert.IsTrue((atom.LogEigenState.Get - atom.EigenStateMatrix.Log()).IsEqualApprox(C33.Zero)); + Assert.IsTrue(atom.LogEigenState.Get.Exp().IsEqualApprox(atom.EigenStateMatrix)); + Assert.IsTrue(atom.LogStateMatrix.Get.IsEqualApprox(b.StateMatrix.Get.ConjugateOn(atom.LogEigenState.Get))); + Assert.IsTrue(atom.StateMatrix.Get.IsEqualApprox(b.StateMatrix.Get.ConjugateOn(atom.EigenStateMatrix))); + + } + + [Theory] + public static void AtomMatrixTest(BaseAtom atom) + { + Assert.IsTrue(atom.LogStateMatrix.Get.Exp().IsEqualApprox(atom.StateMatrix.Get)); + } + + [Theory] + public static void BondInfoTest(BaseAtom atom) + { + Console.WriteLine(atom.Element); + foreach(var g in atom.Bonds.GroupBy(a => a.BondType)) + Console.WriteLine($"\t\t{g.Key}, {g.Count()}"); + } + + [Test] + public static void AtomTestQ() + { + QAtom a = new QAtom(); + a.C(); + //LieSU3 x = a.LogStateMatrix.Get; + //SU3 expx = a.StateMatrix.Get; + //Assert.IsTrue(a.LogStateMatrix.Get.Exp().IsEqualApprox(a.StateMatrix.Get)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.M), Is.Not.EqualTo(BaseBond.Null)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.S), Is.EqualTo(BaseBond.Null)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.D), Is.EqualTo(BaseBond.Null)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.Y), Is.EqualTo(BaseBond.Null)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.Q), Is.EqualTo(BaseBond.Null)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.P), Is.EqualTo(BaseBond.Null)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.H), Is.EqualTo(BaseBond.Null)); + Dictionary bondTypeCount = new(); + foreach (BaseBond b in a.Bonds) + { + Assert.IsFalse(b.Connected); + Assert.That(b.Atom, Is.EqualTo(a)); + Assert.That(b.Energy, Is.EqualTo(0)); + if (bondTypeCount.ContainsKey(b.BondType)) + bondTypeCount[b.BondType] += 1; + else + bondTypeCount[b.BondType] = 1; + } + Assert.That(bondTypeCount["m"], Is.EqualTo(1)); + + } + [Test] + public static void AtomTestR() + { + RAtom a = new RAtom(); + a.C(); + Assert.IsTrue(a.LogStateMatrix.Get.Exp().IsEqualApprox(a.StateMatrix.Get)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.M), Is.Not.EqualTo(BaseBond.Null)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.S), Is.Not.EqualTo(BaseBond.Null)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.D), Is.EqualTo(BaseBond.Null)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.Y), Is.EqualTo(BaseBond.Null)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.Q), Is.EqualTo(BaseBond.Null)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.P), Is.EqualTo(BaseBond.Null)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.H), Is.EqualTo(BaseBond.Null)); + Dictionary bondTypeCount = new Dictionary(); + foreach (BaseBond b in a.Bonds) + { + Assert.IsFalse(b.Connected); + Assert.That(b.Atom, Is.EqualTo(a)); + Assert.That(b.Energy, Is.EqualTo(0)); + if (bondTypeCount.ContainsKey(b.BondType)) + bondTypeCount[b.BondType] += 1; + else + bondTypeCount[b.BondType] = 1; + } + Assert.That(bondTypeCount["m"], Is.EqualTo(1)); + Assert.That(bondTypeCount["s"], Is.EqualTo(2)); + } + [Test] + public static void AtomTestA() + { + AAtom a = new AAtom(); + a.C(); + Assert.IsTrue(a.LogStateMatrix.Get.Exp().IsEqualApprox(a.StateMatrix.Get)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.M), Is.Not.EqualTo(BaseBond.Null)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.S), Is.Not.EqualTo(BaseBond.Null)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.D), Is.Not.EqualTo(BaseBond.Null)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.Y), Is.EqualTo(BaseBond.Null)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.Q), Is.EqualTo(BaseBond.Null)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.P), Is.EqualTo(BaseBond.Null)); + Assert.That(a.NextUnconnected(ChemistryConstant.BondTypes.H), Is.EqualTo(BaseBond.Null)); + Dictionary bondTypeCount = new Dictionary(); + foreach (BaseBond b in a.Bonds) + { + Assert.IsFalse(b.Connected); + Assert.That(b.Atom, Is.EqualTo(a)); + Assert.That(b.Energy, Is.EqualTo(0)); + if (bondTypeCount.ContainsKey(b.BondType)) + bondTypeCount[b.BondType] += 1; + else + bondTypeCount[b.BondType] = 1; + } + Assert.That(bondTypeCount["m"], Is.EqualTo(1)); + Assert.That(bondTypeCount["s"], Is.EqualTo(2)); + Assert.That(bondTypeCount["d"], Is.EqualTo(1)); + } + + + +} \ No newline at end of file diff --git a/tests/BondConnectionTest.cs b/tests/BondConnectionTest.cs new file mode 100644 index 0000000..985113c --- /dev/null +++ b/tests/BondConnectionTest.cs @@ -0,0 +1,96 @@ +using System; +using System.Linq; +using Skeleton.Algebra.Extensions; +using VirtualChemistry.Chemistry.Atoms.Implements; +using VirtualChemistry.Chemistry.Atoms.Resolver; +using VirtualChemistry.Chemistry.Bonds.Implements; +using VirtualChemistry.Chemistry.Compounds.Implements; +using VirtualChemistry.Chemistry.Containers; +using VirtualChemistry.Chemistry.Mixtures.Implements; + +namespace VirtualChemistryTest; + +public static class BondConnectionTest +{ + private class Container : IChemicalContainer + { + public Container(HeterogeneousMixture h) => Content = h; + public double Volume() => 200; + public HeterogeneousMixture Content { get; set; } + public double EnvironmentPressure { get; set; } + public double EnvironmentTemperature { get; set; } + } + + [Test] + public static void Test() + { + HeterogeneousMixture h = new (); + h.Container = new Container(h); + HomogeneousMixture m = new(); + + QAtom q1 = new (); + QAtom q2 = new(); + q1.C(); + q2.C(); + BaseBond b1 = q1.NextUnconnected("m"); + BaseBond b2 = q2.NextUnconnected("m"); + b1.Connect(b2); + Compound c = q1.GrabCompound; + c.Amount = 1; + m.AddCompound(c); + h.AddLayer(m); + + Assert.IsTrue(h.Amount.IsEqualApprox(1)); + Assert.That(h.Layers.Count, Is.EqualTo(1)); + Assert.IsTrue(h.Layers.First().Amount.IsEqualApprox(1)); + Assert.IsTrue(h.Layers.First().Ratio.IsEqualApprox(1)); + Assert.IsTrue(c.Concentration.IsEqualApprox(1)); + Console.WriteLine(c.IsoRepresentation); + QAtom q3 = new(); + QAtom q4 = new(); + q3.C(); + q4.C(); + q3.NextUnconnected("m").Connect(q4.NextUnconnected("m")); + Compound cx = q3.GrabCompound; + Console.WriteLine(cx.IsoRepresentation); + Assert.IsTrue(c.IsometricTo(cx)); + Console.WriteLine(h.Dump()); + Console.WriteLine($"T: {m.Temperature} FD:{m.FreeDensity.Get} FV:{m.FreeVolume}"); + h.Container.EnvironmentTemperature = 1; + for(int i = 0;i<10;i++) + { + m.HeatExchange(); + Console.WriteLine($"P: {m.Phase} T: {m.Temperature} FD:{m.FreeDensity.Get} FV:{m.FreeVolume}"); + //Console.WriteLine($"\t\t{c.CompressionBias.Get} {c.CompressionElasticity.Get} {c.CompressionStiffness}"); + Console.WriteLine($"\t{b1.AntiBondingEnergy} - {b1.Energy}"); + Console.WriteLine($"\t{b2.AntiBondingEnergy} - {b2.Energy}"); + } + } + + [Test] + public static void ReactionTest() + { + HeterogeneousMixture h = new (); + h.Container = new Container(h); + HomogeneousMixture m = new(); + h.AddLayer(m); + BaseAtom a = AtomResolver.Resolve(1); + Compound c = a.GrabCompound; + a.Compound = c; + c.Amount = 2; + m.AddCompound(c); + h.Container.EnvironmentTemperature = 9; + for(int i = 1; i < 10; i++) + h.OneStep(); + foreach (HomogeneousMixture mx in h.Layers) + { + Console.WriteLine(mx.Temperature); + foreach (Compound cx in mx.Compounds) + { + var b = cx.Atoms.First().NextUnconnected("m"); + Console.WriteLine($"{cx.Expression} {cx.Amount} {b.BondingEnergy} {b.Energy}"); + } + } + + } +} \ No newline at end of file diff --git a/tests/MixtureDegenerateTest.cs b/tests/MixtureDegenerateTest.cs new file mode 100644 index 0000000..3c0934e --- /dev/null +++ b/tests/MixtureDegenerateTest.cs @@ -0,0 +1,39 @@ +using Skeleton.Algebra.Extensions; +using VirtualChemistry.Chemistry.Atoms.Implements; +using VirtualChemistry.Chemistry.Atoms.Resolver; +using VirtualChemistry.Chemistry.Compounds.Implements; +using VirtualChemistry.Chemistry.Containers; +using VirtualChemistry.Chemistry.Mixtures.Implements; + +namespace VirtualChemistryTest; + +public static class MixtureDegenerateTest +{ + private class Container : IChemicalContainer + { + public Container(HeterogeneousMixture h) => Content = h; + public double Volume() => 200; + public HeterogeneousMixture Content { get; set; } + public double EnvironmentPressure { get; set; } + public double EnvironmentTemperature { get; set; } + } + [Test] + public static void DegenerateTest() + { + HeterogeneousMixture h = new (); + h.Container = new Container(h); + HomogeneousMixture m = new(); + h.AddLayer(m); + BaseAtom a = AtomResolver.Resolve(1); + BaseAtom a2 = AtomResolver.Resolve(1); + Compound c1 = a.GrabCompound; + c1.Amount = 10; + Compound c2 = a2.GrabCompound; + c2.Amount = 5; + m.AddCompound(c1); + m.AddCompound(c2); + Assert.That(m.Compounds.Count, Is.EqualTo(1)); + Assert.IsTrue(m.Amount.IsEqualApprox(15)); + } +} + diff --git a/tests/ResolvabilityTest.cs b/tests/ResolvabilityTest.cs new file mode 100644 index 0000000..907f33a --- /dev/null +++ b/tests/ResolvabilityTest.cs @@ -0,0 +1,59 @@ +using System; +using System.Numerics; +using VirtualChemistry.Chemistry.Atoms.Implements; +using VirtualChemistry.Chemistry.Atoms.Resolver; +using VirtualChemistry.Chemistry.Compounds.Implements; +using VirtualChemistry.Chemistry.Containers; +using VirtualChemistry.Chemistry.Mixtures.Implements; + +namespace VirtualChemistryTest; + +public static class ResolvabilityTest +{ + private class Container : IChemicalContainer + { + public Container(HeterogeneousMixture h) => Content = h; + public double Volume() => 200; + public HeterogeneousMixture Content { get; set; } + public double EnvironmentPressure { get; set; } + public double EnvironmentTemperature { get; set; } + } + [Test] + public static void SelfResolvabilityTest() + { + HeterogeneousMixture h = new (); + h.Container = new Container(h); + HomogeneousMixture m = new(); + h.AddLayer(m); + BaseAtom a = AtomResolver.Resolve(1); + BaseAtom a2 = AtomResolver.Resolve(1); + Compound c1 = a.GrabCompound; + c1.Amount = 1; + Compound c2 = a2.GrabCompound; + c2.Amount = 2; + m.AddCompound(c1); + Console.WriteLine(m.Resolvability(c2)); + } + + [Test] + public static void InverseResolvabilityTest() + { + HeterogeneousMixture h = new (); + h.Container = new Container(h); + HomogeneousMixture m = new(); + h.AddLayer(m); + HomogeneousMixture m2 = new(); + BaseAtom a = AtomResolver.Resolve(1); + BaseAtom a2 = AtomResolver.Resolve(2); + Compound c1 = a.GrabCompound; + c1.Amount = 1; + Compound c2 = a2.GrabCompound; + c2.Amount = 2; + m.AddCompound(c1); + m2.AddCompound(c2); + Console.WriteLine(m.Resolvability(c2)); + Console.WriteLine(m2.Resolvability(c1)); + Complex sa = 0; + Console.WriteLine(sa.Phase); + } +} \ No newline at end of file diff --git a/tests/Usings.cs b/tests/Usings.cs new file mode 100644 index 0000000..cfc0391 --- /dev/null +++ b/tests/Usings.cs @@ -0,0 +1,10 @@ +global using NUnit.Framework; +global using C3 = Skeleton.Algebra.CategoryOf.OnField.FVector; +global using R3 = Skeleton.Algebra.CategoryOf.OnField.FVector; +global using C33 = Skeleton.Algebra.CategoryOf.OnField.FMatrix; +global using R33 = Skeleton.Algebra.CategoryOf.OnField.FMatrix; +global using U3 = Skeleton.Algebra.CategoryOf.FUnitaryMatrix; +global using SU3 = Skeleton.Algebra.CategoryOf.FSpecialUnitaryMatrix; +global using LieU3 = Skeleton.Algebra.CategoryOf.FLieUnitaryMatrix; +global using LieSU3 = Skeleton.Algebra.CategoryOf.FSpecialLieUnitaryMatrix; +