The Tie Up

Here we just need to the free space loss fs(db) + friis_correction(db). The friis_correction being the ITM calculation for path loss since we cannot have less path loss than the ideal free space.

            var friis_correction = avar(qerfi(timepct), qerfi(locpct), qerfi(confpct));
            dbloss = friis_correction + fs;      //avar(time,location,confidence)
            errnum = _kwx;
            //  Repeat with 100% confidence
            friis_100 = fs + avar(qerfi(0.99), qerfi(0.99), qerfi(0.99));

The Method avar to add statistics.

        double avar(double zzt, double zzl, double zzc)
        {
            //  if zzt, zzl, zzc do not change what changes avarv
            const Double rt = 7.8, rl = 24.0;
            Double sgt = 0.0;
            Double yr = 0.0;

            if (_lvar > Changes.None)
            {
                Double q;
                switch (_lvar)
                {
                    case Changes.All:
                        _cs = _climateSettings[_klim];
                        goto case Changes.VariabilityMode;
                    case Changes.VariabilityMode:
                        goto case Changes.Frequency;
                    case Changes.Frequency:
                        q = Math.Log(0.133 * _wn);
                        _gm = _cs.cfm1 + _cs.cfm2 / (Math.Pow(_cs.cfm3 * q, 2) + 1);
                        _gp = _cs.cfp1 + _cs.cfp2 / (Math.Pow(_cs.cfp3 * q, 2) + 1);
                        goto case Changes.AntennaHeight;
                    case Changes.AntennaHeight:
                        _dexa = Math.Sqrt(18000000 * Transmitter.he) + Math.Sqrt(18000000 * Receiver.he) + Math.Pow(575.7e12 / _wn, THIRD);
                        goto case Changes.Distance;
                    case Changes.Distance:
                        if (_dist < _dexa)
                            _de = 130000 * _dist / _dexa;
                        else
                            _de = 130000 + _dist - _dexa;
                        break;
                }
                _vmd = curve(_cs.cv1, _cs.cv2, _cs.yv1, _cs.yv2, _cs.yv3, _de);
                _sgtm = curve(_cs.csm1, _cs.csm2, _cs.ysm1, _cs.ysm2, _cs.ysm3, _de) * _gm;
                _sgtp = curve(_cs.csp1, _cs.csp2, _cs.ysp1, _cs.ysp2, _cs.ysp3, _de) * _gp;
                _sgtd = _sgtp * _cs.csd1;
                _tgtd = (_sgtp - _sgtd) * _cs.zd;
                if (_w1)
                    _sgl = 0;
                else
                {
                    q = (1 - 0.8 * Math.Exp(-_dist / 50000.0)) * _dh * _wn;
                    _sgl = 10 * q / (q + 13);
                }
                _vs0 = Math.Pow(5 + 3 * Math.Exp(-_de / 100000.0), 2);
                _lvar = Changes.None;
            }
            var zt = zzt;
            var zl = zzl;
            var zc = zzc;
            switch (_mdvar)
            {
                case VariabilityMode.Single:
                    zt = zc;
                    zl = zc;
                    break;
                case VariabilityMode.Individual:
                    zl = zc;
                    break;
                case VariabilityMode.Mobile:
                    zl = zt;
                    break;
            }
            if (Math.Abs(zt) > 3.1 || Math.Abs(zl) > 3.1 || Math.Abs(zc) > 3.1)
            {
                _kwx = Math.Max(_kwx, 1);
            }
            if (zt < 0)
                sgt = _sgtm;
            else if (zt <= _cs.zd)
                sgt = _sgtp;
            else
                sgt = _sgtd + _tgtd / zt;
            var vs = _vs0 + Math.Pow(sgt * zt, 2) / (rt + zc * zc) + Math.Pow(_sgl * zl, 2) / (rl + zc * zc);
            switch (_mdvar)
            {
                case VariabilityMode.Single:
                    yr = 0;
                    _sgc = Math.Sqrt(sgt * sgt + _sgl * _sgl + vs);
                    break;
                case VariabilityMode.Individual:
                    yr = sgt * zt;
                    _sgc = Math.Sqrt(_sgl * _sgl + vs);
                    break;
                case VariabilityMode.Mobile:
                    yr = Math.Sqrt(sgt * sgt + _sgl * _sgl) * zt;
                    _sgc = Math.Sqrt(vs);
                    break;
                default:
                    yr = sgt * zt + _sgl * zl;
                    _sgc = Math.Sqrt(vs);
                    break;
            }
//            _aref = 30;
            var avarv = _aref - _vmd - yr - _sgc * zc;
            if (avarv < 0)
                avarv = avarv * (29 - avarv) / (29 - 10 * avarv);
            return avarv;
        }

Where:

errnum = line of site, single edge diffraction, double edge diffration.