Exemple #1
0
 private void CalcOverlappingZones(LTETransceiverEX tranInfo, CellEx targetCell, CellCasePara casePara)
 {
         //double[] numArray = LTETools.GetCombinedLinkLoss(this.m_LinkLossCal, tranInfo, casePara, targetCell);
         //this.m_LinkLoss = numArray[1];
         if (this.m_LinkLoss != double.MaxValue)
         {
             double rsReceivePower = this.m_CellRSPower - this.m_LinkLoss;
             if ((rsReceivePower >= this.m_RsRxSensitivity) && (rsReceivePower <= this.m_MaxSensitivity))
             {
                
                 //if (LTETools.IsSameFrequency(this.m_DataManager.GetLTECellExByID(this.m_BestServerCellID), targetCell))
                 if (LTETools.IsSameFrequency(this.m_DataManager.GetCellExByID(this.m_BestServerCellID), targetCell))
                 {
                     this.m_HandoverAreaGate = this.m_SameFreqHandoverAreaGate;
                 }
                 else
                 {
                     this.m_HandoverAreaGate = this.m_DiffFreqHandoverAreaGate;
                 }
                 if (Math.Abs((double) (rsReceivePower - this.m_BestServerRsrp)) <= this.m_HandoverAreaGate)
                 {
                     this.m_OverlappingCount++;
                 }
             }
         }
     
 }
Exemple #2
0
 public bool IsRunOK(int index, LTETransceiverEX cellInfo, CellCasePara cellCasePara)
 {
     if (!ValidateTeminal())
     {
         return true;
     }
     short tempLevel = this.m_UlRPUCCHLevel[index];
     double tempRecPower = ((float)tempLevel) / 100f;
     double receivePower = double.MinValue;
     LteCellEx lteCellEx = cellInfo.HighestPriorityCell as LteCellEx;
     if (lteCellEx != null)
     {
         double[] linkLossArray = LTETools.GetCombinedBackhaulLinkLoss(this.m_LinkLossCal, cellInfo, cellCasePara, lteCellEx);
         if (linkLossArray[0] == double.MaxValue)
         {
             return true;
         }
         receivePower = Math.Min(m_DeafaultPower + linkLossArray[1], m_PMaxPower) - UnitTrans.todB(12) - linkLossArray[0];
         //if (receivePower < this.m_RsRxSensitivity || receivePower > m_MaxSensitivity)
         //{
         //    return true;
         //}
         if (receivePower > tempRecPower)
         {
             this.m_UlRPUCCHLevel[index] = Convert.ToInt16((double)((receivePower ) * 100.0));
             this.m_ULLinkLoss[index] = Convert.ToInt32((double)(linkLossArray[0] * LteConst.TIMES_TO_BIG_INT));
             this.m_LTEBestServerID[index] = lteCellEx.LteCell.ID;
         }
     }
     return true;
 }
 public bool IsRunOK(int index, LTETransceiverEX cellInfoEx, CellCasePara cellCasePara)
 {
     m_BestCarrierID = m_LTEBestServerID[index];
     //m_BestCarrierID = this.m_BestServerCarrierID[index];
     if (this.m_BestCarrierID != this.m_InvalidateValue)
     {
         //this.m_BestCellEx = this.m_DataManager.GetCellExByID(this.m_BestCarrierID);
         this.m_BestCellEx = m_DataManager.GetCellExByID(m_BestCarrierID);
         this.m_Interference = (double)this.m_InterfereForRPDCCH[index];
         //m_Interference取到的是dB值,但是用的时候都是转换成线性值
         if (m_Interference == -2147483648.0)
         {
             m_Interference = 0.0;
         }
         else
         {
             m_Interference = UnitTrans.dBto((double)(this.m_Interference * LteConst.TIMES_TO_FLOAT));
         }
         CalInterference(cellInfoEx, cellCasePara);
         if (m_Interference > 0.0)
         {
             m_InterfereForRPDCCH[index] = Convert.ToInt32((double)(UnitTrans.todB(m_Interference) * LteConst.TIMES_TO_BIG_INT));
         }
     }
     return true;
 }
 public bool IsRunOK(int index, LTETransceiverEX tranInfo, CellCasePara cellCasePara)
 {
     //this.m_CellID = this.m_BestCellID[index];
     m_BestCarrierID = m_LTEBestServerID[index];
     if (this.m_BestCarrierID != this.m_InvalidCellID)
     {
         //this.m_BestServerCell = this.m_DataManager.GetCellExByID(this.m_CellID);
         this.m_BestServerCell = m_DataManager.GetCellExByID(m_BestCarrierID);
         this.m_Interference = (double)this.m_InterferenceForRPDSCH[index];
         if (this.m_Interference == this.m_InvalidInterference)
         {
             this.m_Interference = 0.0;
         }
         else
         {
             this.m_Interference = UnitTrans.dBto((double)(this.m_Interference * LteConst.TIMES_TO_FLOAT));
         }
         this.CalcInterference(tranInfo, cellCasePara);
         if (this.m_Interference > 0.0)
         {
             this.m_InterferenceForRPDSCH[index] = Convert.ToInt32((double)(UnitTrans.todB(this.m_Interference) * LteConst.TIMES_TO_BIG_INT));
         }
     }
     return true;
 }
