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(); } } } } }