/// <summary>
/// Sets all necessary values for the ForwardSolverViewModel and executes forward/analysis query
/// </summary>
/// <param name="forwardSolverType"></param>
/// <param name="forwardAnalysisType"></param>
/// <param name="solutionDomainType"></param>
/// <param name="independentVariableAxis"></param>
/// <returns></returns>
private IDataPoint[] ExecuteForwardSolver(
ForwardSolverType forwardSolverType,
ForwardAnalysisType forwardAnalysisType,
SolutionDomainType solutionDomainType,
IndependentVariableAxis independentVariableAxis)
{
_vm.ForwardSolverTypeOptionVM.SelectedValue = forwardSolverType;
_vm.SolutionDomainTypeOptionVM.SelectedValue = solutionDomainType;
_vm.SolutionDomainTypeOptionVM.IndependentVariableAxisOptionVM.SelectedValue = independentVariableAxis;
_vm.ForwardAnalysisTypeOptionVM.SelectedValue = forwardAnalysisType;
return(_vm.ExecuteForwardSolver().First());
}
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[] ComputeReflectance(
IForwardSolver forwardSolver,
SolutionDomainType solutionDomainType,
ForwardAnalysisType forwardAnalysisType,
object[] independentValues)
{
Func <object[], double[]> func = GetForwardReflectanceFunc(forwardSolver, solutionDomainType);
//Func<SolutionDomainType, ForwardAnalysisType, IndependentVariableAxis[], double[]> getOptimizationParameters = (_,_,_) =>
// new[] { op.Mua, op.Musp, op.G, op.N }
//double[] optimizationParameters = GetOptimizationParameters(forwardSolver, solutionDomainType, independentAxisTypes); // will need this for inverse solver
// create a list of inputs (besides optical properties) that corresponds to the behavior of the function above
return(forwardAnalysisType == ForwardAnalysisType.R
? func(independentValues)
: func.GetDerivativeFunc(forwardAnalysisType)(independentValues));
}
public static Func <object[], double[]> GetDerivativeFunc(
this Func <object[], double[]> myFunc, ForwardAnalysisType analysisType)
{
switch (analysisType)
{
case ForwardAnalysisType.dRdMua:
return(parameters =>
{
var less = new object[parameters.Length];
var more = new object[parameters.Length];
for (var i = 1; i < parameters.Length; i++)
{
//loop through objects 2 to the end and set the data equal to parameters
less[i] = (double[])parameters[i];
more[i] = (double[])parameters[i];
}
var ops = (OpticalProperties[])parameters[0];
less[0] = ops.Select(opi => new OpticalProperties(opi.Mua * (1 - _delta), opi.Musp, opi.G, opi.N)).ToArray();
more[0] = ops.Select(opi => new OpticalProperties(opi.Mua * (1 + _delta), opi.Musp, opi.G, opi.N)).ToArray();
var lessValues = myFunc(less);
var moreValues = myFunc(more);
var opList = new OpticalProperties[lessValues.Length];
var counter = 0;
foreach (var o in ops)
{
for (var j = 0; j < lessValues.Length / ops.Length; j++)
{
//Add the values to the array
opList[counter] = o;
counter++;
}
}
return EnumerableExtensions.Zip(
lessValues.ToEnumerable <double>(),
moreValues.ToEnumerable <double>(),
opList,
(lessi, morei, opi) => (morei - lessi) / (2 * opi.Mua * _delta)).ToArray();
});
case ForwardAnalysisType.dRdMusp:
return(parameters =>
{
var less = new object[parameters.Length];
var more = new object[parameters.Length];
for (var i = 1; i < parameters.Length; i++)
{
//loop through objects 2 to the end and set the data equal to parameters
less[i] = (double[])parameters[i];
more[i] = (double[])parameters[i];
}
var ops = (OpticalProperties[])parameters[0];
less[0] = ops.Select(opi => new OpticalProperties(opi.Mua, opi.Musp * (1 - _delta), opi.G, opi.N)).ToArray();
more[0] = ops.Select(opi => new OpticalProperties(opi.Mua, opi.Musp * (1 + _delta), opi.G, opi.N)).ToArray();
var lessValues = myFunc(less);
var moreValues = myFunc(more);
var opList = new OpticalProperties[lessValues.Length];
var counter = 0;
foreach (var o in ops)
{
for (var j = 0; j < lessValues.Length / ops.Length; j++)
{
//Add the values to the array
opList[counter] = o;
counter++;
}
}
return EnumerableExtensions.Zip(
lessValues.ToEnumerable <double>(),
moreValues.ToEnumerable <double>(),
opList,
(lessi, morei, opi) => (morei - lessi) / (2 * opi.Musp * _delta)).ToArray();
});
case ForwardAnalysisType.dRdG:
return(parameters =>
{
var less = new object[parameters.Length];
var more = new object[parameters.Length];
for (var i = 1; i < parameters.Length; i++)
{
//loop through objects 2 to the end and set the data equal to parameters
less[i] = (double[])parameters[i];
more[i] = (double[])parameters[i];
}
var ops = (OpticalProperties[])parameters[0];
less[0] = ops.Select(opi => new OpticalProperties(opi.Mua, opi.Musp, opi.G * (1 - _delta), opi.N)).ToArray();
more[0] = ops.Select(opi => new OpticalProperties(opi.Mua, opi.Musp, opi.G * (1 + _delta), opi.N)).ToArray();
var lessValues = myFunc(less);
var moreValues = myFunc(more);
var opList = new OpticalProperties[lessValues.Length];
var counter = 0;
foreach (var o in ops)
{
for (var j = 0; j < lessValues.Length / ops.Length; j++)
{
//Add the values to the array
opList[counter] = o;
counter++;
}
}
return EnumerableExtensions.Zip(
lessValues.ToEnumerable <double>(),
moreValues.ToEnumerable <double>(),
opList,
(lessi, morei, opi) => (morei - lessi) / (2 * opi.G * _delta)).ToArray();
});
case ForwardAnalysisType.dRdN:
return(parameters =>
{
var less = new object[parameters.Length];
var more = new object[parameters.Length];
for (var i = 1; i < parameters.Length; i++)
{
//loop through objects 2 to the end and set the data equal to parameters
less[i] = (double[])parameters[i];
more[i] = (double[])parameters[i];
}
var ops = (OpticalProperties[])parameters[0];
less[0] = ops.Select(opi => new OpticalProperties(opi.Mua, opi.Musp, opi.G, opi.N * (1 - _delta))).ToArray();
more[0] = ops.Select(opi => new OpticalProperties(opi.Mua, opi.Musp, opi.G, opi.N * (1 + _delta))).ToArray();
var lessValues = myFunc(less);
var moreValues = myFunc(more);
var opList = new OpticalProperties[lessValues.Length];
var counter = 0;
foreach (var o in ops)
{
for (var j = 0; j < lessValues.Length / ops.Length; j++)
{
//Add the values to the array
opList[counter] = o;
counter++;
}
}
return EnumerableExtensions.Zip(
lessValues.ToEnumerable <double>(),
moreValues.ToEnumerable <double>(),
opList,
(lessi, morei, opi) => (morei - lessi) / (2 * opi.N * _delta)).ToArray();
});
default:
throw new ArgumentOutOfRangeException("analysisType");
}
}