Exemple #5
0
 public bool IsRunOK(int index, LTETransceiverEX cellInfo, CellCasePara cellCasePara)
 {
     if (!ValiteTeminal())
     {
         return true;
     }
     short tempLevel = this.m_DlRPDCCHLevel[index];
     double tempRecPower = ((float)tempLevel) / 100f;
     double receivePower = double.MinValue;
     LteCellEx lteCellEx = cellInfo.HighestPriorityCell as LteCellEx;
     if (lteCellEx != null)
     {
         double[] linkLoss = LTETools.GetCombinedBackhaulLinkLoss(this.m_LinkLossCal, cellInfo, cellCasePara, lteCellEx);
         if (linkLoss[1] == double.MaxValue)
         {
             return true;
         }
         receivePower = lteCellEx.LteCell.RSPower - linkLoss[1];
         if (receivePower < this.m_RsRxSensitivity||receivePower > this.m_MaxSensitivity)
         {
             return true;
         }
         if (receivePower > tempRecPower)
         {
             this.m_DlRPDCCHLevel[index] = Convert.ToInt16((double)((receivePower+lteCellEx.LteCell.RPDCCHPoffset) * 100.0));
             //this.m_ULLinkLoss[index] = Convert.ToInt32((double)(numArray[0] * LteConst.TIMES_TO_BIG_INT));
             this.m_LTEBestServerID[index] = lteCellEx.LteCell.ID;
         }
         
     }
     return true;
 }
 private void CalInterference(LTETransceiverEX tranInfoEx, CellCasePara casePara)
 {
     //List<LteCellEx> lteCellExList = tranInfoEx.LteCellExList;
     if (tranInfoEx.LteCellExList.Count > 0)
     {
         foreach (LteCellEx ex in tranInfoEx.LteCellExList)
         {
             if (ex.LteCell.ID == m_BestCarrierID)
             {
                 continue;
             }
             double[] numArray = LTETools.GetCombinedLinkLoss(this.m_LinkLossCal, tranInfoEx, casePara, ex);
             this.m_LinkLoss = numArray[1];
             CalcInterf(ex);
         }
     }
     else
     {
         if (tranInfoEx.RelayCellExList.Count > 0)
         {
             foreach (RelayCellEx relayCellEx in tranInfoEx.RelayCellExList)
             {
                 if (relayCellEx.RelayCell.ID == m_BestCarrierID)
                 {
                     continue;
                 }
                 double[] numArray = LTETools.GetCombinedRelayLinkLoss(this.m_LinkLossCal, tranInfoEx, casePara, relayCellEx);
                 m_LinkLoss = numArray[1];
                 GetTDDSubFrameMatrix(relayCellEx);
                 CalcInterf(relayCellEx);
             }
         }
     }
     #region 原代码
     //foreach (LteCellEx ex in tranInfoEx.LteCellExList)
     //{
     //    double[] numArray = LTETools.GetCombinedLinkLoss(this.m_LinkLossCal, tranInfoEx, casePara, ex);
     //    this.m_LinkLoss = numArray[1];
     //    if (this.m_LinkLoss != double.MaxValue)
     //    {
     //        this.m_LinkLoss = UnitTrans.dBto(this.m_LinkLoss);
     //        this.m_receivePowerTemp = (ex.PTotalForPDCCH / this.m_LinkLoss) / ex.PDCCHOverHeadRENum;
     //        if ((this.m_BestCarrierID != ex.LteCell.ID) && (this.m_receivePowerTemp >= this.m_InterfRecpThreshold))
     //        {
     //            if (LTETools.IsSameFrequency(this.m_BestCellEx, ex))
     //            {
     //                this.m_Interference += this.m_receivePowerTemp;
     //            }
     //            else if (LTETools.IsNeighbourFrequency(this.m_BestCellEx, ex))
     //            {
     //                this.m_Interference += this.m_receivePowerTemp / this.m_BestCellEx.ACIR;
     //            }
     //        }
     //    }
     //}
     #endregion
 }
