public double CalculateLongitudinalElectricComponent(
double effectiveTime_fm,
double radialDistance_fm,
double conductivity_MeV
)
{
Func <double, double, double> integrand = (x_fm, y_fm) =>
{
SpatialVector pointChargePosition = new SpatialVector(radialDistance_fm - x_fm, -y_fm, 0);
return(Nucleus.GetProtonNumberColumnDensity_per_fm3(x_fm, y_fm)
* PointChargeEMF.CalculateElectromagneticField(
EMFComponent.LongitudinalElectricComponent,
effectiveTime_fm,
pointChargePosition.Norm,
conductivity_MeV)
* pointChargePosition.Direction.X);
};
double integral = ImproperQuadrature.IntegrateOverRealPlane(
integrand,
2 * Nucleus.NuclearRadius_fm,
QuadratureOrder);
return(integral);
}
public void GetVectorNorm()
{
SpatialVector vector = new SpatialVector(1, 2, 3);
double norm = vector.Norm;
Assert.AreEqual(Math.Sqrt(14), norm);
}
public void ConvertVectorFieldComponents()
{
double radialPart = 1;
double azimuthalPart = 2;
double longitudinalPart = 3;
SpatialVector vector1 = SpatialVector.ConvertCylindricalToEuclideanVectorFieldComponents(
1, 0, radialPart, azimuthalPart, longitudinalPart);
Assert.AreEqual(1, vector1.X);
Assert.AreEqual(2, vector1.Y);
Assert.AreEqual(3, vector1.Z);
SpatialVector vector2 = SpatialVector.ConvertCylindricalToEuclideanVectorFieldComponents(
0, 1, radialPart, azimuthalPart, longitudinalPart);
Assert.AreEqual(-2, vector2.X);
Assert.AreEqual(1, vector2.Y);
Assert.AreEqual(3, vector2.Z);
SpatialVector vector3 = SpatialVector.ConvertCylindricalToEuclideanVectorFieldComponents(
-1, 0, radialPart, azimuthalPart, longitudinalPart);
Assert.AreEqual(-1, vector3.X);
Assert.AreEqual(-2, vector3.Y);
Assert.AreEqual(3, vector3.Z);
SpatialVector vector4 = SpatialVector.ConvertCylindricalToEuclideanVectorFieldComponents(
0, -1, radialPart, azimuthalPart, longitudinalPart);
Assert.AreEqual(2, vector4.X);
Assert.AreEqual(-1, vector4.Y);
Assert.AreEqual(3, vector4.Z);
}
public void CreateVectorFromCoordinates()
{
SpatialVector vector = new SpatialVector(1, 2, 3);
Assert.AreEqual(1, vector.X);
Assert.AreEqual(2, vector.Y);
Assert.AreEqual(3, vector.Z);
}
public void MultiplyVectorWithVector()
{
SpatialVector left = new SpatialVector(1, 2, 3);
SpatialVector right = new SpatialVector(4, 5, 6);
double product = left * right;
Assert.AreEqual(32, product);
}
public void GetVectorDirection()
{
SpatialVector vector = new SpatialVector(1, 2, 3);
SpatialVector direction = vector.Direction;
Assert.AreEqual(1 / Math.Sqrt(14), direction.X);
Assert.AreEqual(2 / Math.Sqrt(14), direction.Y);
Assert.AreEqual(3 / Math.Sqrt(14), direction.Z);
}
public void DivideVectorByScalar()
{
SpatialVector vector = new SpatialVector(1, 2, 3);
double scalar = 2;
SpatialVector quotient = vector / scalar;
Assert.AreEqual(0.5, quotient.X);
Assert.AreEqual(1, quotient.Y);
Assert.AreEqual(1.5, quotient.Z);
}
public void SubstractVectors()
{
SpatialVector left = new SpatialVector(1, 2, 3);
SpatialVector right = new SpatialVector(6, 5, 4);
SpatialVector difference = left - right;
Assert.AreEqual(-5, difference.X);
Assert.AreEqual(-3, difference.Y);
Assert.AreEqual(-1, difference.Z);
}
public void AddVectors()
{
SpatialVector left = new SpatialVector(1, 2, 3);
SpatialVector right = new SpatialVector(4, 5, 6);
SpatialVector sum = left + right;
Assert.AreEqual(5, sum.X);
Assert.AreEqual(7, sum.Y);
Assert.AreEqual(9, sum.Z);
}
private SpatialVector[] CalculateMagneticFieldValues()
{
CollisionalElectromagneticField emf
= new CollisionalElectromagneticField(CreateFireballParam());
SpatialVector[] fieldValues = new SpatialVector[Positions.Length];
for (int i = 0; i < Positions.Length; i++)
{
fieldValues[i] = emf.CalculateMagneticField(
Time, Positions[i].X, Positions[i].Y, Positions[i].Z, QGPConductivity);
}
return(fieldValues);
}
public void MultiplyVectorWithScalar()
{
SpatialVector vector = new SpatialVector(1, 2, 3);
double scalar = 2;
SpatialVector productLeft = scalar * vector;
SpatialVector productRight = vector * scalar;
Assert.AreEqual(2, productLeft.X);
Assert.AreEqual(4, productLeft.Y);
Assert.AreEqual(6, productLeft.Z);
Assert.AreEqual(2, productRight.X);
Assert.AreEqual(4, productRight.Y);
Assert.AreEqual(6, productRight.Z);
}
public SpatialVector CalculateMagneticFieldInLCF(
double properTime_fm,
double x_fm,
double y_fm,
double rapidity,
double conductivity_MeV
)
{
double effectiveTime_fm = CalculateEffectiveTimeFromLCFCoordinates(properTime_fm, rapidity);
double radialDistance_fm = CalculateRadialDistance(x_fm, y_fm);
double azimuthalField
= CalculateAzimuthalMagneticComponentInLCF(effectiveTime_fm, radialDistance_fm, rapidity, conductivity_MeV);
return(SpatialVector.ConvertCylindricalToEuclideanVectorFieldComponents(
x_fm, y_fm, 0, azimuthalField, 0));
}
public SpatialVector CalculateMagneticField(
double t_fm,
double x_fm,
double y_fm,
double z_fm,
double conductivity_MeV
)
{
double effectiveTime_fm = CalculateEffectiveTime(t_fm, z_fm);
double radialDistance_fm = CalculateRadialDistance(x_fm, y_fm);
double azimuthalField
= CalculateAzimuthalMagneticComponent(effectiveTime_fm, radialDistance_fm, conductivity_MeV);
return(SpatialVector.ConvertCylindricalToEuclideanVectorFieldComponents(
x_fm, y_fm, 0, azimuthalField, 0));
}
public void GetVectorAzimuthalAngle()
{
double angle1 = new SpatialVector(1, 0, 0).AzimuthalAngle;
Assert.AreEqual(0, angle1);
double angle2 = new SpatialVector(1, 1, 0).AzimuthalAngle;
Assert.AreEqual(0.25 * Math.PI, angle2);
double angle3 = new SpatialVector(-1, 0, 0).AzimuthalAngle;
Assert.AreEqual(Math.PI, angle3);
double angle4 = new SpatialVector(1, -1, 0).AzimuthalAngle;
Assert.AreEqual(-0.25 * Math.PI, angle4);
}
public SpatialVector CalculateMagneticFieldInLCF(
double properTime_fm,
double x_fm,
double y_fm,
double rapidity,
double conductivity_MeV
)
{
// Nucleus A is located at negative x and moves in positive z direction
SpatialVector fieldNucleusA = NucleusEMFA.CalculateMagneticFieldInLCF(
properTime_fm, x_fm - NucleusPositionA, y_fm, rapidity, conductivity_MeV);
// Nucleus B is located at positive x and moves in negative z direction
SpatialVector fieldNucleusB = NucleusEMFB.CalculateMagneticFieldInLCF(
properTime_fm, x_fm - NucleusPositionB, y_fm, rapidity, conductivity_MeV);
return(fieldNucleusA + fieldNucleusB);
}
/********************************************************************************************
* Public members, functions and properties
********************************************************************************************/
public SpatialVector CalculateElectricField(
double t_fm,
double x_fm,
double y_fm,
double z_fm,
double conductivity_MeV
)
{
// Nucleus A is located at negative x and moves in positive z direction
SpatialVector fieldNucleusA = NucleusEMFA.CalculateElectricField(
t_fm, x_fm - NucleusPositionA, y_fm, z_fm, conductivity_MeV);
// Nucleus B is located at positive x and moves in negative z direction
SpatialVector fieldNucleusB = NucleusEMFB.CalculateElectricField(
t_fm, x_fm - NucleusPositionB, y_fm, z_fm, conductivity_MeV);
return(fieldNucleusA + fieldNucleusB);
}
public SpatialVector CalculateElectricField(
double t_fm,
double x_fm,
double y_fm,
double z_fm,
double conductivity_MeV
)
{
double effectiveTime_fm = CalculateEffectiveTime(t_fm, z_fm);
double radialDistance_fm = CalculateRadialDistance(x_fm, y_fm);
double longitudinalField
= CalculateLongitudinalElectricComponent(effectiveTime_fm, radialDistance_fm, conductivity_MeV);
double radialField
= CalculateRadialElectricComponent(effectiveTime_fm, radialDistance_fm, conductivity_MeV);
return(SpatialVector.ConvertCylindricalToEuclideanVectorFieldComponents(
x_fm, y_fm, radialField, 0, longitudinalField));
}
/********************************************************************************************
* Private/protected members, functions and properties
********************************************************************************************/
private SpatialVector[] CalculateElectricFieldValues()
{
FireballParam param = CreateFireballParam();
Nucleus.CreateNucleusPair(param, out Nucleus nucleusA, out Nucleus nucleusB);
NucleusElectromagneticField emf = new NucleusElectromagneticField(
param.EMFCalculationMethod,
param.BeamRapidity,
nucleusA,
param.EMFQuadratureOrder);
SpatialVector[] fieldValues = new SpatialVector[Positions.Length];
for (int i = 0; i < Positions.Length; i++)
{
fieldValues[i] = emf.CalculateElectricField(
Time, Positions[i].X, Positions[i].Y, Positions[i].Z, QGPConductivity);
}
return(fieldValues);
}
