public static int GetMaxArgumentLocation(this IndependentVariableAxis axis)
{
switch (axis)
{
case IndependentVariableAxis.Rho:
return(0);
case IndependentVariableAxis.Time:
return(2);
case IndependentVariableAxis.Fx:
return(0);
case IndependentVariableAxis.Ft:
return(2);
case IndependentVariableAxis.Z:
return(1);
case IndependentVariableAxis.Wavelength:
return(2);
default:
throw new NotImplementedException("Independent axis " + axis + " is not implemented for this software feature.");
}
}
public static int GetMaxArgumentLocation(this IndependentVariableAxis axis)
{
switch (axis)
{
case IndependentVariableAxis.Rho:
return(0);
case IndependentVariableAxis.Time:
return(2);
case IndependentVariableAxis.Fx:
return(0);
case IndependentVariableAxis.Ft:
return(2);
case IndependentVariableAxis.Z:
return(1);
case IndependentVariableAxis.Wavelength:
return(2);
default:
throw new NotImplementedException(StringLookup.GetLocalizedString("Exception_IndependentAxis") + axis +
StringLookup.GetLocalizedString("Exception_CustomNotImplemented"));
}
}
internal int GetParameterOrder(IndependentVariableAxis axis)
{
switch (axis)
{
case IndependentVariableAxis.Wavelength:
return(0);
case IndependentVariableAxis.Rho:
return(1);
case IndependentVariableAxis.Fx:
return(1);
case IndependentVariableAxis.Time:
return(2);
case IndependentVariableAxis.Ft:
return(2);
case IndependentVariableAxis.Z:
return(3);
default:
throw new InvalidEnumArgumentException("There is no Enum of this type");
}
}
/// <summary>
/// Function to provide ordering information for assembling forward calls
/// </summary>
/// <param name="axis"></param>
/// <returns></returns>
private int GetParameterOrder(IndependentVariableAxis axis)
{
switch (axis)
{
case IndependentVariableAxis.Wavelength:
return(0);
case IndependentVariableAxis.Rho:
return(1);
case IndependentVariableAxis.Fx:
return(1);
case IndependentVariableAxis.Time:
return(2);
case IndependentVariableAxis.Ft:
return(2);
case IndependentVariableAxis.Z:
return(3);
default:
throw new ArgumentOutOfRangeException("axis");
}
}
private double[] GetParameterValues(IndependentVariableAxis axis)
{
var isConstant = SolutionDomainTypeOptionVM.IndependentVariableAxisOptionVM.UnSelectedValues.Contains(axis);
if (isConstant)
{
//var positionIndex = SolutionDomainTypeOptionVM.IndependentVariableAxisOptionVM.UnSelectedValues.IndexOf(axis);
var positionIndex = 0; //hard-coded for now
switch (positionIndex)
{
case 0:
default:
return(new[] { SolutionDomainTypeOptionVM.ConstantAxesVMs[0].AxisValue });
case 1:
return(new[] { SolutionDomainTypeOptionVM.ConstantAxesVMs[1].AxisValue });
//case 2:
// return new[] { SolutionDomainTypeOptionVM.ConstantAxisThreeValue };
}
}
else
{
var numAxes = SolutionDomainTypeOptionVM.IndependentVariableAxisOptionVM.SelectedValues.Length;
var positionIndex = 0; //hard-coded for now
//var positionIndex = SolutionDomainTypeOptionVM.IndependentVariableAxisOptionVM.SelectedValues.IndexOf(axis);
switch (numAxes)
{
case 1:
default:
return(AllRangeVMs[0].Values.ToArray());
case 2:
switch (positionIndex)
{
case 0:
default:
return(AllRangeVMs[1].Values.ToArray());
case 1:
return(AllRangeVMs[0].Values.ToArray());
}
case 3:
switch (positionIndex)
{
case 0:
default:
return(AllRangeVMs[2].Values.ToArray());
case 1:
return(AllRangeVMs[1].Values.ToArray());
case 2:
return(AllRangeVMs[0].Values.ToArray());
}
}
}
}
/// <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 RangeViewModel(DoubleRange range, string units, IndependentVariableAxis axisType, string title, bool enableNumber)
{
_range = range;
Units = units;
Title = title;
_enableNumber = enableNumber;
_axisType = axisType;
// todo: does this do anything? (start, stop, number already directly modified)
_range.PropertyChanged += (s, a) =>
{
this.OnPropertyChanged("Start");
this.OnPropertyChanged("Stop");
this.OnPropertyChanged("Number");
};
}
private static Func <double[], object[], Complex[]> GetForwardFluenceFuncComplex(
IForwardSolver fs, FluenceSolutionDomainType type, IndependentVariableAxis axis)
{
Func <double[], OpticalProperties> getOP = op => new OpticalProperties(op[0], op[1], op[2], op[3]);
// note: the following uses the convention that the independent variable(s) is (are) first in the forward data object array
// note: secondly, if there are multiple independent axes, they will be assigned in order of appearance in the method signature
switch (type)
{
case FluenceSolutionDomainType.FluenceOfRhoAndZAndFt:
switch (axis)
{
case IndependentVariableAxis.Rho:
if (fs is TwoLayerSDAForwardSolver) // todo: future generalization to IMultiRegionForwardSolver?
{
return((fitData, otherData) => fs.FluenceOfRhoAndZAndFt(new[] { getLayerTissueRegionArray(fitData) }, (double[])otherData[0], (double[])otherData[1], new[] { (double)otherData[2] }));
}
return((fitData, otherData) => fs.FluenceOfRhoAndZAndFt(new[] { getOP(fitData) }, (double[])otherData[0], (double[])otherData[1], new[] { (double)otherData[2] }));
case IndependentVariableAxis.Ft:
if (fs is TwoLayerSDAForwardSolver)
{
return((fitData, otherData) => fs.FluenceOfRhoAndZAndFt(new[] { getLayerTissueRegionArray(fitData) }, (double[])otherData[2], (double[])otherData[1], new[] { (double)otherData[0] }));
}
return((fitData, otherData) => fs.FluenceOfRhoAndZAndFt(new[] { getOP(fitData) }, new[] { (double)otherData[2] }, (double[])otherData[1], (double[])otherData[0]));
default:
throw new ArgumentOutOfRangeException("axis");
}
case FluenceSolutionDomainType.FluenceOfFxAndZAndFt:
switch (axis)
{
case IndependentVariableAxis.Fx:
return((fitData, otherData) => fs.FluenceOfFxAndZAndFt(new[] { getOP(fitData) }, (double[])otherData[0], (double[])otherData[1], new[] { (double)otherData[2] }));
case IndependentVariableAxis.Ft:
return((fitData, otherData) => fs.FluenceOfFxAndZAndFt(new[] { getOP(fitData) }, new[] { (double)otherData[2] }, (double[])otherData[1], (double[])otherData[0]));
default:
throw new ArgumentOutOfRangeException("axis");
}
default:
throw new ArgumentOutOfRangeException("type");
}
}
/// <summary>
/// Sets all necessary values for the InverseSolverViewModel and executes the optimization problem
/// </summary>
/// <param name="measuredForwardSolverType"></param>
/// <param name="inverseForwardSolverType"></param>
/// <param name="solutionDomainType"></param>
/// <param name="independentVariableAxis"></param>
/// <param name="inverseFitType"></param>
/// <returns></returns>
private IDataPoint[][] ExecuteInverseSolver(
ForwardSolverType measuredForwardSolverType,
ForwardSolverType inverseForwardSolverType,
SolutionDomainType solutionDomainType,
IndependentVariableAxis independentVariableAxis,
InverseFitType inverseFitType)
{
_vm.MeasuredForwardSolverTypeOptionVM.SelectedValue = measuredForwardSolverType;
_vm.InverseForwardSolverTypeOptionVM.SelectedValue = inverseForwardSolverType;
_vm.SolutionDomainTypeOptionVM.SelectedValue = solutionDomainType;
_vm.SolutionDomainTypeOptionVM.IndependentVariableAxisOptionVM.SelectedValue = independentVariableAxis;
_vm.InverseFitTypeOptionVM.SelectedValue = inverseFitType;
var fitResults = _vm.SolveInverse();
return(fitResults.FitDataPoints);
}
public static bool IsTemporalAxis(this IndependentVariableAxis axis)
{
switch (axis)
{
case IndependentVariableAxis.Time:
case IndependentVariableAxis.Ft:
return(true);
case IndependentVariableAxis.Rho:
case IndependentVariableAxis.Fx:
case IndependentVariableAxis.Z:
case IndependentVariableAxis.Wavelength:
return(false);
default:
throw new NotImplementedException("Independent axis " + axis + " is not implemented for this software feature.");
}
}
public static bool IsTemporalAxis(this IndependentVariableAxis axis)
{
switch (axis)
{
case IndependentVariableAxis.Time:
case IndependentVariableAxis.Ft:
return(true);
case IndependentVariableAxis.Rho:
case IndependentVariableAxis.Fx:
case IndependentVariableAxis.Z:
case IndependentVariableAxis.Wavelength:
return(false);
default:
throw new NotImplementedException(StringLookup.GetLocalizedString("Exception_IndependentAxis") + axis +
StringLookup.GetLocalizedString("Exception_CustomNotImplemented"));
}
}
public static string GetTitle(this IndependentVariableAxis axis)
{
switch (axis)
{
case IndependentVariableAxis.Rho:
default:
return(IndependentVariableAxis.Rho.GetLocalizedString());
case IndependentVariableAxis.Time:
return(IndependentVariableAxis.Time.GetLocalizedString());
case IndependentVariableAxis.Fx:
return(IndependentVariableAxis.Fx.GetLocalizedString());
case IndependentVariableAxis.Ft:
return(IndependentVariableAxis.Ft.GetLocalizedString());
case IndependentVariableAxis.Wavelength:
return(IndependentVariableAxis.Wavelength.GetLocalizedString());
}
}
public static double GetDefaultConstantAxisValue(this IndependentVariableAxis constantType)
{
switch (constantType)
{
case IndependentVariableAxis.Rho:
default:
return(1.0);
case IndependentVariableAxis.Time:
return(0.05);
case IndependentVariableAxis.Fx:
return(0.0);
case IndependentVariableAxis.Ft:
return(0.0);
case IndependentVariableAxis.Wavelength:
return(650.0);
}
}
public static DoubleRange GetDefaultRange(this IndependentVariableAxis independentAxisType)
{
switch (independentAxisType)
{
case IndependentVariableAxis.Rho:
default:
return(new DoubleRange(0.5D, 9.5D, 19)); // units=mm
case IndependentVariableAxis.Time:
return(new DoubleRange(0D, 0.05D, 51)); // units=ns
case IndependentVariableAxis.Fx:
return(new DoubleRange(0D, 0.5D, 51));
case IndependentVariableAxis.Ft:
return(new DoubleRange(0D, 0.5D, 51)); // units=GHz
case IndependentVariableAxis.Wavelength:
return(new DoubleRange(650D, 1000D, 36)); // units=nm
}
}
public static string GetUnits(this IndependentVariableAxis axis)
{
switch (axis)
{
case IndependentVariableAxis.Rho:
default:
return(IndependentVariableAxisUnits.MM.GetInternationalizedString());
case IndependentVariableAxis.Time:
return(IndependentVariableAxisUnits.NS.GetInternationalizedString());
case IndependentVariableAxis.Fx:
return(IndependentVariableAxisUnits.InverseMM.GetInternationalizedString());
case IndependentVariableAxis.Ft:
return(IndependentVariableAxisUnits.GHz.GetInternationalizedString());
case IndependentVariableAxis.Wavelength:
return(IndependentVariableAxisUnits.NM.GetInternationalizedString());
}
}
public RangeViewModel(DoubleRange range, string units, IndependentVariableAxis axisType, string title)
: this(range, units, axisType, title, true)
{
}
// todo: array overloads for fluence forward solvers too
private static Func <double[], object[], double[]> GetForwardFluenceFunc(
IForwardSolver fs, FluenceSolutionDomainType type, IndependentVariableAxis axis)
{
Func <double[], OpticalProperties> getOP = op => new OpticalProperties(op[0], op[1], op[2], op[3]);
// note: the following uses the convention that the independent variable(s) is (are) first in the forward data object array
// note: secondly, if there are multiple independent axes, they will be assigned in order of appearance in the method signature
switch (type)
{
case FluenceSolutionDomainType.FluenceOfRhoAndZ:
if (fs is TwoLayerSDAForwardSolver) // todo: future generalization to IMultiRegionForwardSolver?
{
return((fitData, otherData) => fs.FluenceOfRhoAndZ(new[] { getLayerTissueRegionArray(fitData) }, (double[])otherData[0], (double[])otherData[1]));
}
return((fitData, otherData) => fs.FluenceOfRhoAndZ(new[] { getOP(fitData) }, (double[])otherData[0], (double[])otherData[1]));
case FluenceSolutionDomainType.FluenceOfFxAndZ:
return((fitData, otherData) => fs.FluenceOfFxAndZ(new[] { getOP(fitData) }, (double[])otherData[0], (double[])otherData[1]));
case FluenceSolutionDomainType.FluenceOfRhoAndZAndTime:
switch (axis)
{
case IndependentVariableAxis.Rho:
return((fitData, otherData) => fs.FluenceOfRhoAndZAndTime(new[] { getOP(fitData) }, (double[])otherData[0], (double[])otherData[1], new[] { (double)otherData[2] }));
case IndependentVariableAxis.Time:
return((fitData, otherData) => fs.FluenceOfRhoAndZAndTime(new[] { getOP(fitData) }, new[] { (double)otherData[2] }, (double[])otherData[1], (double[])otherData[0]));
//case IndependentVariableAxis.Wavelength:
// return (chromPlusMusp, constantData) =>
// {
// var wv = (double[]) constantData[0];
// var tissue = (Tissue) constantData[1];
// int i = 0;
// tissue.Absorbers.ForEach(abs => abs.Concentration = chromPlusMusp[i++]);
// tissue.Scatterer = new PowerLawScatterer(chromPlusMusp[i], chromPlusMusp[i + 1]);
// var muas = wv.Select(w => tissue.GetMua(w));
// var musps = wv.Select(w => tissue.GetMusp(w));
// return EnumerableExtensions.Zip(muas,musps,(mua,musp)=>fs.ROfRhoAndTime())...
// };
// return op => fs.ROfRhoAndTime(op, ((double)constantValues[0]).AsEnumerable(), ((double)constantValues[1]).AsEnumerable());
default:
throw new ArgumentOutOfRangeException("axis");
}
case FluenceSolutionDomainType.FluenceOfFxAndZAndTime:
switch (axis)
{
case IndependentVariableAxis.Fx:
return((fitData, otherData) => fs.FluenceOfFxAndZAndTime(new[] { getOP(fitData) }, (double[])otherData[0], (double[])otherData[1], new[] { (double)otherData[2] }));
case IndependentVariableAxis.Time:
return((fitData, otherData) => fs.FluenceOfFxAndZAndTime(new[] { getOP(fitData) }, new[] { (double)otherData[2] }, (double[])otherData[1], (double[])otherData[0]));
default:
throw new ArgumentOutOfRangeException("axis");
}
default:
throw new ArgumentOutOfRangeException("type");
}
}
private double[] GetParameterValues(IndependentVariableAxis axis)
{
var isConstant = SolutionDomainTypeOptionVM.IndependentVariableAxisOptionVM.UnSelectedValues.Contains(axis);
if (isConstant)
{
var independentValues =
SolutionDomainTypeOptionVM.IndependentVariableAxisOptionVM.UnSelectedValues.Length;
var positionIndex = 0;
for (var i = 0; i < independentValues; i++)
{
if (SolutionDomainTypeOptionVM.IndependentVariableAxisOptionVM.UnSelectedValues[i] == axis)
{
positionIndex = i;
}
}
switch (positionIndex)
{
default:
return(new[] { SolutionDomainTypeOptionVM.ConstantAxesVMs[0].AxisValue });
case 1:
return(new[] { SolutionDomainTypeOptionVM.ConstantAxesVMs[1].AxisValue });
}
}
else
{
var numAxes = SolutionDomainTypeOptionVM.IndependentVariableAxisOptionVM.SelectedValues.Length;
var positionIndex = 0;
for (var i = 0; i < numAxes; i++)
{
if (SolutionDomainTypeOptionVM.IndependentVariableAxisOptionVM.SelectedValues[i] == axis)
{
positionIndex = i;
}
}
switch (numAxes)
{
default:
return(AllRangeVMs[0].Values.ToArray());
case 2:
switch (positionIndex)
{
default:
return(AllRangeVMs[1].Values.ToArray());
case 1:
return(AllRangeVMs[0].Values.ToArray());
}
case 3:
switch (positionIndex)
{
default:
return(AllRangeVMs[2].Values.ToArray());
case 1:
return(AllRangeVMs[1].Values.ToArray());
case 2:
return(AllRangeVMs[0].Values.ToArray());
}
}
}
}
// this has commented out code that might come into play when we add wavelength as axis
internal double[] GetParameterValues(IndependentVariableAxis axis, string isConstant, double independentValue,
double[] xs)
{
if (((axis == IndependentVariableAxis.Rho) && (isConstant == "rho")) ||
((axis == IndependentVariableAxis.Time) && (isConstant == "t")) ||
((axis == IndependentVariableAxis.Fx) && (isConstant == "fx")) ||
((axis == IndependentVariableAxis.Ft) && (isConstant == "ft")))
{
return(new[] { independentValue });
}
return(xs.ToArray());
//else
//{
// if (axis != IndependentVariableAxis.Time)
// {
// return xs.ToArray();
// }
// else
// {
// return xs.ToArray();
// }
//}
//{
// var positionIndex = 0; //hard-coded for now
// switch (positionIndex)
// {
// case 0:
// default:
// return new[] {independentValue};
//case 1:
//return new[] { SolutionDomainTypeOptionVM.ConstantAxesVMs[1].AxisValue };
//case 2:
// return new[] { SolutionDomainTypeOptionVM.ConstantAxisThreeValue };
//}
//}
//else
//{
// //var numAxes = axis.Count();
// var numAxes = 1;
// var positionIndex = 0; //hard-coded for now
// //var positionIndex = SolutionDomainTypeOptionVM.IndependentVariableAxisOptionVM.SelectedValues.IndexOf(axis);
// switch (numAxes)
// {
// case 1:
// default:
// //return AllRangeVMs[0].Values.ToArray();
// return xs.ToArray();
//case 2:
// switch (positionIndex)
// {
// case 0:
// default:
// return AllRangeVMs[1].Values.ToArray();
// case 1:
// return AllRangeVMs[0].Values.ToArray();
// }
//case 3:
// switch (positionIndex)
// {
// case 0:
// default:
// return AllRangeVMs[2].Values.ToArray();
// case 1:
// return AllRangeVMs[1].Values.ToArray();
// case 2:
// return AllRangeVMs[0].Values.ToArray();
// }
//}
//}
}
