示例#1
0
        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);
        }
示例#2
0
        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);
        }