Exemple #7
0
 public static double[] GetCombinedLinkLoss(ILTELinkLossCalculator linkLoss, LTETransceiverEX tranInfo, CellCasePara casePara, LteCellEx cellEx)
 {
     for (int i = 0; i < cellEx.AntConfigExList.Count; i++)
     {
         double[] linkLossArr = linkLoss.GetLinkLoss(cellEx.AntConfigExList[i].AntConfig, cellEx.LteCell, casePara.X, casePara.Y, casePara.ClutterID, casePara.BuildHeight, true, (float)casePara.Resolution);
         tranInfo.AntLinkLoss[i][0] = linkLossArr[0];
         tranInfo.AntLinkLoss[i][1] = linkLossArr[1];
     }
     return linkLoss.GetCombinedLinkLoss(tranInfo.RatioArr, tranInfo.AntLinkLoss);
 }
 public bool IsRunOK(int index, LTETransceiverEX tranInfoEx, CellCasePara casePara)
 {
     short carrierID = this.m_BestServerCellID[index];
     if (carrierID != -32768)
     {
         this.m_BestServer = this.m_DataManager.GetCellExByID(carrierID);
         this.m_Interference = (double)this.m_ShiftingInterfOfDLRSSinr[index];
         if (this.m_Interference == -2147483648.0)
         {
             this.m_Interference = 0.0;
         }
         else
         {
             this.m_Interference = UnitTrans.dBto((double)(this.m_Interference * LteConst.TIMES_TO_FLOAT));
         }
         foreach (LteCellEx ex2 in tranInfoEx.LteCellExList)
         {
             if (ex2.LteCell.ID == carrierID)
             {
                 continue;
             }
             double[] numArray = LTETools.GetCombinedLinkLoss(this.m_LinkLossCal, tranInfoEx, casePara, ex2);
             this.m_LinkLoss = numArray[1];
             if (this.m_LinkLoss != double.MaxValue)
             {
                 this.m_LinkLoss = UnitTrans.dBto(this.m_LinkLoss);
                 CalcInterference(ex2);
             }
         }
         foreach (RelayCellEx ex2 in tranInfoEx.RelayCellExList)
         {
             if (ex2.RelayCell.ID == carrierID)
             {
                 continue;
             }
             double[] numArray = LTETools.GetCombinedRelayLinkLoss(this.m_LinkLossCal, tranInfoEx, casePara, ex2);
             this.m_LinkLoss = numArray[1];
             if (this.m_LinkLoss != double.MaxValue)
             {
                 this.m_LinkLoss = UnitTrans.dBto(this.m_LinkLoss);
                 GetTDDSubFrameMatrix(ex2);
                 CalcInterference(ex2);
             }
         }
         if (this.m_Interference > 0.0)
         {
             this.m_ShiftingInterfOfDLRSSinr[index] = Convert.ToInt32((double)(UnitTrans.todB(this.m_Interference) * LteConst.TIMES_TO_BIG_INT));
         }
     }
     return true;
 } 
Exemple #9
0
 public bool IsRunOK(int index, LTETransceiverEX tranInfo, CellCasePara casePara)
 {
     this.m_BestServerCellID = this.m_BestServerCellIDMatrix[index];
     if (this.m_BestServerCellID != this.m_InvalidateValue)
     {
         this.m_BestServerRsrp = ((float) this.m_BestServerRSRPMatrix[index]) / 100f;
         this.m_OverlappingCount = this.m_OverlappingZones[index];
         if (this.m_OverlappingCount == -2147483648)
         {
             this.m_OverlappingCount = 1;
         }
         else
         {
             this.m_OverlappingCount /= 0x3e8;
         }
         if (tranInfo.LteCellExList.Count > 0)
         {
             foreach (LteCellEx ex in tranInfo.LteCellExList)
             {
                 double[] linkLossArr = LTETools.GetCombinedLinkLoss(this.m_LinkLossCal, tranInfo, casePara, ex);
                 this.m_LinkLoss = linkLossArr[1];
                 this.m_CellRSPower = ex.LteCell.RSPower;
                 if (ex.LteCell.ID != this.m_BestServerCellID)
                 {
                     this.CalcOverlappingZones(tranInfo, ex, casePara);
                 }
             }
         }
         else
         {
             if (tranInfo.RelayCellExList.Count > 0)
             {
                 foreach (RelayCellEx rex in tranInfo.RelayCellExList)
                 {
                     double[] linkLossArr = LTETools.GetCombinedRelayLinkLoss(this.m_LinkLossCal, tranInfo, casePara, rex);
                     this.m_LinkLoss = linkLossArr[1];
                     this.m_CellRSPower = rex.RelayCell.RSPower;
                     if (rex.RelayCell.ID != this.m_BestServerCellID)
                     {
                         this.CalcOverlappingZones(tranInfo, rex, casePara);
                     }
                 }
             }
         }
         this.m_OverlappingZones[index] = this.m_OverlappingCount * 0x3e8;
     }
     return true;
 }
Exemple #10
0
 public bool IsRunOK(int index, LTETransceiverEX tranInfo, CellCasePara casePara)
 {
     this.m_BestCarrierID = this.m_BestServerCarrierID[index];
     if (this.m_BestCarrierID != this.m_InvalidateValue)
     {
         m_BestServer = this.m_DataManager.GetCellExByID(this.m_BestCarrierID);
         m_Interference = (double)this.m_InterferenceForUL[index];
         if (m_Interference == -2147483648.0)
         {
             m_Interference = 0.0;
         }
         else
         {
             m_Interference = UnitTrans.dBto((double)(m_Interference * LteConst.TIMES_TO_FLOAT));
         }
         CalcInterference(tranInfo, casePara);
         if (m_Interference > 0.0)
         {
             this.m_InterferenceForUL[index] = Convert.ToInt32((double)(UnitTrans.todB(m_Interference) * LteConst.TIMES_TO_BIG_INT));
         }
     }
     return true;
 }
