protected abstract Direction GetFinalDirection(Position position); // position may or may not be needed
private static Position GetFinalPositionFromProfileType(ISourceProfile sourceProfile, double aParameter, double bParameter, Random rng)
{
Position finalPosition = SourceDefaults.DefaultPosition.Clone();
switch (sourceProfile.SourceProfileType)
{
case SourceProfileType.Flat:
// var flatProfile = sourceProfile as FlatSourceProfile;
finalPosition = SourceToolbox.GetPositionInAnEllipseRandomFlat(
SourceDefaults.DefaultPosition.Clone(),
aParameter,
bParameter,
rng);
break;
case SourceProfileType.Gaussian:
var gaussianProfile = sourceProfile as GaussianSourceProfile;
finalPosition = SourceToolbox.GetPositionInAnEllipseRandomGaussian(
SourceDefaults.DefaultPosition.Clone(),
aParameter,
bParameter,
gaussianProfile.BeamDiaFWHM,
rng);
break;
}
return(finalPosition);
}
protected abstract Direction GetFinalDirection(Position position); // position may or may not be needed
private static Position GetFinalPositionFromProfileType(ISourceProfile sourceProfile, double innerRadius, double outerRadius, Random rng)
{
Position finalPosition = SourceDefaults.DefaultPosition.Clone();
switch (sourceProfile.SourceProfileType)
{
case SourceProfileType.Flat:
// var flatProfile = sourceProfile as FlatSourceProfile;
finalPosition = SourceToolbox.GetPositionInACircleRandomFlat(
SourceDefaults.DefaultPosition.Clone(),
innerRadius,
outerRadius,
rng);
break;
case SourceProfileType.Gaussian:
var gaussianProfile = sourceProfile as GaussianSourceProfile;
finalPosition = SourceToolbox.GetPositionInACircleRandomGaussian(
SourceDefaults.DefaultPosition.Clone(),
outerRadius,
innerRadius,
gaussianProfile.BeamDiaFWHM,
rng);
break;
}
return(finalPosition);
}
private static Position GetFinalPositionFromProfileType(ISourceProfile sourceProfile, double rectLengthX, double rectWidthY, Random rng)
{
Position finalPosition = null;
switch (sourceProfile.SourceProfileType)
{
case SourceProfileType.Flat:
// var flatProfile = sourceProfile as FlatSourceProfile;
SourceToolbox.GetPositionInARectangleRandomFlat(
SourceDefaults.DefaultPosition.Clone(),
rectLengthX,
rectWidthY,
rng);
break;
case SourceProfileType.Gaussian:
var gaussianProfile = sourceProfile as GaussianSourceProfile;
finalPosition = SourceToolbox.GetPositionInARectangleRandomGaussian(
SourceDefaults.DefaultPosition.Clone(),
0.5 * rectLengthX,
0.5 * rectWidthY,
gaussianProfile.BeamDiaFWHM,
rng);
break;
}
return(finalPosition);
}
/// <summary>
/// Returns direction for a given position
/// </summary>
/// <param name="position">position</param>
/// <returns>new direction</returns>
protected override Direction GetFinalDirection(Position position)
{
return(SourceToolbox.GetDirectionForGivenPolarAzimuthalAngleRangeRandom(
_polarAngleEmissionRange,
_azimuthalAngleEmissionRange,
Rng));
}
public void validate_static_method_getsinglenormallydistributedrandomnumber()
{
Random rng = new MathNet.Numerics.Random.MersenneTwister(0);
var nrng = SourceToolbox.GetSingleNormallyDistributedRandomNumber(_limitL, rng);
Assert.Less(Math.Abs(nrng - _tp[84]), ACCEPTABLE_PRECISION);
}
/// <summary>
/// Implements Get next photon
/// </summary>
/// <param name="tissue">tissue</param>
/// <returns>photon</returns>
public Photon GetNextPhoton(ITissue tissue)
{
//Source starts at the origin
Position finalPosition = SourceDefaults.DefaultPosition.Clone();
// sample angular distribution
Direction finalDirection = SourceToolbox.GetDirectionForGivenPolarAzimuthalAngleRangeRandom(
_polarAngleEmissionRange,
_azimuthalAngleEmissionRange,
Rng);
//Find the relevent polar and azimuthal pair for the direction
_rotationalAnglesOfPrincipalSourceAxis = SourceToolbox.GetPolarAzimuthalPairFromDirection(_direction);
//Rotation and translation
SourceToolbox.UpdateDirectionPositionAfterGivenFlags(
ref finalPosition,
ref finalDirection,
_rotationalAnglesOfPrincipalSourceAxis,
_pointLocation,
_rotationAndTranslationFlags);
var photon = new Photon(finalPosition, finalDirection, 1.0, tissue, _initialTissueRegionIndex, Rng);
return(photon);
}
public void validate_static_method_getpositionofasymmetricallinerandomflat()
{
Random rng = new MathNet.Numerics.Random.MersenneTwister(0);
var loc = SourceToolbox.GetPositionOfASymmetricalLineRandomFlat(_lengthX, rng);
Assert.Less(Math.Abs(loc - _tp[83]), ACCEPTABLE_PRECISION);
}
/// <summary>
/// Implements Get next photon
/// </summary>
/// <param name="tissue">tissue</param>
/// <returns>photon</returns>
public Photon GetNextPhoton(ITissue tissue)
{
// sample angular distribution
Direction finalDirection = SourceToolbox.GetDirectionForGivenPolarAzimuthalAngleRangeRandom(_polarAngleRangeToDefineSphericalSurface, _azimuthalAngleRangeToDefineSphericalSurface, Rng);
//Source starts from anywhere in the sphere
Position finalPosition = GetFinalPositionFromProfileType(finalDirection, _radius, Rng);
//Lambertian distribution (uniform hemispherical distribution)
PolarAzimuthalAngles polarAzimuthalPair = SourceToolbox.GetPolarAzimuthalPairForGivenAngleRangeRandom(
SourceDefaults.DefaultHalfPolarAngleRange.Clone(),
SourceDefaults.DefaultAzimuthalAngleRange.Clone(),
Rng);
//Avoid updating the finalDirection during following rotation
Position dummyPosition = finalPosition;
//Rotate polar azimutahl angle by polarAzimuthalPair vector
SourceToolbox.UpdateDirectionPositionAfterRotatingByGivenAnglePair(polarAzimuthalPair, ref finalDirection, ref dummyPosition);
//Find the relevent polar and azimuthal pair for the direction
PolarAzimuthalAngles _rotationalAnglesOfPrincipalSourceAxis = SourceToolbox.GetPolarAzimuthalPairFromDirection(_newDirectionOfPrincipalSourceAxis);
//Translation and source rotation
SourceToolbox.UpdateDirectionPositionAfterGivenFlags(
ref finalPosition,
ref finalDirection,
_rotationalAnglesOfPrincipalSourceAxis,
_translationFromOrigin,
_rotationAndTranslationFlags);
var photon = new Photon(finalPosition, finalDirection, 1.0, tissue, _initialTissueRegionIndex, Rng);
return(photon);
}
protected abstract Direction GetFinalDirection(Position position); // position may or may not be needed
private static Position GetFinalPositionFromProfileType(ISourceProfile sourceProfile, double lineLength, Random rng)
{
Position finalPosition = SourceDefaults.DefaultPosition.Clone();
switch (sourceProfile.SourceProfileType)
{
case SourceProfileType.Flat:
// var flatProfile = sourceProfile as FlatSourceProfile;
finalPosition = SourceToolbox.GetPositionInALineRandomFlat(
finalPosition,
lineLength,
rng);
break;
case SourceProfileType.Gaussian:
var gaussianProfile = sourceProfile as GaussianSourceProfile;
finalPosition = SourceToolbox.GetPositionInALineRandomGaussian(
finalPosition,
0.5 * lineLength,
gaussianProfile.BeamDiaFWHM,
rng);
break;
}
return(finalPosition);
}
/// <summary>
/// Returns Lambertian direction - all fluorescence emission is Lambertian
/// </summary>
/// <returns>new direction</returns>
private static Direction GetFinalDirection(Random rng)
{
//Lambertian distribution
return(SourceToolbox.GetDirectionForGivenPolarAzimuthalAngleRangeRandom(
SourceDefaults.DefaultFullPolarAngleRange.Clone(),
SourceDefaults.DefaultAzimuthalAngleRange.Clone(),
rng));
}
public void validate_static_method_getpolarazimuthalpairforgivenanglerangerandom()
{
Random rng = new MathNet.Numerics.Random.MersenneTwister(0);
var angPair = SourceToolbox.GetPolarAzimuthalPairForGivenAngleRangeRandom(_polRange, _aziRange, rng);
Assert.Less(Math.Abs(angPair.Theta - _tp[43]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(angPair.Phi - _tp[44]), ACCEPTABLE_PRECISION);
}
public void validate_static_method_getpositioninacirclerandomgaussian()
{
Random rng = new MathNet.Numerics.Random.MersenneTwister(0);
var pos = SourceToolbox.GetPositionInACircleRandomGaussian(_position, _outerRadius, _innerRadius, _bdFWHM, rng);
Assert.Less(Math.Abs(pos.X - _tp[50]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(pos.Y - _tp[51]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(pos.Z - _tp[52]), ACCEPTABLE_PRECISION);
}
public void validate_static_method_getpositionatcircleperimeter()
{
Random rng = new MathNet.Numerics.Random.MersenneTwister(0);
var pos = SourceToolbox.GetPositionAtCirclePerimeter(_position, _outerRadius, rng);
Assert.Less(Math.Abs(pos.X - _tp[140]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(pos.Y - _tp[141]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(pos.Z - _tp[142]), ACCEPTABLE_PRECISION);
}
public void validate_static_method_getpositioninarectanglerandomflat()
{
Random rng = new MathNet.Numerics.Random.MersenneTwister(0);
var pos = SourceToolbox.GetPositionInARectangleRandomFlat(_position, _lengthX, _widthY, rng);
Assert.Less(Math.Abs(pos.X - _tp[77]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(pos.Y - _tp[78]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(pos.Z - _tp[79]), ACCEPTABLE_PRECISION);
}
public void validate_static_method_getpositioninanellipsoidrandomgaussian()
{
Random rng = new MathNet.Numerics.Random.MersenneTwister(0);
var pos = SourceToolbox.GetPositionInAnEllipsoidRandomGaussian(_position, _aParameter, _bParameter, _cParameter, _bdFWHM, rng);
Assert.Less(Math.Abs(pos.X - _tp[74]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(pos.Y - _tp[75]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(pos.Z - _tp[76]), ACCEPTABLE_PRECISION);
}
public void validate_static_method_getpositioninanellipserandomflat()
{
Random rng = new MathNet.Numerics.Random.MersenneTwister(0);
var pos = SourceToolbox.GetPositionInAnEllipseRandomFlat(_position, _aParameter, _bParameter, rng);
Assert.Less(Math.Abs(pos.X - _tp[65]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(pos.Y - _tp[66]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(pos.Z - _tp[67]), ACCEPTABLE_PRECISION);
}
public void validate_static_method_getpositioninacuboidrandomgaussian()
{
Random rng = new MathNet.Numerics.Random.MersenneTwister(0);
var pos = SourceToolbox.GetPositionInACuboidRandomGaussian(_position, 0.5 * _lengthX, 0.5 * _widthY, 0.5 * _heightZ, _bdFWHM, rng);
Assert.Less(Math.Abs(pos.X - _tp[56]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(pos.Y - _tp[57]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(pos.Z - _tp[58]), ACCEPTABLE_PRECISION);
}
public void validate_static_method_getdirectionforisotropicdistributionrandom()
{
Random rng = new MathNet.Numerics.Random.MersenneTwister(0);
var dir = SourceToolbox.GetDirectionForIsotropicDistributionRandom(rng);
Assert.Less(Math.Abs(dir.Ux - _tp[37]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(dir.Uy - _tp[38]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(dir.Uz - _tp[39]), ACCEPTABLE_PRECISION);
}
public void validate_static_method_getdirectionforgivenpolarazimuthalanglerangerandom()
{
Random rng = new MathNet.Numerics.Random.MersenneTwister(0);
var dir = SourceToolbox.GetDirectionForGivenPolarAzimuthalAngleRangeRandom(_polRange, _aziRange, rng);
Assert.Less(Math.Abs(dir.Ux - _tp[34]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(dir.Uy - _tp[35]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(dir.Uz - _tp[36]), ACCEPTABLE_PRECISION);
}
public void validate_static_method_updatepolarangleFordirectionalsources()
{
var polAngle = SourceToolbox.UpdatePolarAngleForDirectionalSources(
_outerRadius,
_innerRadius,
_polarAngle);
Assert.Less(Math.Abs(polAngle - _tp[136]), ACCEPTABLE_PRECISION);
}
public void validate_static_method_getpositioninacuboidrandomflat()
{
Random rng = new MathNet.Numerics.Random.MersenneTwister(0);
var pos = SourceToolbox.GetPositionInACuboidRandomFlat(_position, _lengthX, _widthY, _heightZ, rng);
Assert.Less(Math.Abs(pos.X - _tp[53]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(pos.Y - _tp[54]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(pos.Z - _tp[55]), ACCEPTABLE_PRECISION);
}
public void validate_static_method_getpositioninarectanglerandomgaussian()
{
Random rng = new MathNet.Numerics.Random.MersenneTwister(0);
var pos = SourceToolbox.GetPositionInARectangleRandomGaussian(_position, 0.5 * _lengthX, 0.5 * _widthY, _bdFWHM, rng);
Assert.Less(Math.Abs(pos.X - _tp[80]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(pos.Y - _tp[81]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(pos.Z - _tp[82]), ACCEPTABLE_PRECISION);
}
/// <summary>
/// Implements Get next photon
/// </summary>
/// <param name="tissue">tissue</param>
/// <returns>photon</returns>
public Photon GetNextPhoton(ITissue tissue)
{
double curved = 2 * Math.PI * _fiberRadius * _fiberHeightZ * _curvedSurfaceEfficiency;
double bottom = Math.PI * _fiberRadius * _fiberRadius * _bottomSurfaceEfficiency;
Direction finalDirection = SourceToolbox.GetDirectionForGivenPolarAzimuthalAngleRangeRandom(
SourceDefaults.DefaultHalfPolarAngleRange.Clone(),
SourceDefaults.DefaultAzimuthalAngleRange.Clone(),
Rng);
Position finalPosition = SourceDefaults.DefaultPosition.Clone();
if (_fiberRadius > 0.0)
{
if (Rng.NextDouble() > bottom / (curved + bottom)) //Consider
{ /* Curved surface */
// To utilize the final direction given above, we can assume a tube
// parallel to the y-axis. We can rotate it about the x-axis by pi/2
// to compute the new direction.
SourceToolbox.UpdateDirectionAfterRotatingAroundXAxis(-0.5 * Math.PI, finalDirection);
//Sample tube perimeter first to compute x and y coordinates
finalPosition = SourceToolbox.GetPositionAtCirclePerimeter(finalPosition,
_fiberRadius,
Rng);
//Sample tube height to compute z coordinate
finalPosition.Z = _fiberHeightZ * (Rng.NextDouble() - 0.5);
}
else
{ /* Bottom Surface */
//Shift finalPosition by _fiberHeightZ / 2
finalPosition = new Position(0.0, 0.0, _fiberHeightZ * 0.5);
//Sample the bottom face to find x, y coordinates of the emission
finalPosition = SourceToolbox.GetPositionInACircleRandomFlat(finalPosition,
0.0,
_fiberRadius,
Rng);
}
}
//Find the relevent polar and azimuthal pair for the direction
PolarAzimuthalAngles _rotationalAnglesOfPrincipalSourceAxis = SourceToolbox.GetPolarAzimuthalPairFromDirection(_newDirectionOfPrincipalSourceAxis);
//Translation and source rotation
SourceToolbox.UpdateDirectionPositionAfterGivenFlags(
ref finalPosition,
ref finalDirection,
_rotationalAnglesOfPrincipalSourceAxis,
_translationFromOrigin,
_rotationAndTranslationFlags);
var photon = new Photon(finalPosition, finalDirection, 1.0, tissue, _initialTissueRegionIndex, Rng);
return photon;
}
public void validate_static_method_getpolarazimuthalpairfromdirection()
{
Direction dir = _direction;
Random rng = new MathNet.Numerics.Random.MersenneTwister(0);
var angPair = SourceToolbox.GetPolarAzimuthalPairFromDirection(dir);
Assert.Less(Math.Abs(angPair.Theta - _tp[45]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(angPair.Phi - _tp[46]), ACCEPTABLE_PRECISION);
}
public void validate_static_method_getdirectionforgiven2dpositionandgivenpolarangle()
{
read_data();
var pos = _position.Clone();
var dir = SourceToolbox.GetDirectionForGiven2DPositionAndGivenPolarAngle(_polarAngle, pos);
Assert.Less(Math.Abs(dir.Ux - _tp[31]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(dir.Uy - _tp[32]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(dir.Uz - _tp[33]), ACCEPTABLE_PRECISION);
}
/// <summary>
/// Returns direction for a given position
/// </summary>
/// <param name="position">position</param>
/// <returns>new direction</returns>
protected override Direction GetFinalDirection(Position position)
{
var azimuthalAngleEmissionRange = SourceDefaults.DefaultAzimuthalAngleRange.Clone();
var polarAngleEmissionRange = SourceDefaults.DefaultFullPolarAngleRange.Clone();
//Sample angular distribution
Direction finalDirection = SourceToolbox.GetDirectionForGivenPolarAzimuthalAngleRangeRandom(polarAngleEmissionRange, azimuthalAngleEmissionRange, Rng);
return(finalDirection);
}
public void validate_static_method_updatedirectionafterrotatingaroundzaxis()
{
var dir = _direction.Clone();
SourceToolbox.UpdateDirectionAfterRotatingAroundZAxis(_angRot.ZRotation, dir);
Assert.Less(Math.Abs(dir.Ux - _tp[94]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(dir.Uy - _tp[95]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(dir.Uz - _tp[96]), ACCEPTABLE_PRECISION);
}
public void validate_static_method_updatedirectionafterrotatingbygivenanglepair()
{
var dir = _direction.Clone();
SourceToolbox.UpdateDirectionAfterRotatingByGivenAnglePair(_angPair, dir);
Assert.Less(Math.Abs(dir.Ux - _tp[97]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(dir.Uy - _tp[98]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(dir.Uz - _tp[99]), ACCEPTABLE_PRECISION);
}
public void validate_static_method_updatepositionaftertranslation()
{
var pos = _position.Clone();
pos = SourceToolbox.UpdatePositionAfterTranslation(pos, _translation);
Assert.Less(Math.Abs(pos.X - _tp[137]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(pos.Y - _tp[138]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(pos.Z - _tp[139]), ACCEPTABLE_PRECISION);
}
public void validate_static_method_getdoublenormallydistributedrandomnumbers()
{
Random rng = new MathNet.Numerics.Random.MersenneTwister(0);
double nrng1 = 0.0;
double nrng2 = 0.0;
SourceToolbox.GetDoubleNormallyDistributedRandomNumbers(ref nrng1, ref nrng2, _limitL, _limitU, rng);
Assert.Less(Math.Abs(nrng1 - _tp[40]), ACCEPTABLE_PRECISION);
Assert.Less(Math.Abs(nrng2 - _tp[41]), ACCEPTABLE_PRECISION);
}
