public static double[] SolveInverse(
ForwardSolverType forwardSolverType,
OptimizerType optimizerType,
SolutionDomainType solutionDomainType,
double[] dependentValues,
double[] standardDeviationValues,
InverseFitType inverseFitType,
object[] independentValues,
double[] lowerBounds,
double[] upperBounds)
{
// use factory method on each call, as opposed to injecting an instance from the outside
// -- still time-efficient if singletons are used
// -- potentially memory-inefficient if the user creates lots of large solver instances
return(SolveInverse(
SolverFactory.GetForwardSolver(forwardSolverType),
SolverFactory.GetOptimizer(optimizerType),
solutionDomainType,
dependentValues,
standardDeviationValues,
inverseFitType,
independentValues,
lowerBounds,
upperBounds));
}
/// <summary>
/// Overload of GetPHD that uses internal DI framework-supplied solver singletons
/// </summary>
/// <param name="forwardSolverType">enum of forward solver type</param>
/// <param name="fluence">fluence</param>
/// <param name="sdSeparation">source detector separation (in mm)</param>
/// <param name="ops">optical properties</param>
/// <param name="rhos">detector locations (in mm)</param>
/// <param name="zs">z values (in mm)</param>
/// <returns></returns>
public static double[] GetPHD(ForwardSolverType forwardSolverType, Complex[] fluence, double sdSeparation,
double timeModulationFrequency, OpticalProperties[] ops, double[] rhos,
double[] zs)
{
return(GetPHD(SolverFactory.GetForwardSolver(forwardSolverType), fluence, sdSeparation,
timeModulationFrequency, ops, rhos, zs));
}
public static double[] ComputeReflectance(
ForwardSolverType forwardSolverType,
SolutionDomainType solutionDomainType,
ForwardAnalysisType forwardAnalysisType,
object[] independentValues)
{
// use factory method on each call, as opposed to injecting an instance from the outside
// -- still time-efficient if singletons are used
// -- potentially memory-inefficient if the user creates lots of large solver instances
return(ComputeReflectance(
SolverFactory.GetForwardSolver(forwardSolverType),
solutionDomainType,
forwardAnalysisType,
independentValues));
}
public static double[] ComputeFluence(
ForwardSolverType forwardSolverType,
FluenceSolutionDomainType solutionDomainType, // keeping us from uniting the above. needs to be a single SolutionDomainType enum
IndependentVariableAxis[] independentAxesTypes,
double[][] independentValues,
OpticalProperties[] opticalProperties,
params double[] constantValues)
{
// use factory method on each call, as opposed to injecting an instance from the outside
// -- still time-efficient if singletons are used
// -- potentially memory-inefficient if the user creates lots of large solver instances
return(ComputeFluence(
SolverFactory.GetForwardSolver(forwardSolverType),
solutionDomainType,
independentAxesTypes,
independentValues,
opticalProperties,
constantValues));
}
/// <summary>
/// Overload of GetPHD that uses internal DI framework-supplied solver singletons
/// </summary>
/// <param name="forwardSolverType">enum of forward solver type</param>
/// <param name="fluence">fluence</param>
/// <param name="sdSeparation">source detector separation (in mm)</param>
/// <param name="ops">optical properties</param>
/// <param name="rhos">detector locations (in mm)</param>
/// <param name="zs">z values (in mm)</param>
/// <returns></returns>
public static double[] GetPHD(ForwardSolverType forwardSolverType, double[] fluence, double sdSeparation,
OpticalProperties[] ops, double[] rhos, double[] zs)
{
return(GetPHD(SolverFactory.GetForwardSolver(forwardSolverType), fluence, sdSeparation, ops, rhos, zs));
}
