public static LorentzMatrixUL Matrix(EuclideanVector3 velocity)
{
return(new LorentzMatrixUL((i, j) =>
{
Symbol gamma = LorentzTransform.Gamma(velocity);
if (i == 0)
{
if (j == 0)
{
return gamma;
}
return -gamma * velocity[j - 1];
}
if (j == 0)
{
return -gamma * velocity[i - 1];
}
Symbol symbol = (gamma - 1) * velocity[i - 1] * velocity[j - 1] / velocity.InvariantScalar;
if (i == j)
{
symbol = 1 + symbol;
}
return symbol;
}));
}
static void TestFieldTransforms(EuclideanVector3 E, EuclideanVector3 B, EuclideanVector3 Ep, EuclideanVector3 Bp, EuclideanVector3 v)
{
Symbol gamma = LorentzTransform.Gamma(v);
Assert.AreEqual(Ep.ParallelComponent(v), E.ParallelComponent(v), "E Parallel component:");
Assert.AreEqual(Ep.PerpendicularComponent(v), gamma * (E + v.Cross(B)).PerpendicularComponent(v), "E Perpendicular component:");
Assert.AreEqual(Bp.ParallelComponent(v), B.ParallelComponent(v), "B Parallel component:");
Assert.AreEqual(Bp.PerpendicularComponent(v), gamma * (B - v.Cross(E)).PerpendicularComponent(v), "B Perpendicular component:");
}
public RelativisticParticle(Symbol mass, EuclideanVector3 position, Variable time)
{
this.Mass = mass;
this.Position = new LorentzVectorU(time, position);
Operator dt = new Derivative(time);
EuclideanVector3 v = dt * position;
this.Gamma = LorentzTransform.Gamma(v);
this.Velocity = this.Gamma * new LorentzVectorU(Symbol.One, v);
this.InvariantTimeDerivative = this.Gamma * dt;
}
static void TestLorentzTransform(EuclideanVector3 v)
{
LorentzVectorVariableU x0 = new LorentzVectorVariableU("t", "x", "y", "z");
LorentzVectorU x1 = x0.Transform(v);
LorentzVectorU x2 = x1.Transform(-v);
Assert.AreEqual(x0, x2);
Assert.AreEqual(LorentzMatrixUL.One, LorentzTransform.Matrix(v) * LorentzTransform.Matrix(-v));
}
static void CompareInvariantScalars(ElectromagneticField field1, ElectromagneticField field2)
{
EuclideanVector3 E1 = field1.ElectricField;
EuclideanVector3 B1 = field1.MagneticField;
EuclideanVector3 E2 = field2.ElectricField;
EuclideanVector3 B2 = field2.MagneticField;
//Symbol comparison failure
// Expected:<2(y^2+z^2)^-1>. Actual:<2(-v^2+1)^-1*(y^2+z^2)^-2*(z^2+v^2*(-z^2-y^2)+y^2)>.
//Assert.AreEqual(field1.FieldStrengthTensor.InvariantScalar, field2.FieldStrengthTensor.InvariantScalar);
Assert.AreEqual(field1.FieldStrengthTensor.Dot(field1.DualFieldStrengthTensor), field2.FieldStrengthTensor.Dot(field2.DualFieldStrengthTensor));
}
static void TestMaxwellsEquations(ElectromagneticField F)
{
Operator dt = F.Del.Scalar;
EuclideanVector3Operator del = F.Del.Vector;
Symbol chargeDensity = F.CurrentDensity.Scalar;
EuclideanVector3 currentDensity = F.CurrentDensity.Vector;
Assert.AreEqual(del.Dot(F.ElectricField), chargeDensity, "Gauss' Law:");
Assert.AreEqual(del.Dot(F.MagneticField), Symbol.Zero, "Gauss' Law for Magnetism:");
Assert.AreEqual(del.Cross(F.ElectricField) + dt * F.MagneticField, EuclideanVector3.Zero, "Faraday's Law of Induction");
Assert.AreEqual(del.Cross(F.MagneticField) - dt * F.ElectricField, currentDensity, "Ampere's Law");
}
static void TestFieldStrength(LorentzMatrixUU F, EuclideanVector3 E, EuclideanVector3 B)
{
Assert.AreEqual(F[0, 0], Symbol.Zero, "F[0, 0]");
Assert.AreEqual(F[0, 1], E[0], "F[0, 1]");
Assert.AreEqual(F[0, 2], E[1], "F[0, 2]");
Assert.AreEqual(F[0, 3], E[2], "F[0, 3]");
Assert.AreEqual(F[1, 0], -E[0], "F[1, 0]");
Assert.AreEqual(F[1, 1], Symbol.Zero, "F[1, 1]");
Assert.AreEqual(F[1, 2], B[2], "F[1, 2]");
Assert.AreEqual(F[1, 3], -B[1], "F[1, 3]");
Assert.AreEqual(F[2, 0], -E[1], "F[2, 0]");
Assert.AreEqual(F[2, 1], -B[2], "F[2, 1]");
Assert.AreEqual(F[2, 2], Symbol.Zero, "F[2, 2]");
Assert.AreEqual(F[2, 3], B[0], "F[2, 3]");
Assert.AreEqual(F[3, 0], -E[2], "F[3, 0]");
Assert.AreEqual(F[3, 1], B[1], "F[3, 1]");
Assert.AreEqual(F[3, 2], -B[0], "F[3, 2]");
Assert.AreEqual(F[3, 3], Symbol.Zero, "F[3, 3]");
}
public LorentzVectorOperatorU Transform(EuclideanVector3 velocity)
{
return(LorentzTransform.Matrix(velocity) * this);
}
public RelativisticParticle Transform(EuclideanVector3 velocity)
{
LorentzMatrixUL L = LorentzTransform.Matrix(velocity);
return new RelativisticParticle(this.Mass, L * this.Position, this.InvariantTimeDerivative);
}
static void TestPotential(Func <LorentzVectorVariableU, LorentzVectorU> createPotential, EuclideanVector3 v)
{
LorentzVectorVariableU coordinates = new LorentzVectorVariableU("t", "x", "y", "z");
LorentzVectorU potential = createPotential(coordinates);
LorentzVectorOperatorL del = coordinates.Del;
ElectromagneticField field0 = new ElectromagneticField(potential, del);
TestField(field0);
ElectromagneticField field1 = field0.Transform(v);
TestField(field1);
TestFieldTransforms(field0.ElectricField, field0.MagneticField, field1.ElectricField, field1.MagneticField, v);
CompareInvariantScalars(field0, field1);
ElectromagneticField field2 = field1.Transform(-v);
TestField(field2);
TestFieldTransforms(field1.ElectricField, field1.MagneticField, field2.ElectricField, field2.MagneticField, -v);
CompareInvariantScalars(field1, field2);
Assert.AreEqual(field0.Potential, field2.Potential, "A dual transform");
Assert.AreEqual(field0.Del.ToString(), field2.Del.ToString(), "Del dual transform");
Assert.AreEqual(field0.ElectricField, field2.ElectricField, "E dual transform");
Assert.AreEqual(field0.MagneticField, field2.MagneticField, "B dual transform");
Assert.AreEqual(field0.CurrentDensity, field2.CurrentDensity, "J dual transform");
}
public ElectromagneticField Transform(EuclideanVector3 velocity)
{
LorentzMatrixUL L = LorentzTransform.Matrix(velocity);
return(new ElectromagneticField(L * this.Potential, L.Invert() * this.Del));
}
public static Symbol Gamma(EuclideanVector3 velocity)
{
return(1 / Functions.Sqrt(1 - velocity.Dot(velocity)));
}
