public void SixJReggeSymmetry()
{
SixJSymbol[] symbols = GenerateRandomSixJSymbols(15.0, 15);
foreach (SixJSymbol symbol in symbols)
{
Spin sa1 = symbol.J1;
Spin sa2 = symbol.J2;
Spin sa3 = symbol.J3;
Spin sa4 = symbol.J4;
Spin sa5 = symbol.J5;
Spin sa6 = symbol.J6;
Console.WriteLine("{0} {1} {2}", sa1.J, sa2.J, sa3.J);
Console.WriteLine("{0} {1} {2}", sa4.J, sa5.J, sa6.J);
double sa = SpinMath.SixJ(sa1, sa2, sa3, sa4, sa5, sa6);
Spin sb1 = new Spin(sa1.J);
Spin sb2 = new Spin((sa3.J + sa5.J + sa6.J - sa2.J) / 2.0);
Spin sb3 = new Spin((sa2.J + sa5.J + sa6.J - sa3.J) / 2.0);
Spin sb4 = new Spin(sa4.J);
Spin sb5 = new Spin((sa2.J + sa3.J + sa6.J - sa5.J) / 2.0);
Spin sb6 = new Spin((sa2.J + sa3.J + sa5.J - sa6.J) / 2.0);
Console.WriteLine("{0} {1} {2}", sb1.J, sb2.J, sb3.J);
Console.WriteLine("{0} {1} {2}", sb4.J, sb5.J, sb6.J);
double sb = SpinMath.SixJ(sb1, sb2, sb3, sb4, sb5, sb6);
Console.WriteLine("{0} vs. {1}", sa, sb);
Console.WriteLine("---");
Assert.IsTrue(TestUtilities.IsNearlyEqual(sa, sb));
}
}
public void SixJSum()
{
Spin[] spins = GenerateRandomSpins(0.0, 50.0, 5);
foreach (Spin a in spins)
{
foreach (Spin b in spins)
{
Spin[] combined_spins = GenerateRandomCombinedSpins(a, b, 5);
foreach (Spin f in combined_spins)
{
double s = 0.0;
Spin[] xs = GenerateCombinedSpins(a, b);
foreach (Spin x in xs)
{
double t = (2 * x.J + 1) * SpinMath.SixJ(a, b, x, a, b, f);
if ((((int)Math.Round(2 * x.J)) % 2) != 0)
{
t = -t;
}
s += t;
}
Assert.IsTrue(TestUtilities.IsNearlyEqual(s, 1.0));
}
}
}
}
public void SixJExchangeSymmetry()
{
SixJSymbol[] symbols = GenerateRandomSixJSymbols(50.0, 5);
foreach (SixJSymbol symbol in symbols)
{
Spin j1 = symbol.J1;
Spin j2 = symbol.J2;
Spin j3 = symbol.J3;
Spin j4 = symbol.J4;
Spin j5 = symbol.J5;
Spin j6 = symbol.J6;
double s1 = SpinMath.SixJ(j1, j2, j3, j4, j5, j6);
// odd column permutation
double s2 = SpinMath.SixJ(j2, j1, j3, j5, j4, j6);
Assert.IsTrue(TestUtilities.IsNearlyEqual(s1, s2));
// even column permutation
double s3 = SpinMath.SixJ(j2, j3, j1, j5, j6, j4);
Assert.IsTrue(TestUtilities.IsNearlyEqual(s1, s3));
// flip
double s4 = SpinMath.SixJ(j1, j5, j6, j4, j2, j3);
Assert.IsTrue(TestUtilities.IsNearlyEqual(s1, s4));
}
}
public void SixJSpecialCase()
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(SpinMath.SixJ(Spin.SpinZero, Spin.SpinZero, Spin.SpinZero, Spin.SpinZero, Spin.SpinZero, Spin.SpinZero), 1.0));
Assert.IsTrue(TestUtilities.IsNearlyEqual(SpinMath.SixJ(Spin.SpinZero, Spin.SpinZero, Spin.SpinZero, Spin.SpinOneHalf, Spin.SpinOneHalf, Spin.SpinOneHalf), -1.0 / Math.Sqrt(2.0)));
Assert.IsTrue(TestUtilities.IsNearlyEqual(SpinMath.SixJ(Spin.SpinOneHalf, Spin.SpinOneHalf, Spin.SpinZero, Spin.SpinOneHalf, Spin.SpinOneHalf, Spin.SpinZero), -1.0 / 2.0));
}
public void SixJProductSum()
{
SixJSymbol[] symbols = GenerateRandomSixJSymbols(50.0, 5);
foreach (SixJSymbol symbol in symbols)
{
Spin a = symbol.J1;
Spin b = symbol.J2;
Spin c = symbol.J4;
Spin d = symbol.J5;
Spin f = symbol.J6;
SpinRange ac = CombinedSpinRange(a, c);
Console.WriteLine("ac: [{0},{1}]", ac.Minimum.J, ac.Maximum.J);
SpinRange bd = CombinedSpinRange(b, d);
Console.WriteLine("bd: [{0},{1}]", bd.Minimum.J, bd.Maximum.J);
SpinRange ac_bd = CombinedSpinRange(ac, bd);
Console.WriteLine("g: [{0},{1}]", ac_bd.Minimum.J, ac_bd.Maximum.J);
Spin[] gs = RandomSpinsInRange(ac_bd, 3);
SpinRange ab = CombinedSpinRange(a, b);
SpinRange cd = CombinedSpinRange(c, d);
SpinRange ab_cd = CombinedSpinRange(ab, cd);
Spin[] xs = AllSpinsInRange(ab_cd);
foreach (Spin g in gs)
{
//double s = 0.0;
List <double> s = new List <double>();
foreach (Spin x in xs)
{
double t = (2.0 * x.J + 1.0) *
SpinMath.SixJ(a, b, x, c, d, f) *
SpinMath.SixJ(c, d, x, b, a, g);
int p = (int)Math.Round(f.J + g.J + x.J);
if (p % 2 != 0)
{
t = -t;
}
Console.WriteLine(" {0} {1}", x.J, t);
//s += t;
s.Add(t);
}
double r = SpinMath.SixJ(a, d, f, b, c, g);
Console.WriteLine("a={0} b={1} c={2} d={3} f={4} g={5}: {6} {7}", a.J, b.J, c.J, d.J, f.J, g.J, s, r);
Assert.IsTrue(TestUtilities.IsSumNearlyEqual(s, r));
//Assert.IsTrue(TestUtilities.IsNearlyEqual(s, r));
}
}
}
public void SixJZeroMinimum()
{
// we include these special cases in order to exercise code in the recursion routine that is active
// only when the minimum spin of the recursion is zero
Spin s1 = Spin.SpinOne;
Spin s2 = new Spin(2.0);
Spin s3 = new Spin(3.0);
Assert.IsTrue(TestUtilities.IsNearlyEqual(SpinMath.SixJ(s2, s2, s2, s1, s2, s2), -1.0 / 10.0));
Assert.IsTrue(TestUtilities.IsNearlyEqual(SpinMath.SixJ(s2, s2, s2, s2, s2, s2), -3.0 / 70.0));
Assert.IsTrue(TestUtilities.IsNearlyEqual(SpinMath.SixJ(s2, s2, s2, s3, s2, s2), 4.0 / 35.0));
}
public void SixJOrthonormality()
{
SixJSymbol[] sas = GenerateRandomSixJSymbols(50.0, 5);
foreach (SixJSymbol sa in sas)
{
Spin j1 = sa.J1;
Spin j2 = sa.J2;
Spin j4 = sa.J4;
Spin j5 = sa.J5;
Spin j6a = sa.J6;
SpinRange r15 = CombinedSpinRange(j1, j5);
SpinRange r42 = CombinedSpinRange(j4, j2);
SpinRange r6b = CombinedSpinRange(r15, r42);
Spin[] j6bs = RandomSpinsInRange(r6b, 5);
j6bs[0] = j6a;
SpinRange r12 = CombinedSpinRange(j1, j2);
SpinRange r45 = CombinedSpinRange(j4, j5);
SpinRange r3 = CombinedSpinRange(r12, r45);
Spin[] j3s = AllSpinsInRange(r3);
foreach (Spin j6b in j6bs)
{
double s = 0.0;
foreach (Spin j3 in j3s)
{
double t = (2.0 * j3.J + 1.0) *
SpinMath.SixJ(j1, j2, j3, j4, j5, j6a) *
SpinMath.SixJ(j1, j2, j3, j4, j5, j6b);
s += t;
}
Console.WriteLine("j1={0} j2={1} j4={2} j5={3} j6a={4} j6b={5} s={6}", j1.J, j2.J, j4.J, j5.J, j6a.J, j6b.J, s);
if (j6a == j6b)
{
Assert.IsTrue(TestUtilities.IsNearlyEqual(s, 1.0 / (2.0 * j6a.J + 1.0)));
}
else
{
Assert.IsTrue(Math.Abs(s) < TestUtilities.TargetPrecision);
}
}
}
}
public void SixJThreeJRelation()
{
SixJSymbol[] symbols = GenerateRandomSixJSymbols(50.0, 5);
foreach (SixJSymbol symbol in symbols)
{
Spin a = symbol.J1;
Spin b = symbol.J2;
Spin c = symbol.J3;
Spin d = symbol.J4;
Spin e = symbol.J5;
Spin f = symbol.J6;
SpinState[] ams = GenerateRandomSpinStates(a, 2);
SpinState[] bms = GenerateRandomSpinStates(b, 2);
foreach (SpinState am in ams)
{
foreach (SpinState bm in bms)
{
if (Math.Abs(am.M + bm.M) > c.J)
{
continue;
}
SpinState cm = new SpinState(c, -(am.M + bm.M));
double g1 = SpinMath.ThreeJ(am, bm, cm);
double g2 = SpinMath.SixJ(a, b, c, d, e, f);
double p = g1 * g2;
double q = 0.0;
List <double> ts = new List <double>();
SpinState[] dms = d.States();
foreach (SpinState dm in dms)
{
if (Math.Abs(dm.M + cm.M) > e.J)
{
continue;
}
SpinState em = new SpinState(e, dm.M + cm.M);
SpinState mem = new SpinState(e, -em.M);
double f1 = SpinMath.ThreeJ(dm, mem, cm);
if (Math.Abs(em.M + am.M) > f.J)
{
continue;
}
SpinState fm = new SpinState(f, em.M + am.M);
SpinState mfm = new SpinState(f, -fm.M);
double f2 = SpinMath.ThreeJ(em, mfm, am);
SpinState mdm = new SpinState(d, -dm.M);
double f3 = SpinMath.ThreeJ(fm, mdm, bm);
double t = f1 * f2 * f3;
int s = (int)Math.Round(dm.J + dm.M + em.J + em.M + fm.J + fm.M);
if (s % 2 != 0)
{
t = -t;
}
q += t;
ts.Add(t);
}
Console.WriteLine("{0} v. {1}", p, q);
//Assert.IsTrue(TestUtilities.IsNearlyEqual(p, q));
Assert.IsTrue(TestUtilities.IsSumNearlyEqual(ts, p));
}
}
}
}