private static Complex[,] CalculateA(OmegaModel model, AuxContainer c)
{
var result = new Complex[c.P.Length, c.P.Length];
int s = System.Math.Max(c.CorrBackgroundRc, c.CorrBackgroundTr);
int r = System.Math.Min(c.CorrBackgroundRc, c.CorrBackgroundTr);
for (int n = s; n >= r; n--)
{
Complex prevA = 1.0 / (c.Eta[n] * (1 - c.P[n] * c.Q[n] * c.Exp[n]));
result[n, n] = prevA;
for (int k = n - 1; k >= r; k--)
{
var dk1 = (double)model.GetLayerDepth(k + 1);
var q = ((1 + c.P[k + 1]) / (1 + c.P[k] * c.Exp[k])) *
Complex.Exp((c.Eta[k + 1] - c.Eta[k]) * dk1);
Complex nextA = q * prevA;
result[k, n] = nextA;
result[n, k] = nextA;
prevA = nextA;
}
}
return(result);
}
public InnerResult CalculateForH(Transmitter transmitter, Receiver receiver)
{
var c = AuxContainer.CreateContainer(_model, transmitter, receiver);
var uCalculator = GetCalculatorU(_model, c);
var result = CalculateForH(c, uCalculator);
return(result);
}
public static AuxContainer CreateContainer(OmegaModel model, Transmitter tr, Receiver rc)
{
var corrBackgroundTr = model.DetermineCorrespondingBackgroundLayer(tr.GetWorkingDepth());
var corrBackgroundRc = model.DetermineCorrespondingBackgroundLayer(rc.GetWorkingDepth());
var c = new AuxContainer(tr, rc, corrBackgroundTr, corrBackgroundRc);
return(c);
}
private Z GetZ(AuxContainer c)
{
return(new Z
{
s1 = (double)c.Tr.StartingDepth,
s2 = (double)c.Tr.GetEndDepth(),
r1 = (double)c.Rc.StartingDepth,
r2 = (double)c.Rc.GetEndDepth()
});
}
private InnerResult CalculateForE(AuxContainer c, ICalculatorU u)
{
var e = InitResultE(_planItem);
var zeta = _model.Section1D.GetAllSection1DZeta();
var length = _planItem.Lambdas.Length;
for (int i = 0; i < length; i++)
{
var lambda = _planItem.Lambdas[i];
c.Eta = CalculateEta(_model, lambda);
c.Exp = CalculateExp(_model, c.Eta);
if (_planItem.CalculateI1)
{
c.P = CalculateP1(_alphaBeta, c.Eta, c.Exp);
c.Q = CalculateQ1(_alphaBeta, c.Eta, c.Exp);
c.A = CalculateA1(_model, c);
e.U1[i] = u.CalculateU1();
}
c.P = CalculatePSigma(zeta, c.Eta, c.Exp);
c.Q = CalculateQSigma(c.Eta, c.Exp);
c.A = CalculateASigma(_model, c);
if (_planItem.CalculateI2)
{
e.U2[i] = u.CalculateU2();
}
if (_planItem.CalculateI3)
{
e.U3[i] = u.CalculateU3();
}
if (_planItem.CalculateI4)
{
e.U4[i] = u.CalculateU4();
}
if (_planItem.CalculateI5)
{
e.U5[i] = u.CalculateU5(lambda);
}
}
var result = ScalarMathUtils.NormalizeAndPerformHankel(e, _planItem, _model, c.CorrBackgroundRc);
return(result);
}
private static Complex[,] CalculateASigma(OmegaModel model, AuxContainer c)
{
var a = CalculateA(model, c);
int s = System.Math.Max(c.CorrBackgroundRc, c.CorrBackgroundTr);
int r = System.Math.Min(c.CorrBackgroundRc, c.CorrBackgroundTr);
for (int n = s; n >= r; n--)
{
for (int k = n - 1; k >= r; k--)
{
var zetaRc = model.Section1D[k].Zeta;
var zetaTr = model.Section1D[n].Zeta;
a[n, k] = (zetaTr / zetaRc) * a[k, n];
}
}
return(a);
}
private InnerResult CalculateForH(AuxContainer c, ICalculatorU u)
{
var h = InitResultH(_planItem);
var zeta = _model.Section1D.GetAllSection1DZeta();
var length = _planItem.Lambdas.Length;
for (int i = 0; i < length; i++)
{
c.Eta = CalculateEta(_model, _planItem.Lambdas[i]);
c.Exp = CalculateExp(_model, c.Eta);
c.P = CalculateP1(_alphaBeta, c.Eta, c.Exp);
c.Q = CalculateQ1(_alphaBeta, c.Eta, c.Exp);
c.A = CalculateA1(_model, c);
if (_planItem.CalculateI4)
{
h.U11[i] = u.CalculateU1();
}
if (_planItem.CalculateI1)
{
h.U31[i] = u.CalculateU3();
}
c.P = CalculatePSigma(zeta, c.Eta, c.Exp);
c.Q = CalculateQSigma(c.Eta, c.Exp);
c.A = CalculateASigma(_model, c);
if (_planItem.CalculateI3)
{
h.U1Sigma[i] = u.CalculateU1();
}
if (_planItem.CalculateI2)
{
h.U4Sigma[i] = u.CalculateU4();
}
}
var result = ScalarMathUtils.NormalizeAndPerformHankel(h, _planItem);
return(result);
}
public VolumeToVolumeCalculatorU(OmegaModel model, AuxContainer container)
{
_model = model;
_container = container;
}
protected abstract ICalculatorU GetCalculatorU(OmegaModel model, AuxContainer c);
protected override ICalculatorU GetCalculatorU(OmegaModel model, AuxContainer c)
{
return(new VolumeToPointCalculatorU(model, c));
}
public static Complex[,] CalculateA1(OmegaModel model, AuxContainer c) => CalculateA(model, c);