Exemple #11
0
        public bool IsRunOK(int index, LTETransceiverEX tranInfo, CellCasePara casePara)
        {
            short num = this.m_BestServerRSRP[index];
            double tempReceivePower = ((float)num) / 100f;
            short carrierID = this.m_BestServerCellID[index];
            CellEx cellEx=this.m_DataManager.GetCellExByID(carrierID);
            if (cellEx is RelayCellEx)
            {
               tempReceivePower = (tempReceivePower + ((RelayCellEx)cellEx).RelayCell.PowerBias);
            }
            //double lteReceivePower = double.MinValue;
            //double relayReceivePower = double.MinValue;
            double receivePower = double.MinValue;
            double uLLinkLoss = double.MaxValue;
            double dLLinkLoss = double.MaxValue;
            this.CalcInterference(index, tranInfo, casePara);
            LteCellEx lteCellEx = tranInfo.HighestPriorityCell as LteCellEx;
            RelayCellEx relayCellEx = tranInfo.HighestPriorityCell as RelayCellEx;
            if (lteCellEx != null)
            {

                double[] numArray = LTETools.GetCombinedLinkLoss(this.m_LinkLoss, tranInfo, casePara, lteCellEx);
                uLLinkLoss = numArray[0];
                dLLinkLoss = numArray[1];
                if (dLLinkLoss == double.MaxValue)
                {
                    return true;
                }
                receivePower = lteCellEx.LteCell.RSPower - dLLinkLoss;
                if (receivePower < this.m_RsRxSensitivity)
                {
                    return true;
                }
                if (receivePower > this.m_MaxSensitivity)
                {
                    setFalseValue(index);
                    return true;
                } 
                this.CalcReceivePower(index, lteCellEx, dLLinkLoss, uLLinkLoss, tempReceivePower, receivePower,tranInfo);
            }
            else
            {
                if (relayCellEx != null)
                {
                    //TODO::RelayCell计算
                    double[] numArray = LTETools.GetCombinedRelayLinkLoss(this.m_LinkLoss, tranInfo, casePara, relayCellEx);
                    uLLinkLoss = numArray[0];
                    dLLinkLoss = numArray[1];
                    if (dLLinkLoss == double.MaxValue)
                    {
                        return true;
                    }
                    receivePower = relayCellEx.RelayCell.RSPower + relayCellEx.RelayCell.PowerBias - dLLinkLoss;
                    if (receivePower < this.m_RsRxSensitivity)
                    {
                        return true;
                    }
                    if (receivePower > this.m_MaxSensitivity)
                    {
                        setFalseValue(index);
                        return true;
                    }
                    this.CalcReceivePower(index, relayCellEx, dLLinkLoss, uLLinkLoss, tempReceivePower, receivePower, tranInfo);
                }
            }
            //if (lteReceivePower >= relayReceivePower)
            //{
            //    receivePower = lteReceivePower;
            //    m_BestServer = (CellEx)lteCellEx;
            //}
            //else
            //{
            //    receivePower = relayReceivePower;
            //    m_BestServer = (CellEx)relayCellEx;
            //}     
            if (this.m_NeedPenetrationLoss)
            {
                this.m_PenetrationLoss[index] = UnitTrans.DoubleToShort(casePara.PenetrationLoss);
            }
            return true;
        }
Exemple #12
0
        /// <summary>
        /// 计算干扰
        /// </summary>
        /// <param name="tranInfo"></param>
        /// <param name="casePara"></param>
        private void CalcInterference(LTETransceiverEX tranInfo, CellCasePara casePara)
        {
            if (tranInfo.LteCellExList.Count > 0)
            {
                foreach (LteCellEx ltecellex in tranInfo.LteCellExList)
                {
                    double[] lteLinkLoss = LTETools.GetCombinedLinkLoss(this.m_LinkLossCal, tranInfo, casePara, ltecellex);
                    this.m_LinkLoss = lteLinkLoss[1];
                    if (this.m_LinkLoss != double.MaxValue)
                    {
                        this.m_LinkLoss = UnitTrans.dBto(this.m_LinkLoss);
                        if (m_BestServer is LteCellEx)
                        {
                            this.m_receivePowerTemp = ltecellex.DlActualPowerPerRE;
                        }
                        else
                        {
                            this.m_receivePowerTemp = ltecellex.DlActualPowerPerRE / this.m_LinkLoss;
                        }
                        if ((this.m_BestCarrierID != ltecellex.LteCell.ID) && (this.m_receivePowerTemp >= this.m_InterfRecpThreshold))
                        {
                            GetInterference(ltecellex);
                        }
                    }
                }

            }
            if (tranInfo.RelayCellExList.Count > 0)
            {
                foreach (RelayCellEx relayCellEx in tranInfo.RelayCellExList)
                {
                    double[] relayLinkLoss = LTETools.GetCombinedRelayLinkLoss(this.m_LinkLossCal, tranInfo, casePara, relayCellEx);
                    this.m_LinkLoss = relayLinkLoss[1];
                    if (this.m_LinkLoss != double.MaxValue)
                    {
                        this.m_LinkLoss = UnitTrans.dBto(this.m_LinkLoss);
                        if (m_BestServer is RelayCellEx)
                        {
                            this.m_receivePowerTemp = relayCellEx.DlActualPowerPerRE;
                        }
                        else
                        {
                            this.m_receivePowerTemp = relayCellEx.DlActualPowerPerRE / this.m_LinkLoss;
                        }
                        if ((this.m_BestCarrierID != relayCellEx.RelayCell.ID) && (this.m_receivePowerTemp >= this.m_InterfRecpThreshold))
                        {
                            GetInterference(relayCellEx);
                        }
                    }
                }
            }
        }
        private void CalInterference(LTETransceiverEX cellInfoEx, CellCasePara cellCasePara)
        {
            foreach (LteCellEx cellex in cellInfoEx.LteCellExList)
            {
                //计算同频段普通帧的PDSCH会对RPDCCH产生的干扰
                if (cellex.LteCell.ID == this.m_BestCarrierID)
                {
                    continue;
                }
                double[] numArray = LTETools.GetCombinedBackhaulLinkLoss(this.m_LinkLossCal, cellInfoEx, cellCasePara, cellex);
                this.m_LinkLoss = numArray[1];
                if (this.m_LinkLoss != double.MaxValue)
                {
                    m_LinkLoss = UnitTrans.dBto(m_LinkLoss);
                    double reNum = cellex.RSRENumOfPDSCH + cellex.TypeADataRENum + cellex.TypeBDataRENum;
                    double receiverPowerTemp = (cellex.PTotalForPDSCH / this.m_LinkLoss) / reNum;
                    double receiverPowerTempDLActualRe = cellex.DlActualPowerPerRE / m_LinkLoss;
                    if (LTETools.IsSameFrequency(m_BestCellEx, cellex) && (receiverPowerTemp >= m_InterfRecpThreshold))
                    {
                        m_Interference += receiverPowerTemp;
                    }
                    else if (LTETools.IsNeighbourFrequency(m_BestCellEx, cellex) && (receiverPowerTempDLActualRe >= m_InterfRecpThreshold))
                    {
                        m_Interference += receiverPowerTempDLActualRe / m_BestCellEx.ACIR;
                    }
                    else if (LTETools.IsCrossFrequency(this.m_BestCellEx, cellex))
                    {
                        double coPercent = this.GetCoInterfPercent(this.m_BestCellEx, cellex);
                        double adPercent = this.GetAdjacentInterfPercent(this.m_BestCellEx, cellex);
                        this.m_Interference += coPercent * receiverPowerTemp + adPercent * (receiverPowerTempDLActualRe / m_BestCellEx.ACIR);
                    }

                }
            }
        }
