/// <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"); } }