public void CalculateOpticalConstants_DrudeLorentz_Gnuplot()
{
// Arrange
var optConst = ParameterHelper.ReadOpticalConstants("opt_const.txt");
var drudeLorentz = new DrudeLorentz();
var dict = new Dictionary <double, Complex>();
foreach (var waveLength in optConst.WaveLengthList)
{
var freq = new SpectrumUnit(waveLength / OpticalConstants.WaveLengthMultiplier,
SpectrumUnitType.WaveLength);
dict.Add(waveLength, drudeLorentz.GetPermittivity(freq));
}
ParameterHelper.WriteOpticalConstants("opt_const_drudeLorentz.txt", dict);
using (var gp = new GnuPlot())
{
gp.HoldOn();
gp.Set("style data lines");
gp.Plot(getPermitivittyFunc(optConst));
gp.Plot(dict);
gp.Wait();
}
// Act
// Assert
}
private SimulationResult calculateExtinction(SpectrumUnit freq, SimulationParameters parameters)
{
var pulseFourier = this.pulse.FourierPulse.Select(x => x.Transform(freq, parameters.TimeStep).Magnitude).ToArray();
double extinction = this.iterator.Sum(parameters.Indices,
(i, j, k) =>
{
var medium = parameters.Medium[i, j, k];
if (!medium.IsBody)
{
return(0);
}
Complex eps = medium.Permittivity.GetPermittivity(freq);
double pulseMultiplier = 1 / pulseFourier[j];
var complex = eps.Imaginary *
pulseMultiplier * this.fields.FourierField[i, j, k].Transform(freq, parameters.TimeStep).Norm;
return(complex);
});
double area = this.calculateArea(parameters);
var resu = new SimulationResult();
double waveNumber = freq.ToType(SpectrumUnitType.WaveNumber);
extinction = extinction * parameters.CellSize * waveNumber;
double areamult = 1 / area;
resu.EffectiveCrossSectionAbsorption = (extinction * areamult);
resu.CrossSectionAbsorption = extinction * Math.Pow(parameters.CellSize, 2);
return(resu);
}
private CartesianCoordinate getWaveVector(
SpectrumUnit waveLength,
double refractiveIndex,
SphericalCoordinate angle)
{
SphericalCoordinate radianAngles = angle.ToRadians();
radianAngles.Radius = waveLength.ToType(SpectrumUnitType.WaveNumber) * refractiveIndex; // k_mod
return(radianAngles.ConvertToCartesian());
}
public void GetPermittivity_AnyUnit_ReturnsOne()
{
// Arrange
var parameter = new SpectrumUnit(300e-9, SpectrumUnitType.WaveLength);
var target = new Vacuum();
// Act
Complex result = target.GetPermittivity(parameter);
// Assert
Assert.AreEqual(Complex.One, result);
}
/// <summary>
/// Gets the permittivity at specific frequency.
/// </summary>
/// <param name="frequency">The frequency.</param>
/// <returns>
/// The complex permittivity.
/// </returns>
public override Complex GetPermittivity(SpectrumUnit frequency)
{
double w = frequency.ToType(SpectrumUnitType.CycleFrequency);
double plasmaFreq = this.PlasmaTerm.ResonanceFrequency.ToType(SpectrumUnitType.CycleFrequency);
double collisionFreq = this.PlasmaTerm.CollisionFrequency.ToType(SpectrumUnitType.CycleFrequency);
Complex compl = this.EpsilonInfinity -
this.PlasmaTerm.StrengthFactor * plasmaFreq * plasmaFreq /
(w * w + Complex.ImaginaryOne * collisionFreq * w);
return(compl);
}
public void GetPermittivity_SetEpsilon_ReturnsOne()
{
// Arrange
const double RelativePermittivity = 5.0;
var parameter = new SpectrumUnit(300e-9, SpectrumUnitType.WaveLength);
var target = new Dielectric {
Epsilon = RelativePermittivity
};
// Act
Complex result = target.GetPermittivity(parameter);
// Assert
Assert.AreEqual(RelativePermittivity, result);
}
public void Equals_SameSpectrumType_ReturnsTrue()
{
// Arrange
var unit = new SpectrumUnit(300, SpectrumUnitType.Frequency);
var dict = new Dictionary <SpectrumUnit, double>();
dict.Add(unit, 0);
//Act
var result = unit.Equals(unit);
var contains = dict.ContainsKey(unit);
// Assert
Assert.IsTrue(result);
Assert.IsTrue(contains);
}
/// <summary>
/// Gets the dispersion parameters.
/// </summary>
/// <param name="parameter">The parameter.</param>
/// <param name="angle">The angle.</param>
/// <returns>The dispersion parameters.</returns>
public DispersionParameter GetDispersionParameters(SpectrumUnit parameter, SphericalCoordinate angle)
{
var parameters = new DispersionParameter
{
SpectrumParameter = parameter,
MediumRefractiveIndex = this.getMediumCoeficient(parameter),
Permittivity = this.medium.GetPermittivity(parameter)
};
CartesianCoordinate waveVector = this.getWaveVector(
parameter,
parameters.MediumRefractiveIndex,
angle);
parameters.WaveVector = waveVector;
return(parameters);
}
public void GetPermittivity_SetEpsilonAndConduct_ReturnsOne()
{
// Arrange
const double RelativePermittivity = 5.0;
const double Conductivity = 5.0;
var parameter = new SpectrumUnit(300e-9, SpectrumUnitType.WaveLength);
var target = new LossyDielectric
{
Epsilon = RelativePermittivity,
Conductivity = Conductivity
};
// Act
Complex result = target.GetPermittivity(parameter);
// Assert
Assert.AreEqual(RelativePermittivity, result.Real);
Assert.IsTrue(result.Imaginary < 0);
}
private SimulationResult calculateExtinction(SpectrumUnit freq, SimulationParameters parameters)
{
var pulseFourier = this.pulse.FourierE.Select(x => x.Transform(freq, parameters.TimeStep)).ToArray();
var pulseFourierH = this.pulse.FourierH.Select(x => x.Transform(freq, parameters.TimeStep)).ToArray();
double extinction = this.iterator.Sum(parameters.Indices,
(i, j, k) =>
{
var medium = parameters.Medium[i, j, k];
if (!medium.IsBody)
{
return(0);
}
Complex eps = medium.Permittivity.GetPermittivity(freq);
Complex clausiusMosottiPolar = (eps - 1.0) / (eps + 2.0);
Complex multiplier = Complex.Reciprocal(clausiusMosottiPolar);
var mult = 1; //(eps.Imaginary) ;
var fourierE = this.fields.FourierE[i, j, k].Transform(freq, parameters.TimeStep);
var fourierH = this.fields.FourierH[i, j, k].Transform(freq, parameters.TimeStep);
double pulseMultiplier = Complex.Reciprocal(pulseFourier[j].ScalarProduct(pulseFourierH[j])).Magnitude;
var complex = (clausiusMosottiPolar) * (fourierE).ScalarProduct(fourierE);
//pulseMultiplier *
//(fourierE.VectorProduct(fourierH).Z);
return(complex.Imaginary);
});
double area = this.calculateArea(parameters);
var resu = new SimulationResult();
double waveNumber = freq.ToType(SpectrumUnitType.WaveNumber);
extinction = extinction * parameters.CellSize * waveNumber;
double areamult = 1 / area;
resu.EffectiveCrossSectionAbsorption = (extinction * areamult);
resu.CrossSectionAbsorption = extinction * Math.Pow(parameters.CellSize, 2);
return(resu);
}
private double getMediumCoeficient(SpectrumUnit waveLength)
{
double refractiveIndex;
//// n_med = sqrt( 1.0 + 2.121*WaveLength*WaveLength / (WaveLength*WaveLength-263.3*263.3) ); // CdBr2 (300K)
//// n_med = 0.7746 + 0.14147*exp(-(WaveLength-59.0737)/122.56035)
//// + 0.99808*exp(-(WaveLength-59.0737)/42.78953) + 0.56471*exp(-(WaveLength-59.0737)/36297.71849); // Waher
refractiveIndex = 1; ////air
//refractiveIndex = 1.39; //water
refractiveIndex = 1.51; // Glass 1.51
//// n_med = 1.65; // Casein has a refractive index of 1.51-1.65
//refractiveIndex = this.solid ? 1.0 : refractiveIndex;
return(refractiveIndex);
}
/// <summary>
/// Gets the permittivity at specific frequency.
/// </summary>
/// <param name="frequency">The frequency.</param>
/// <returns>
/// The complex permittivity.
/// </returns>
public override Complex GetPermittivity(SpectrumUnit frequency)
{
double w = frequency.ToType(SpectrumUnitType.CycleFrequency);
var drudeEps = base.GetPermittivity(frequency);
var plasmafreq = this.PlasmaTerm.ResonanceFrequency.ToType(SpectrumUnitType.CycleFrequency);
return(this.OscillatorTerms.Aggregate(
drudeEps,
(eps, oscillator) =>
{
var resonanceFrequency = oscillator.ResonanceFrequency.ToType(SpectrumUnitType.CycleFrequency);
var collisionFrequency = oscillator.CollisionFrequency.ToType(SpectrumUnitType.CycleFrequency);
var lorentzEps = oscillator.StrengthFactor * plasmafreq * plasmafreq /
(resonanceFrequency * resonanceFrequency - w * w -
Complex.ImaginaryOne * collisionFrequency * w);
eps += lorentzEps;
return eps;
}));
}
/// <summary>
/// Calculates the single DDA.
/// </summary>
/// <param name="waveLength">Length of the wave.</param>
/// <param name="parameters">The parameters.</param>
/// <returns>The single simulation result.</returns>
public SimulationResult CalculateSingleDDA(
SpectrumUnit waveLength,
SimulationParameters parameters,
double[] polarization)
{
Console.WriteLine("start wave" + waveLength.ToType(Simulation.Models.Enums.SpectrumUnitType.WaveLength));
DispersionParameter dispersion =
this.mediumManager.GetDispersionParameters(
waveLength,
parameters.WavePropagation);
ComplexCoordinate[] e = this.getIncidentField(
parameters.SystemConfig,
parameters.IncidentMagnitude,
dispersion);
IMatrix <IMatrix <Complex> > a = this.buildMatrixA(
parameters.SystemConfig,
dispersion);
ModernKDDAEntryPoint.OpenMPCGMethod(
polarization.Length,
CoordinateHelper.ConvertToPlainArrayMatrix(a),
polarization,
CoordinateHelper.ConvertToPlainArray(e));
var result = new SimulationResult
{
Polarization = CoordinateHelper.ConvertFromPlainArray(polarization),
ElectricField = e
};
this.calculateCrossSectionExtinction(
result,
parameters,
dispersion);
Console.WriteLine("finish wave" + waveLength.ToType(Simulation.Models.Enums.SpectrumUnitType.WaveLength));
return(result);
}
/// <summary>
/// Gets the permittivity.
/// </summary>
/// <param name="parameter">The parameter.</param>
/// <returns>The complex permittivity.</returns>
public override Complex GetPermittivity(SpectrumUnit parameter)
{
var waveLength = parameter.ToType(SpectrumUnitType.WaveLength) * WaveLengthMultiplier;
var tuple = this.getNearestIndexes(waveLength);
var lower = tuple.Item1;
var upper = tuple.Item2;
var deltaWaveLength = waveLength - this.WaveLengthList[lower];
var stepWaveLength = this.WaveLengthList[upper] - this.WaveLengthList[lower];
var coefWaveLength = deltaWaveLength / stepWaveLength;
double epsRe = this.PermittivityList[lower].Real + coefWaveLength *
(this.PermittivityList[upper].Real - this.PermittivityList[lower].Real);
double epsIm = this.PermittivityList[lower].Imaginary + coefWaveLength *
(this.PermittivityList[upper].Imaginary - this.PermittivityList[lower].Imaginary);
return(new Complex(epsRe, epsIm));
////eps_re = 3.9943 - (13.29e+15*13.29e+15)/((4.0*Pi*Pi*3.0e8*3e8/WaveLength/WaveLength*1e18)+(0.1128e+15*0.1128e+15));
////eps_im = (13.29e+15*13.29e+15*0.1128e+15)/((4.0*Pi*Pi*3e8*3e8/WaveLength/WaveLength*1e18)+(0.1128e+15*0.1128e+15))/(2.0*Pi*3e8/WaveLength*1e9);
}
/// <summary>
/// Gets the permittivity at specific frequency.
/// </summary>
/// <param name="frequency">The frequency.</param>
/// <returns>
/// The complex permittivity.
/// </returns>
public override Complex GetPermittivity(SpectrumUnit frequency)
{
return(Complex.One);
}
/// <summary>
/// Gets the permittivity at specific frequency.
/// </summary>
/// <param name="frequency">The frequency.</param>
/// <returns>
/// The complex permittivity.
/// </returns>
public override Complex GetPermittivity(SpectrumUnit frequency)
{
double w = frequency.ToType(SpectrumUnitType.CycleFrequency);
return(this.Epsilon - Complex.ImaginaryOne * this.Conductivity / Fundamentals.ElectricConst / w);
}
/// <summary>
/// Gets the permittivity at specific frequency.
/// </summary>
/// <param name="frequency">The frequency.</param>
/// <returns>
/// The complex permittivity.
/// </returns>
public override Complex GetPermittivity(SpectrumUnit frequency)
{
return(this.epsilon);
}
private double getSubstrateCoefficient(SpectrumUnit parameter)
{
return(0);
}
/// <summary> /// Gets the permittivity at specific frequency. /// </summary> /// <param name="frequency">The frequency.</param> /// <returns>The complex permittivity.</returns> public abstract Complex GetPermittivity(SpectrumUnit frequency);