Exemple #14
0
        /// <summary>
        /// 判断小区是否是LTE频带内
        /// </summary>
        /// <param name="tranInfo"></param>
        /// <returns></returns>
        private bool ValidateTranByFrequencyBand(LTETransceiverEX tranInfo)
        {
            bool flag = false;
            int cellPriority = int.MaxValue;
            if (tranInfo.LteCellExList.Count > 0)
            {
                LteCellEx ex = null;
                LTECell lteCell = null;
                foreach (LteCellEx ex2 in tranInfo.LteCellExList)
                {
                    lteCell = ex2.LteCell;
                    bool flag2 = this.m_Group.FreqBandIdList.Contains(lteCell.FreqBand.ID) && this.m_Group.ChannelIndexDic[lteCell.FreqBand.ID].Contains(lteCell.ChannelIndex);
                    if (flag2 && (lteCell.CellPriority < cellPriority))
                    {
                        cellPriority = lteCell.CellPriority;
                        ex = ex2;
                    }
                    flag |= flag2;
                }
                tranInfo.HighestPriorityCell = ex;
            }
            else if (tranInfo.RelayCellExList.Count > 0)
            {
                RelayCellEx rex = null;
                RelayCell relayCell = null;
                foreach (RelayCellEx ex2 in tranInfo.RelayCellExList)
                {
                    relayCell = ex2.RelayCell;
                    bool flag2 = this.m_Group.FreqBandIdList.Contains(relayCell.FreqBand.ID) && this.m_Group.ChannelIndexDic[relayCell.FreqBand.ID].Contains(relayCell.ChannelIndex);
                    if (flag2 && (relayCell.RCellPriority < cellPriority))
                    {
                        cellPriority = relayCell.RCellPriority;
                        rex = ex2;
                    }
                    flag |= flag2;
                }
                tranInfo.HighestPriorityCell = rex;
            }

            return flag;
        }
