private static void EvaluateAndWriteForwardSolver2DResults(ForwardSolverType fST,
SpatialDomainType sDT,
TimeDomainType tDT,
OpticalProperties op,
IEnumerable <double> spatialVariable,
double[,] temporalVariable)
{
double[] reflectanceValues;
var ReflectanceFunction = Get2DReflectanceFunction(fST, sDT, tDT);
MakeDirectoryIfNonExistent(sDT.ToString(), tDT.ToString(), fST.ToString());
var sV = spatialVariable.First();
var tV = temporalVariable.Row(0);
reflectanceValues = ReflectanceFunction(op.AsEnumerable(), sV.AsEnumerable(), tV).ToArray();
LocalWriteArrayToBinary(reflectanceValues, @"Output/" + sDT.ToString() +
"/" + tDT.ToString() + "/" + fST.ToString() + "/" +
"musp" + op.Musp.ToString() + "mua" + op.Mua.ToString(),
FileMode.Create);
for (int spaceInd = 1; spaceInd < spatialVariable.Count(); spaceInd++)
{
sV = spatialVariable.ElementAt(spaceInd);
tV = temporalVariable.Row(spaceInd);
reflectanceValues = ReflectanceFunction(op.AsEnumerable(), sV.AsEnumerable(), tV).ToArray();
LocalWriteArrayToBinary(reflectanceValues, @"Output/" + sDT.ToString() + "/" +
tDT.ToString() + "/" + fST.ToString() + "/" +
"musp" + op.Musp.ToString() + "mua" + op.Mua.ToString(),
FileMode.Append);
}
}
private IEnumerable <double> ROfRho(ForwardSolverType fst, OpticalProperties op, DoubleRange rho)
{
var ops = op.AsEnumerable();
var rhos = rho.AsEnumerable();
var fs = Factories.SolverFactory.GetForwardSolver(fst);
return(fs.ROfRho(ops, rhos));
}
private IEnumerable <Complex> ROfFxAndFt(ForwardSolverType fst, OpticalProperties op, double fx, DoubleRange ft)
{
var ops = op.AsEnumerable();
var fxs = fx.AsEnumerable();
var fts = ft.AsEnumerable();
var fs = Factories.SolverFactory.GetForwardSolver(fst);
return(fs.ROfFxAndFt(ops, fxs, fts));
}
private IEnumerable <double> ROfFxAndTime(ForwardSolverType fst, OpticalProperties op, double fx, DoubleRange time)
{
var ops = op.AsEnumerable();
var fxs = fx.AsEnumerable();
var times = time.AsEnumerable();
var fs = Factories.SolverFactory.GetForwardSolver(fst);
return(fs.ROfFxAndTime(ops, fxs, times));
}
private IEnumerable <double> ROfRho(ForwardSolverType forwardSolverType, OpticalProperties opticalProperties, DoubleRange rho, double noise)
{
var ops = opticalProperties.AsEnumerable();
var rhos = rho.AsEnumerable();
var fs = SolverFactory.GetForwardSolver(forwardSolverType);
if (noise > 0.0)
{
return(fs.ROfRho(ops, rhos).AddNoise(noise));
}
return(fs.ROfRho(ops, rhos));
}
private IEnumerable <double> ROfFxAndTime(ForwardSolverType forwardSolverType, OpticalProperties opticalProperties, double fx, DoubleRange time, double noise)
{
var ops = opticalProperties.AsEnumerable();
var fxs = fx.AsEnumerable();
var times = time.AsEnumerable();
var fs = SolverFactory.GetForwardSolver(forwardSolverType);
if (noise > 0.0)
{
return(fs.ROfFxAndTime(ops, fxs, times).AddNoise(noise));
}
return(fs.ROfFxAndTime(ops, fxs, times));
}
private IEnumerable <double> ROfFx(ForwardSolverType fst, OpticalProperties op, DoubleRange fx)
{
try
{
var ops = op.AsEnumerable();
var rhos = fx.AsEnumerable();
var fs = Factories.SolverFactory.GetForwardSolver(fst);
return(fs.ROfFx(ops, rhos));
}
catch (Exception e)
{
throw new Exception("Error in call to ROfFx: " + e.Message + "values fst: " + fst + ", op: " + op + ", rho:" + fx + " source: " + e.Source + " inner: " + e.InnerException);
}
}
private IEnumerable <Complex> ROfFxAndFt(ForwardSolverType forwardSolverType, OpticalProperties opticalProperties, double fx, DoubleRange ft, double noise)
{
var ops = opticalProperties.AsEnumerable().ToArray();
var fxs = fx.AsEnumerable().ToArray();
var fts = ft.AsEnumerable().ToArray();
var fs = SolverFactory.GetForwardSolver(forwardSolverType);
var results = fs.ROfRhoAndFt(ops, fxs, fts).ToArray();
if (noise > 0.0)
{
var realsWithNoise = results.Select(r => r.Real).AddNoise(noise);
var imagsWithNoise = results.Select(i => i.Imaginary).AddNoise(noise);
IEnumerable <Complex> resultsWithNoise = realsWithNoise.Zip(imagsWithNoise, (a, b) => new Complex(a, b));
return(resultsWithNoise);
}
return(fs.ROfFxAndFt(ops, fxs, fts));
}
private static void EvaluateAndWriteForwardSolverSteadyStateResults(ForwardSolverType fST,
SpatialDomainType sDT,
OpticalProperties op,
IEnumerable <double> spatialVariable)
{
double[] reflectanceValues;
var ReflectanceFunction = GetSteadyStateReflectanceFunction(fST, sDT);
MakeDirectoryIfNonExistent(sDT.ToString(), "SteadyState", fST.ToString());
reflectanceValues = ReflectanceFunction(op.AsEnumerable(), spatialVariable).ToArray();
LocalWriteArrayToBinary(reflectanceValues, @"Output/" + sDT.ToString() +
"/SteadyState/" + fST.ToString() + "/" +
"musp" + op.Musp.ToString() + "mua" + op.Mua.ToString(), FileMode.Create);
}
private IEnumerable <double> ROfFx(ForwardSolverType forwardSolverType, OpticalProperties opticalProperties, DoubleRange fx, double noise)
{
try
{
var ops = opticalProperties.AsEnumerable();
var fxs = fx.AsEnumerable();
var fs = SolverFactory.GetForwardSolver(forwardSolverType);
if (noise > 0.0)
{
return(fs.ROfFx(ops, fxs).AddNoise(noise));
}
return(fs.ROfFx(ops, fxs));
}
catch (Exception e)
{
_logger.LogError("Error in call to ROfFx: " + e.Message + "values fst: " + forwardSolverType + ", op: " + opticalProperties + ", rho:" + fx + " source: " + e.Source + " inner: " + e.InnerException);
throw;
}
}
public override double ROfTheta(OpticalProperties op, double theta)
{
return(ROfTheta(op.AsEnumerable(), theta.AsEnumerable()).FirstOrDefault());
}
/// <summary>
/// Evaluates the steady state reflectance at
/// a single source detector separation rho, for the specified single set of optical properties.
/// </summary>
/// <param name="op">optical properties</param>
/// <param name="rho">source detector separation</param>
/// <returns>spatailly resolved reflectance</returns>
public override double ROfRho(OpticalProperties op, double rho)
{
return(ROfRho(op.AsEnumerable(), rho.AsEnumerable()).First());
}
/// <summary>
/// Calls its vectorized version to evaluate the spatial frequency
/// resolved reflectance for the spatial frequancy fx, for the
/// specified optical properties.
/// </summary>
/// <param name="op">optical properties</param>
/// <param name="fx">spatial frequency</param>
/// <returns>spatial frequency resolved reflectance</returns>
public override double ROfFx(OpticalProperties op, double fx)
{
return(ROfFx(op.AsEnumerable(), fx.AsEnumerable()).FirstOrDefault());
}
/// <summary>
/// Calls its vectorized version to evaluate the temporal frequency and space resolved
/// reflectance at a source detector separation rho for a modulation frequency ft,
/// for the specified optical properties.
/// </summary>
/// <param name="op">optical properties</param>
/// <param name="rho">source detector separation</param>
/// <param name="ft">modulation frequency</param>
/// <returns>reflectance intensity</returns>
public override Complex ROfRhoAndFt(OpticalProperties op, double rho, double ft)
{
return(ROfRhoAndFt(op.AsEnumerable(), rho.AsEnumerable(), ft.AsEnumerable()).FirstOrDefault());
}
/// <summary>
/// Evaluates reflectance as aa function of spatial frequency and time
/// </summary>
/// <param name="op">optical properties</param>
/// <param name="fx">spatial frequency</param>
/// <param name="t">time</param>
/// <returns>reflectance at specified optical properties, spatial frequency and time</returns>
public override double ROfFxAndTime(OpticalProperties op, double fx, double t)
{
return(ROfFxAndTime(op.AsEnumerable(), fx.AsEnumerable(), fx.AsEnumerable()).First());
}
/// <summary>
/// Evaluates reflectance ay spatial frequency and modulation frequency
/// </summary>
/// <param name="op">optical properties</param>
/// <param name="fx">spatial frequency</param>
/// <param name="ft">modulation frequency</param>
/// <returns>reflectance at specified optical properties, spatial frequency and modulation frequency</returns>
public override Complex ROfFxAndFt(OpticalProperties op, double fx, double ft)
{
return(ROfFxAndFt(op.AsEnumerable(), fx.AsEnumerable(), ft.AsEnumerable()).First());
}
private static void ReportInverseSolverROfRho(double drho,
double[] rhoRange,
InverseFitType IFT,
string projectName,
string inputPath,
ForwardSolverType[] forwardSolverTypes,
OptimizerType[] optimizerTypes,
IEnumerable <OpticalProperties> guessOps,
IEnumerable <OpticalProperties> realOps,
int ratioDetectors,
double noisePercentage,
bool stepByStep)
{
Console.WriteLine("#############################################");
Console.WriteLine("####### REPORT INVERSE SOLVER: ROfRho #######");
Console.WriteLine("#############################################");
//path definition
string spaceDomainFolder = "Real";
string timeDomainFolder = "SteadyState";
string problemFolder = "drho" + drho.ToString() + "/" + "ratioD" + ratioDetectors.ToString() + "/" +
"noise" + noisePercentage.ToString() + "/" + rhoRange[0].ToString() + "_" + rhoRange[1].ToString();
problemFolder = problemFolder.Replace(".", "p");
//rhos based on range
int numberOfPoints = Convert.ToInt32((rhoRange[1] - rhoRange[0]) / drho) + 1;
var rhos = new DoubleRange(rhoRange[0], rhoRange[1], numberOfPoints).AsEnumerable().ToArray();
double[] R = new double[numberOfPoints];
double[] S = new double[numberOfPoints];
//based on range evaluate the index of first and last points to use
int firstInd = Convert.ToInt32((rhoRange[0] + drho / 2.0) / drho) - 1;
int lastInd = Convert.ToInt32((rhoRange[1] + drho / 2) / drho) - 1;
//execute
foreach (var fST in forwardSolverTypes)
{
Console.WriteLine("Forward Solver Type: {0}", fST.ToString());
foreach (var oT in optimizerTypes)
{
Console.WriteLine("Optimizer Type: {0}", oT.ToString());
if (stepByStep)
{
Console.WriteLine("Press enter to continue");
}
Console.WriteLine("=================================================");
if (stepByStep)
{
Console.ReadLine();
}
foreach (var rOp in realOps)
{
//output
double bestMua = 0.0;
double meanMua = 0.0;
double guessBestMua = 0.0;
double bestMusp = 0.0;
double meanMusp = 0.0;
double guessBestMusp = 0.0;
double bestChiSquared = 10000000000000.0; //initialize very large to avoid if first
double meanChiSquared = 0.0;
DateTime start = new DateTime(); //processing start time
DateTime end = new DateTime(); //processing finish time
double elapsedSeconds; //processing time
//set filename based on real optical properties
var filename = "musp" + rOp.Musp.ToString() + "mua" + rOp.Mua.ToString();
filename = filename.Replace(".", "p");
Console.WriteLine("Looking for file {0}", filename);
if (File.Exists(inputPath + spaceDomainFolder + "/" + timeDomainFolder + "/" + filename + "R"))
{
Console.WriteLine("The file has been found");
//read binary files
var Rtot = (IEnumerable <double>)FileIO.ReadArrayFromBinaryInResources <double>
("Resources/" + spaceDomainFolder + "/" + timeDomainFolder + "/" + filename + "R", projectName, 88);
var Stot = (IEnumerable <double>)FileIO.ReadArrayFromBinaryInResources <double>
("Resources/" + spaceDomainFolder + "/" + timeDomainFolder + "/" + filename + "S", projectName, 88);
// extract points within range
for (int i = firstInd; i <= lastInd; i++)
{
R[i - firstInd] = Rtot.ToArray()[i];
S[i - firstInd] = Stot.ToArray()[i];
}
// reduce number of measurements
var mrhos = FilterArray(rhos, ratioDetectors);
var mR = FilterArray(R, ratioDetectors);
var mS = FilterArray(S, ratioDetectors);
// add noise
if (noisePercentage != 0.0)
{
mR.AddNoise(noisePercentage);
}
start = DateTime.Now;
int covergedCounter = 0;
foreach (var gOp in guessOps)
{
bool converged;
//if fitting only one parameter change the guess to the true value
if (IFT == InverseFitType.Mua)
{
gOp.Musp = rOp.Musp;
}
if (IFT == InverseFitType.Musp)
{
gOp.Mua = rOp.Mua;
}
//solve inverse problem
double[] fit = ComputationFactory.SolveInverse(fST, oT, SolutionDomainType.ROfRho, mR, mS, IFT, new object[] { new[] { gOp }, mrhos });
if (fit[0] != 0 && fit[1] != 0)
{
converged = true;
}
else
{
converged = false;
}
// fitted op
if (converged)
{
OpticalProperties fOp = new OpticalProperties(fit[0], fit[1], gOp.G, gOp.N);
//calculate chi squared and change values if it improved
double chiSquared = EvaluateChiSquared(mR, SolverFactory.GetForwardSolver(fST).ROfRho(fOp.AsEnumerable(), mrhos).ToArray(), mS);
if (chiSquared < bestChiSquared)
{
guessBestMua = gOp.Mua;
bestMua = fit[0];
guessBestMusp = gOp.Musp;
bestMusp = fit[1];
bestChiSquared = chiSquared;
}
meanMua += fit[0];
meanMusp += fit[1];
meanChiSquared += chiSquared;
covergedCounter += 1;
}
}
end = DateTime.Now;
meanMua /= covergedCounter;
meanMusp /= covergedCounter;
meanChiSquared /= covergedCounter;
elapsedSeconds = (end - start).TotalSeconds;
MakeDirectoryIfNonExistent(new string[] { spaceDomainFolder, timeDomainFolder, problemFolder, fST.ToString(), oT.ToString(), IFT.ToString() });
//write results to array
double[] inverseProblemValues = FillInverseSolverValuesArray(bestMua, meanMua, guessBestMua,
bestMusp, meanMusp, guessBestMusp,
bestChiSquared, meanChiSquared,
elapsedSeconds, mR.Count());
// write array to binary
LocalWriteArrayToBinary(inverseProblemValues, @"Output/" + spaceDomainFolder + "/" +
timeDomainFolder + "/" + problemFolder + "/" + fST.ToString() + "/" +
oT.ToString() + "/" + IFT.ToString() + "/" + filename, FileMode.Create);
Console.WriteLine("Real MUA = {0} - best MUA = {1} - mean MUA = {2}", rOp.Mua, bestMua, meanMua);
Console.WriteLine("Real MUSp = {0} - best MUSp = {1} - mean MUSp = {2}", rOp.Musp, bestMusp, meanMusp);
if (stepByStep)
{
Console.ReadLine();
}
}
else
{
Console.WriteLine("The file has not been found.");
}
Console.Clear();
}
}
}
}
/// <summary>
/// Evaluates spatially- and temporally- resolved reflectance at specified optical properties, rho and time
/// </summary>
/// <param name="op">optical properties</param>
/// <param name="rho">source-detector separation</param>
/// <param name="t">time</param>
/// <returns>reflectance at specified optical properties, rho and time </returns>
public override double ROfRhoAndTime(OpticalProperties op, double rho, double t)
{
return(ROfRhoAndTime(op.AsEnumerable(), rho.AsEnumerable(), t.AsEnumerable()).First());
}
private static void ReportInverseSolverROfRhoAndTime(double dt,
double riseMarker,
double tailMarker,
string stDevMode,
InverseFitType IFT,
string projectName,
string inputPath,
ForwardSolverType[] forwardSolverTypes,
OptimizerType[] optimizerTypes,
IEnumerable <OpticalProperties> guessOps,
IEnumerable <OpticalProperties> realOps,
double[] rhos,
double noisePercentage,
bool stepByStep)
{
Console.WriteLine("#############################################");
Console.WriteLine("##### REPORT INVERSE SOLVER: ROfRhoAndT #####");
Console.WriteLine("#############################################");
//path definition
string spaceDomainFolder = "Real";
string timeDomainFolder = "TimeDomain";
string noiseFolder = "noise" + noisePercentage.ToString();
string problemFolder = "dt" + (dt * 1000).ToString() + "markers" + riseMarker.ToString() +
tailMarker.ToString();
problemFolder = problemFolder.Replace(".", "p");
foreach (var fST in forwardSolverTypes)
{
//initialize forward solver
Console.WriteLine("Forward Solver Type: {0}", fST.ToString());
foreach (var oT in optimizerTypes)
{
Console.WriteLine("Optimizer Type: {0}", oT.ToString());
foreach (var rho in rhos)
{
string rhoFolder = rho.ToString();
Console.WriteLine("=================================================");
Console.WriteLine("SOURCE DETECTOR SEPARETION: R = {0} mm", rhoFolder);
if (stepByStep)
{
Console.WriteLine("Press enter to continue");
}
Console.WriteLine("=================================================");
if (stepByStep)
{
Console.ReadLine();
}
rhoFolder = rhoFolder.Replace(".", "p");
rhoFolder = "rho" + rhoFolder;
double[] constantVals = { rho };
foreach (var rOp in realOps)
{
//output
double bestMua = 0.0;
double meanMua = 0.0;
double guessBestMua = 0.0;
double bestMusp = 0.0;
double meanMusp = 0.0;
double guessBestMusp = 0.0;
double bestChiSquared = 10000000000000.0; //initialize very large to avoid if first
double meanChiSquared = 0.0;
DateTime start = new DateTime(); //processing start time
DateTime end = new DateTime(); //processing finish time
double elapsedSeconds; //processing time
//set filename based on real optical properties
var filename = "musp" + rOp.Musp.ToString() + "mua" + rOp.Mua.ToString();
filename = filename.Replace(".", "p");
Console.WriteLine("Looking for file {0}", filename);
if (File.Exists(inputPath + spaceDomainFolder + "/" + timeDomainFolder + "/" + problemFolder + "/" + rhoFolder + "/" + filename + "Range"))
{
Console.WriteLine("The file has been found for rho = {0} mm.", rho);
//read binary files
var timeRange = (double[])FileIO.ReadArrayFromBinaryInResources <double>
("Resources/" + spaceDomainFolder + "/" + timeDomainFolder + "/" + problemFolder + "/" + rhoFolder + "/" + filename + "Range", projectName, 2);
int numberOfPoints = Convert.ToInt32((timeRange[1] - timeRange[0]) / dt) + 1;
var T = new DoubleRange(timeRange[0], timeRange[1], numberOfPoints).AsEnumerable().ToArray();
var R = (double[])FileIO.ReadArrayFromBinaryInResources <double>
("Resources/" + spaceDomainFolder + "/" + timeDomainFolder + "/" + problemFolder + "/" + rhoFolder + "/" + filename + "R", projectName, numberOfPoints);
var S = GetStandardDeviationValues("Resources/" + spaceDomainFolder + "/" + timeDomainFolder + "/" + problemFolder + "/" + rhoFolder + "/" + filename + "S",
projectName, stDevMode, numberOfPoints, R.ToArray());
// add noise
if (noisePercentage != 0.0)
{
R = R.AddNoise(noisePercentage);
}
start = DateTime.Now;
int convergedCounter = 0;
foreach (var gOp in guessOps)
{
bool converged;
if (IFT == InverseFitType.Mua)
{
gOp.Musp = rOp.Musp;
}
if (IFT == InverseFitType.Musp)
{
gOp.Mua = rOp.Mua;
}
//solve inverse problem
double[] fit = ComputationFactory.SolveInverse(fST, oT, SolutionDomainType.ROfRhoAndTime, R, S, IFT, new object[] { new[] { gOp }, constantVals, T });
if (fit[0] != 0 && fit[1] != 0)
{
converged = true;
}
else
{
converged = false;
}
if (converged)
{
OpticalProperties fOp = new OpticalProperties(fit[0], fit[1], gOp.G, gOp.N);
//calculate chi squared and change best values if it improved
double chiSquared = EvaluateChiSquared(R.ToArray(), SolverFactory.GetForwardSolver(fST).ROfRhoAndTime(fOp.AsEnumerable(), rho.AsEnumerable(), T).ToArray(), S.ToArray());
if (chiSquared < bestChiSquared)
{
guessBestMua = gOp.Mua;
bestMua = fit[0];
guessBestMusp = gOp.Musp;
bestMusp = fit[1];
bestChiSquared = chiSquared;
}
meanMua += fit[0];
meanMusp += fit[1];
meanChiSquared += chiSquared;
convergedCounter += 1;
}
}
end = DateTime.Now;
meanMua /= convergedCounter;
meanMusp /= convergedCounter;
meanChiSquared /= convergedCounter;
elapsedSeconds = (end - start).TotalSeconds;
MakeDirectoryIfNonExistent(new string[] { spaceDomainFolder, timeDomainFolder, noiseFolder, problemFolder, fST.ToString(), oT.ToString(), IFT.ToString(), rhoFolder });
//write results to array
double[] inverseProblemValues = FillInverseSolverValuesArray(bestMua, meanMua, guessBestMua,
bestMusp, meanMusp, guessBestMusp,
bestChiSquared, meanChiSquared,
elapsedSeconds, numberOfPoints);
// write array to binary
LocalWriteArrayToBinary(inverseProblemValues, @"Output/" + spaceDomainFolder + "/" +
timeDomainFolder + "/" + noiseFolder + "/" + problemFolder + "/" + fST.ToString() + "/" +
oT.ToString() + "/" + IFT.ToString() + "/" + rhoFolder + "/" + filename, FileMode.Create);
Console.WriteLine("Real MUA = {0} - best MUA = {1} - mean MUA = {2}", rOp.Mua, bestMua, meanMua);
Console.WriteLine("Real MUSp = {0} - best MUSp = {1} - mean MUSp = {2}", rOp.Musp, bestMusp, meanMusp);
if (stepByStep)
{
Console.ReadLine();
}
}
else
{
Console.WriteLine("The file has not been found.");
}
Console.Clear();
}
}
}
}
}
