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