Exemple #15
0
 private void LteCellInit(LTETransceiverExCollection transColl, bool flag, bool flag2, float uLBLER, float dLBLER, LTETransceiverEX rex)
 {
     foreach (LteCellEx ex in rex.LteCellExList)
     {
         LteFrequencyBandEx lteFreqBandEx = ex.LteFreqBandEx;
         LTECell lteCell = ex.LteCell;
         lteFreqBandEx.FrequcyBandUsableWidth = UnitTrans.todB((int)(lteFreqBandEx.LteFrequencyBand.RBNum * 0x2bf20));
         //RSNumOfBandWidth?RENumOfBandWidth?
         lteFreqBandEx.RSNumOfBandWidth = UnitTrans.todB((int)(lteFreqBandEx.LteFrequencyBand.RBNum * 2));
         lteFreqBandEx.RENumOfBandWidth = UnitTrans.todB((int)(lteFreqBandEx.LteFrequencyBand.RBNum * 12));
         lteFreqBandEx.NoisePowerOfBandWidth = this.GetNoisePower(lteFreqBandEx.LteFrequencyBand);
         ex.NoiseULRE = this.GetRENoisePower(ex.NoiseFigureOfBts);
         ex.SpaceBetweenDlAndUL = this.m_IPLCalcVstr.GetDeltaLossFrmDLToUL(rex.Transceiver, lteCell)[0];
         ex.BandWidthAndStartFrequecyKey = lteCell.FreqBand.BandWidth + "_" + ((lteCell.FreqBand.BandWidth * lteCell.ChannelIndex) + lteCell.FreqBand.DLFrequency);
         ex.NeighbourBandWidth_Larger_Key = lteCell.FreqBand.BandWidth + "_" + ((lteCell.FreqBand.BandWidth * (lteCell.ChannelIndex + 1)) + lteCell.FreqBand.DLFrequency);
         ex.NeighbourBandWidth_Smaller_Key = lteCell.FreqBand.BandWidth + "_" + ((lteCell.FreqBand.BandWidth * (lteCell.ChannelIndex - 1)) + lteCell.FreqBand.DLFrequency);
         ex.DLFrequency = (lteCell.FreqBand.BandWidth * lteCell.ChannelIndex) + lteCell.FreqBand.DLFrequency;
         ex.DLBandWidth = lteCell.FreqBand.BandWidth;
         ex.TerminalNoisePower = UnitTrans.dBto((double)(lteFreqBandEx.NoisePowerOfBandWidth + this.m_Group.TrafficTerminal.NetTerminalList[0].NoiseFigure));
         ex.PDCCHOverHeadRENum = (lteCell.FreqBand.RBNum * 12) * lteCell.LteAlgParameter.DlPdcchSymbols;
         ex.RENumOfBandWidth = lteFreqBandEx.LteFrequencyBand.RBNum * 12;
         ex.ACIR = UnitTrans.dBto((double)lteFreqBandEx.LteFrequencyBand.ACIR);
         ex.FrequencyShift = AdvancedSettingTable.GetFrequencyShift(ex);
         /*固定为6个*/
         ex.RSRENumOfPDSCH = AdvancedSettingTable.GetRSREInPDSCH();
         ex.TypeADataRENum = AdvancedSettingTable.GetTypeADataReNumSimplify(ex);
         ex.TypeBDataRENum = AdvancedSettingTable.GetTypeBDataReNumSimplify(ex);
         ex.TypeADataRENumByComplicate = AdvancedSettingTable.GetTypeADataReNumComplicated(ex);
         ex.TypeBDataRENumByComplicate = AdvancedSettingTable.GetTypeBDataReNumComplicated(ex);
         ex.PDSCHTotalPower = AdvancedSettingTable.GetPDSCHTotalPower(ex, ex.TypeADataRENum, ex.TypeBDataRENum);
         ex.PDSCHREPower = ex.PDSCHTotalPower / (ex.TypeADataRENum + ex.TypeBDataRENum);
         ex.PDSCHOffset = UnitTrans.todB(ex.PDSCHREPower) - ex.LteCell.RSPower;
         ex.DlRsREPower = UnitTrans.dBto((double)ex.LteCell.RSPower);
         ex.DlActualPowerPerRE = UnitTrans.dBto((double)ex.LteCell.DlActualTxPower) / ((double)ex.RENumOfBandWidth);
         ex.SCHREPower = AdvancedSettingTable.GetSchRePower(ex);
         ex.PBCHREPower = AdvancedSettingTable.GetPbchRePower(ex);
         ex.IRCFigure = Huawei.UNet.Application.Common.IRC.IRC.GetIRCFigure(ex.LteCell.Parent.RxNumber);
         //TODO::新添的backhaul链路指标的功率属性未赋值
         ex.RTypeADataRENum = AdvancedSettingTable.GetRTypeADataReNumSimplify(ex);
         ex.RTypeADataRENumByComplicate = AdvancedSettingTable.GetRTypeADataReNumComplicated(ex);
         ex.RTypeBDataRENum = AdvancedSettingTable.GetRTypeBDataReNumSimplify(ex);
         ex.RTypeBDataRENumByComplicate = AdvancedSettingTable.GetRTypeBDataReNumComplicated(ex);
         ex.RPDSCHTotalPower = AdvancedSettingTable.GetPDSCHTotalPower(ex, ex.RTypeADataRENum, ex.RTypeBDataRENum);
         ex.RPDSCHREPower = ex.RPDSCHTotalPower / (ex.RTypeADataRENum + ex.RTypeBDataRENum);
         ex.RPDSCHOffset = UnitTrans.todB(ex.RPDSCHREPower) - ex.LteCell.RSPower;
         this.SetPTotal(ex);
         if (flag2 || flag)
         {
             this.m_ITrafficMCS.InitialMcsArr();
         }
         if (flag)
         {
             this.GetULMimo(ex);
             this.GetULDemodulationTable(ex, uLBLER);
         }
         if (flag2)
         {
             this.GetDLMimo(ex);
             this.GetDLDemodulationTable(ex, dLBLER);
         }
         transColl.AddCellEx(lteCell.ID, ex);
     }
 }
Exemple #16
0
 private void GetOneTransInfo(float resolution, ref LTETransceiverExCollection transceiverColl, Transceiver trans)
 {
     List<AntConfigEx> antExList = new List<AntConfigEx>();
     foreach (IACell cell in trans.Cells)
     {
         float maxCalcRadius = this.GetMaxCalcRadius(cell);
         foreach (AntConfig config in trans.AntConfiguration)
         {
             this.m_AntPoint.X = trans.Parent.X + config.DX;
             this.m_AntPoint.Y = trans.Parent.Y + config.DY;
             this.m_AntLeftTop.X = this.m_AntPoint.X - maxCalcRadius;
             this.m_AntLeftTop.Y = this.m_AntPoint.Y + maxCalcRadius;
             this.m_AntRightBottom.X = this.m_AntPoint.X + maxCalcRadius;
             this.m_AntRightBottom.Y = this.m_AntPoint.Y - maxCalcRadius;
             if (!(!this.IsAntInCalcZone() || this.IsExistAntEx(config.AntennaID, antExList)))
             {
                 antExList.Add(this.GetIndexCoodinateOfAnt(config, resolution));
             }
         }
     }
     if (antExList.Count > 0)
     {
         LTETransceiverEX item = new LTETransceiverEX(trans, antExList);
         transceiverColl.LTETransceiverEXList.Add(item);
     }
 }
Exemple #17
0
 private void CalcReceivePower(int index, CellEx cellEx, double DLLinkLoss, double ULLinkLoss, double tempReceivePower, double receivePower,LTETransceiverEX tranInfo)
 {
       if ((receivePower > tempReceivePower) && (receivePower > this.m_RsRxSensitivity))
      {
         this.m_BestServerRSRP[index] = Convert.ToInt16((double) (receivePower * 100.0));
         if (cellEx is LteCellEx)
         {
             LteCellEx lteCellEx = (LteCellEx)cellEx;
             if (this.m_NeedCalSymbolRSRP || this.m_NeedCalRSRQ)
             {
                 this.m_RsMaxCarrierFrequecyBandEx = lteCellEx.LteFreqBandEx;
                 /*m_RsMaxCarrierFrequecyBandEx.RSNumOfBandWidth是dB值,对应100*2个RS(一个OFDM符号内)*/
                 this.m_SymbolRSRP[index] = Convert.ToInt16((double)((receivePower + this.m_RsMaxCarrierFrequecyBandEx.RSNumOfBandWidth) * 100.0));
             }
             this.m_BestServerCellID[index] = lteCellEx.LteCell.ID;
             this.m_BestServerTransID[index] = tranInfo.Transceiver.ID;
         }
         else 
         {
             if (cellEx is RelayCellEx)
             {
                 RelayCellEx relayCellEx = (RelayCellEx)cellEx;
                 if (this.m_NeedCalSymbolRSRP || this.m_NeedCalRSRQ)
                 {
                     this.m_RsMaxCarrierFrequecyBandEx = relayCellEx.RelayFreqBandEx;
                     /*m_RsMaxCarrierFrequecyBandEx.RSNumOfBandWidth是dB值,对应100*2个RS(一个OFDM符号内)*/
                     this.m_SymbolRSRP[index] = Convert.ToInt16((double)((receivePower + this.m_RsMaxCarrierFrequecyBandEx.RSNumOfBandWidth) * 100.0));
                 }
                 this.m_BestServerCellID[index] = relayCellEx.RelayCell.ID;
                 this.m_BestServerTransID[index] = tranInfo.Transceiver.ID;
             }
         }
         //this.m_BestServerTransID[index] = cellInfo.Transceiver.ID;
         if (this.m_NeedCalActualRxIntf || this.m_NeedCalMaxRxIntf)
         {
             /*dBֵ*/
             this.m_DlBestServerLinkLoss[index] = Convert.ToInt32((double) (DLLinkLoss * LteConst.TIMES_TO_BIG_INT));
         }
         if (this.m_IsNeedCalULStudy)
         {
             this.m_UlBestServerLinkLoss[index] = Convert.ToInt32((double) (ULLinkLoss * LteConst.TIMES_TO_BIG_INT));
         }
     }
  }
Exemple #18
0
 private void CalcInterference(int index, LTETransceiverEX cellInfo, CellCasePara casePara)
 {
     if (this.m_NeedCalActualRxIntf || this.m_NeedCalMaxRxIntf)
     {
         this.m_RxPowerOfBandWidthKey = "";
         this.m_MaxRxPowerOfBandWidthKey = "";
         this.m_ActualRxPower = 0.0;
         this.m_MaxRxPower = 0.0;
         foreach (LteCellEx ex in cellInfo.LteCellExList)
         {
             LTECell lteCell = ex.LteCell;
             if (lteCell.Active)
             {
                 double[] linkLoss = LTETools.GetCombinedLinkLoss(this.m_LinkLoss, cellInfo, casePara, ex);
                 if (linkLoss[1] != double.MaxValue)
                 {
                     this.m_ActualRxPower = lteCell.DlActualTxPower - linkLoss[1];
                     this.m_MaxRxPower = lteCell.MaxPower - linkLoss[1];
                     double reNumOfBandWidth = ex.LteFreqBandEx.RENumOfBandWidth;
                     calActualRxIntf(index, ex, reNumOfBandWidth);
                 }
             }
         }
         foreach (RelayCellEx ex in cellInfo.RelayCellExList)
         {
             RelayCell relayCell = ex.RelayCell;
             if (relayCell.Active)
             {
                 double[] linkLoss = LTETools.GetCombinedRelayLinkLoss(this.m_LinkLoss, cellInfo, casePara, ex);
                 if (linkLoss[1] != double.MaxValue)
                 {
                     this.m_ActualRxPower = relayCell.DlActualTxPower - linkLoss[1];
                     this.m_MaxRxPower = relayCell.MaxPower - linkLoss[1];
                     double reNumOfBandWidth = ex.RelayFreqBandEx.RENumOfBandWidth;
                     calActualRxIntf(index, ex, reNumOfBandWidth); 
                 }
             }
         }
     }
 }
 /// <summary>
 /// 计算RPDSCH受到的干扰
 /// </summary>
 /// <param name="tranInfo"></param>
 /// <param name="casePara"></param>
 private void CalcInterference(LTETransceiverEX tranInfo, CellCasePara casePara)
 {
     foreach (LteCellEx cellex in tranInfo.LteCellExList)
     {
         if (cellex.LteCell.ID == this.m_BestCarrierID)
         {
             continue;
         }
         double[] numArray = LTETools.GetCombinedBackhaulLinkLoss(this.m_LinkLossCal, tranInfo, casePara, cellex);
         this.m_LinkLoss = numArray[1];
         if (this.m_LinkLoss != double.MaxValue)
         {
             this.m_LinkLoss = UnitTrans.dBto(this.m_LinkLoss);
             double reNum = cellex.RSRENumOfPDSCH + cellex.TypeADataRENum + cellex.TypeBDataRENum;
             this.m_InterfPower = (cellex.PTotalForPDSCH / this.m_LinkLoss) / reNum;//每个RE上的干扰功率
             this.m_receivePowerTempDLActualRE = cellex.DlActualPowerPerRE / this.m_LinkLoss;
             //同频干扰
             if (LTETools.IsSameFrequency(this.m_BestServerCell, cellex) && (this.m_InterfPower >= this.m_InterfRecpThreshold))
             {
                 this.m_Interference += this.m_InterfPower;
             }
             //邻频干扰
             else if (LTETools.IsNeighbourFrequency(this.m_BestServerCell, cellex) && (this.m_receivePowerTempDLActualRE >= this.m_InterfRecpThreshold))
             {
                 this.m_Interference += this.m_receivePowerTempDLActualRE / this.m_BestServerCell.ACIR;
             }
             else if (LTETools.IsCrossFrequency(this.m_BestServerCell, cellex))
             {
                 double coPercent = this.GetCoInterfPercent(this.m_BestServerCell, cellex);
                 double adPercent = this.GetAdjacentInterfPercent(this.m_BestServerCell, cellex);
                 this.m_Interference += coPercent * m_InterfPower + adPercent * (this.m_receivePowerTempDLActualRE / this.m_BestServerCell.ACIR);
             }
         }
     }
 }
Exemple #20
0
 /// <summary>
 /// 获取relayTrans信息
 /// </summary>
 /// <param name="resolution"></param>
 /// <param name="transceiverColl"></param>
 /// <param name="rn"></param>
 private void GetOneRelayTransInfo(ref List<Transceiver> allTran,float resolution, ref LTETransceiverExCollection transceiverColl, RelayNode rn,short id)
 {
     //
     if (this.m_GeoInfo.GetValueByGeoXYPoint(rn.X, rn.Y, DemDataType.Height) > -32768)
     {
         List<AntConfigEx> antExList = new List<AntConfigEx>();
         bool flag=false;
         foreach (IACell cell in rn.RCList)
         {
             float maxCalcRadius = this.GetMaxCalcRadius(cell);
             RelayCell relayCell = (RelayCell)cell;
             flag |= !float.IsNegativeInfinity(relayCell.DlActualTxPower);
             if (relayCell.Active & flag)
             {
                 this.m_AntPoint.X = rn.X + relayCell.CellToUEAnt.DX;
                 this.m_AntPoint.Y = rn.Y + relayCell.CellToUEAnt.DY;
                 this.m_AntLeftTop.X = this.m_AntPoint.X - maxCalcRadius;
                 this.m_AntLeftTop.Y = this.m_AntPoint.Y + maxCalcRadius;
                 this.m_AntRightBottom.X = this.m_AntPoint.X + maxCalcRadius;
                 this.m_AntRightBottom.Y = this.m_AntPoint.Y - maxCalcRadius;
                 if (!(!this.IsAntInCalcZone() || this.IsExistAntEx(relayCell.CellToUEAnt.AntennaID, antExList)))
                 {
                     antExList.Add(this.GetIndexCoodinateOfAnt(relayCell.CellToUEAnt, resolution));
                 }
             }
             
         }
         if (antExList.Count > 0)
         {
             Transceiver tran = new Transceiver();
             tran.ID = id;
             tran.Name = rn.Name;
             allTran.Add(tran);
             LTETransceiverEX item = new LTETransceiverEX(rn, antExList, tran);
             transceiverColl.LTETransceiverEXList.Add(item);
         }
     }
 }