コード例 #1
0
ファイル: OverlappingZoneCase.cs プロジェクト: xiaoyj/Space
 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++;
                 }
             }
         }
     
 }
コード例 #2
0
 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;
 }
コード例 #3
0
 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;
 }
コード例 #4
0
ファイル: PRACH_SINRCase.cs プロジェクト: xiaoyj/Space
 public bool IsBuildOneBinOk(int index)
 {
     short carrierID = this.m_BestServerCarrierID[index];
     if ((carrierID != -32768) && (this.m_OneBinValueTemp.UL_RSRP != -32768))
     {
        m_bestServer = this.m_DataManager.GetCellExByID(carrierID);
        this.GetPrachSinr(index);
     }
     return true;
 } 
コード例 #5
0
 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;
 } 
コード例 #6
0
ファイル: PBCH_SINRCase.cs プロジェクト: xiaoyj/Space
 public bool IsBuildOneBinOk(int index)
 {
     this.m_BestCarrierID = this.m_BestServerCarrierID[index];
     if (this.m_BestCarrierID != this.m_InvalidateValue)
     {
         this.m_BestServer = this.m_DataManager.GetCellExByID(this.m_BestCarrierID);
         if (this.m_RsShifting)
         {
             this.m_PBCHLevel = ((float)this.m_OneBinValueTemp.DL_PBCH_RP) / 100f;
             this.m_PBCHLevel += this.m_OneBinValueTemp.m_ModelShadowMargin;
             this.m_Interference = (double)this.m_ShiftingInterfOfDLPBCHSinr[index];
             if (this.m_Interference != -2147483648.0)
             {
                 this.m_Interference *= LteConst.TIMES_TO_FLOAT;
                 this.m_Interference += this.m_OneBinValueTemp.m_ModelShadowMargin;
                 this.m_Interference = UnitTrans.todB((double)(UnitTrans.dBto(this.m_Interference) + (this.m_BestServer.TerminalNoisePower / ((double)this.m_BestServer.RENumOfBandWidth))));
             }
             else
             {
                 this.m_Interference = UnitTrans.todB((double)(this.m_BestServer.TerminalNoisePower / ((double)this.m_BestServer.RENumOfBandWidth)));
             }
             this.m_OneBinValueTemp.PBCH_SINR = Convert.ToInt16((double)(((this.m_PBCHLevel - this.m_Interference) - this.m_OneBinValueTemp.m_C_i_nShadowMargin) * 100.0));
         }
         else
         {
             if (m_BestServer is LteCellEx)
             {
                 LteCellEx lteCellEx = (LteCellEx)m_BestServer;
                 LTECell lteCell = lteCellEx.LteCell;
                 this.m_OneBinValueTemp.PBCH_SINR = Convert.ToInt16((float)(((((float)this.m_OneBinValueTemp.DLRSSINR) / 100f) + lteCell.BCHPoffset) * 100f));
             }
             else
             {
                 if (m_BestServer is RelayCellEx)
                 {
                     RelayCellEx relayCellEx = (RelayCellEx)m_BestServer;
                     RelayCell relayCell = relayCellEx.RelayCell;
                     this.m_OneBinValueTemp.PBCH_SINR = Convert.ToInt16((float)(((((float)this.m_OneBinValueTemp.DLRSSINR) / 100f) + relayCell.BCHPoffset) * 100f));
                 }
             }
         }
     }
     return true;
 } 
コード例 #7
0
ファイル: InterferenceCaseForUL.cs プロジェクト: xiaoyj/Space
 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;
 }
コード例 #8
0
 private void CalcInterference(CellEx cellex)
 {
     if (cellex is LteCellEx)
     {
         if (LTETools.IsSameFrequency(m_BestServer, cellex))
         {
             this.m_receivePowerTempRSRE = cellex.DlRsREPower / this.m_LinkLoss;
             this.m_receivePowerTempPDSCHRE = cellex.PDSCHREPower / this.m_LinkLoss;
             if ((m_BestServer.FrequencyShift == cellex.FrequencyShift) && (this.m_receivePowerTempRSRE >= this.m_InterfRecpThreshold))
             {
                 /*如果邻小区RSRE的位置与本小区位于相同的位置,那么干扰本小区RS RE的是邻小区的RS RE*/
                 this.m_Interference += this.m_receivePowerTempRSRE;
             }
             else if (this.m_receivePowerTempPDSCHRE >= this.m_InterfRecpThreshold)
             {
                 /*如果邻小区RSRE的位置与本小区位于不同的位置,那么干扰本小区RS RE的是邻小区的PDSCH RE*/
                 this.m_Interference += this.m_receivePowerTempPDSCHRE;
             }
         }
         else if (LTETools.IsNeighbourFrequency(m_BestServer, cellex))
         {
             this.m_receivePowerTempDLActualRE = cellex.DlActualPowerPerRE / this.m_LinkLoss;
             if (this.m_receivePowerTempDLActualRE >= this.m_InterfRecpThreshold)
             {
                 this.m_Interference += this.m_receivePowerTempDLActualRE / m_BestServer.ACIR;
             }
         }
         else if (LTETools.IsCrossFrequency(this.m_BestServer, cellex))
         {
             double coPercent = this.GetCoInterfPercent(this.m_BestServer, cellex);
             double adPercent = this.GetAdjacentInterfPercent(this.m_BestServer, cellex);
             if ((this.m_BestServer.FrequencyShift == cellex.FrequencyShift) && (this.m_receivePowerTempRSRE >= this.m_InterfRecpThreshold))
             {
                 /*如果最佳服务小区的RS位置与干扰邻小区的位置相同,那么干扰最佳服务区PBCH RE的是邻小区的PBCH RE*/
                 this.m_Interference += coPercent * this.m_receivePowerTempRSRE + adPercent * (this.m_receivePowerTempDLActualRE / this.m_BestServer.ACIR);
             }
             else if (this.m_receivePowerTempPDSCHRE >= this.m_InterfRecpThreshold)
             {
                 /*如果最佳服务小区的RS位置与干扰邻小区的位置不相同,那么干扰最佳服务区PBCH RE的是邻小区的RS RE*/
                 this.m_Interference += coPercent * this.m_receivePowerTempPDSCHRE + adPercent * (this.m_receivePowerTempDLActualRE / this.m_BestServer.ACIR);
             }    
         }
     }
     else 
     {
         if (cellex is RelayCellEx)
         {
             if (m_isFdd)
             {
                 RelayCellEx relayCellEx = (RelayCellEx)cellex;
                 int RBNum = relayCellEx.RelayCell.ParentRN.RbNum;
                 if (LTETools.IsSameFrequency(m_BestServer, cellex))
                 {
                     this.m_receivePowerTempRSRE = cellex.DlRsREPower / this.m_LinkLoss;
                     this.m_receivePowerTempPDSCHRE = cellex.PDSCHREPower / this.m_LinkLoss;
                     if ((m_BestServer.FrequencyShift == cellex.FrequencyShift) && (this.m_receivePowerTempRSRE >= this.m_InterfRecpThreshold))
                     {
                         /*如果邻小区RSRE的位置与本小区位于相同的位置,那么干扰本小区RS RE的是邻小区的RS RE*/
                         this.m_Interference += 7 / 8 * this.m_receivePowerTempRSRE;
                     }
                     else if (this.m_receivePowerTempPDSCHRE >= this.m_InterfRecpThreshold)
                     {
                         /*如果邻小区RSRE的位置与本小区位于不同的位置,那么干扰本小区RS RE的是邻小区的PDSCH RE*/
                         this.m_Interference += 7 / 8 * this.m_receivePowerTempPDSCHRE;
                     }
                 }
                 else if (LTETools.IsNeighbourFrequency(m_BestServer, cellex))
                 {
                     this.m_receivePowerTempDLActualRE = cellex.DlActualPowerPerRE / this.m_LinkLoss;
                     if (this.m_receivePowerTempDLActualRE >= this.m_InterfRecpThreshold)
                     {
                         this.m_Interference += 7 / 8 * this.m_receivePowerTempDLActualRE / m_BestServer.ACIR;
                     }
                 }
                 else if (LTETools.IsCrossFrequency(this.m_BestServer, cellex))
                 {
                     double coPercent = this.GetCoInterfPercent(this.m_BestServer, cellex);
                     double adPercent = this.GetAdjacentInterfPercent(this.m_BestServer, cellex);
                     if ((this.m_BestServer.FrequencyShift == cellex.FrequencyShift) && (this.m_receivePowerTempRSRE >= this.m_InterfRecpThreshold))
                     {
                         /*如果最佳服务小区的RS位置与干扰邻小区的位置相同,那么干扰最佳服务区PBCH RE的是邻小区的PBCH RE*/
                         this.m_Interference += 7 / 8 * coPercent * this.m_receivePowerTempRSRE + 7 / 8 * adPercent * (this.m_receivePowerTempDLActualRE / this.m_BestServer.ACIR);
                     }
                     else if (this.m_receivePowerTempPDSCHRE >= this.m_InterfRecpThreshold)
                     {
                         /*如果最佳服务小区的RS位置与干扰邻小区的位置不相同,那么干扰最佳服务区PBCH RE的是邻小区的RS RE*/
                         this.m_Interference += 7 / 8 * coPercent * this.m_receivePowerTempPDSCHRE + 7 / 8 * adPercent * (this.m_receivePowerTempDLActualRE / this.m_BestServer.ACIR);
                     }    
                 }
             }
             else 
             {
                 RelayCellEx relayCellEx = (RelayCellEx)cellex;
                 int RBNum = relayCellEx.RelayCell.ParentRN.RbNum;
                 if (LTETools.IsSameFrequency(m_BestServer, cellex))
                 {
                     this.m_receivePowerTempRSRE = cellex.DlRsREPower / this.m_LinkLoss;
                     this.m_receivePowerTempPDSCHRE = cellex.PDSCHREPower / this.m_LinkLoss;
                     if ((m_BestServer.FrequencyShift == cellex.FrequencyShift) && (this.m_receivePowerTempRSRE >= this.m_InterfRecpThreshold))
                     {
                         /*如果邻小区RSRE的位置与本小区位于相同的位置,那么干扰本小区RS RE的是邻小区的RS RE*/
                         this.m_Interference += m_a * this.m_receivePowerTempRSRE + m_b * m_MaxPower / (RBNum * 12);
                     }
                     else if (this.m_receivePowerTempPDSCHRE >= this.m_InterfRecpThreshold)
                     {
                         /*如果邻小区RSRE的位置与本小区位于不同的位置,那么干扰本小区RS RE的是邻小区的PDSCH RE*/
                         this.m_Interference += m_a * this.m_receivePowerTempPDSCHRE + m_b * m_MaxPower / (RBNum * 12);
                     }
                 }
                 else if (LTETools.IsNeighbourFrequency(m_BestServer, cellex))
                 {
                     this.m_receivePowerTempDLActualRE = cellex.DlActualPowerPerRE / this.m_LinkLoss;
                     if (this.m_receivePowerTempDLActualRE >= this.m_InterfRecpThreshold)
                     {
                         this.m_Interference += m_a * this.m_receivePowerTempDLActualRE / m_BestServer.ACIR + m_b * m_MaxPower / (RBNum * 12);
                     }
                 }
                 else if (LTETools.IsCrossFrequency(this.m_BestServer, cellex))
                 {
                     double coPercent = this.GetCoInterfPercent(this.m_BestServer, cellex);
                     double adPercent = this.GetAdjacentInterfPercent(this.m_BestServer, cellex);
                     if ((this.m_BestServer.FrequencyShift == cellex.FrequencyShift) && (this.m_receivePowerTempRSRE >= this.m_InterfRecpThreshold))
                     {
                         /*如果最佳服务小区的RS位置与干扰邻小区的位置相同,那么干扰最佳服务区PBCH RE的是邻小区的PBCH RE*/
                         this.m_Interference += coPercent * m_a * this.m_receivePowerTempRSRE + m_b * m_MaxPower / (RBNum * 12) + adPercent * (m_a * this.m_receivePowerTempDLActualRE / m_BestServer.ACIR + m_b * m_MaxPower / (RBNum * 12));
                     }
                     else if (this.m_receivePowerTempPDSCHRE >= this.m_InterfRecpThreshold)
                     {
                         /*如果最佳服务小区的RS位置与干扰邻小区的位置不相同,那么干扰最佳服务区PBCH RE的是邻小区的RS RE*/
                         this.m_Interference += coPercent * m_a * this.m_receivePowerTempPDSCHRE + m_b * m_MaxPower / (RBNum * 12) + adPercent * (m_a * this.m_receivePowerTempDLActualRE / m_BestServer.ACIR + m_b * m_MaxPower / (RBNum * 12));
                     }
                 }
             }
            
         }
     }
 }
コード例 #9
0
 /// <summary>
 /// 返回邻频干扰的比率
 /// </summary>
 /// <param name="sourceCell"></param>
 /// <param name="targetCell"></param>
 /// <returns></returns>
 private double GetAdjacentInterfPercent(CellEx sourceCell, CellEx targetCell)
 {
     double a = 0;
     if (sourceCell.DLFrequency >= targetCell.DLFrequency)
     {
         a = (Math.Min(targetCell.DLFrequency + targetCell.DLBandWidth, sourceCell.DLFrequency) - Math.Max(targetCell.DLFrequency, sourceCell.DLFrequency - sourceCell.DLBandWidth)) / sourceCell.DLBandWidth;
     }
     else
     {
         a = (Math.Min(targetCell.DLFrequency + targetCell.DLBandWidth, sourceCell.DLFrequency + 2 * sourceCell.DLBandWidth) - Math.Max(targetCell.DLFrequency, sourceCell.DLFrequency + sourceCell.DLBandWidth)) / sourceCell.DLBandWidth;
     }
     return a;
 }
コード例 #10
0
 /// <summary>
 /// 返回同频干扰的比率
 /// </summary>
 /// <param name="sourceCell"></param>
 /// <param name="targetCell"></param>
 /// <returns></returns>
 private double GetCoInterfPercent(CellEx sourceCell, CellEx targetCell)
 {
     double a = 0;
     a = (Math.Min(targetCell.DLFrequency + targetCell.DLBandWidth, sourceCell.DLFrequency + sourceCell.DLBandWidth) - Math.Max(targetCell.DLFrequency, sourceCell.DLFrequency)) / sourceCell.DLBandWidth;
     return a;
 }
コード例 #11
0
ファイル: RPUSCH_SINRCase.cs プロジェクト: xiaoyj/Space
 /// <summary>
 /// 主程序
 /// </summary>
 /// <param name="index"></param>
 /// <returns></returns>
 public bool IsBuildOneBinOk(int index)
 {
     this.m_BestCarrierID = this.m_BestServerCarrierID[index];
     if ((this.m_BestCarrierID != this.m_InvalidateValue) && (this.m_OneBinValueTemp.UL_RSRP != this.m_InvalidateValue))
     {
         if (!ValiteTeminal())
         {
             return true;
         }
         m_bestServer = m_DataManager.GetCellExByID(m_BestCarrierID);
         //RelayNode relayNode = this.m_DataManager.Group.TrafficTerminal.NetTerminalList[0] as RelayNode;
         LTETerminal terminal = this.m_DataManager.Group.TrafficTerminal.NetTerminalList[0] as LTETerminal;
         int rbNum = 0;
         double gain = 0.0;
         //if (m_bestServer is LteCellEx)
         //{
             LteCellEx lteCellEx = (LteCellEx)m_bestServer;
             if (lteCellEx.ULMIMO == null)
             {
                 return true;
             }
             LTECell lteCell = lteCellEx.LteCell;
             this.m_ulActualIoT = lteCell.UlActualIoT;
             this.m_FreqBand = lteCell.FreqBand;
             this.m_RSPower = lteCell.RSPower;
             this.m_ActualUlLoad = lteCell.ActualUlLoad;
             this.m_LteAlgParam = lteCell.LteAlgParameter;
             this.m_NoisePowerOfBandWidth = lteCellEx.LteFreqBandEx.NoisePowerOfBandWidth;
         //}
         //else
         //{
         //    if (m_bestServer is RelayCellEx)
         //    {
         //        RelayCellEx relayCellEx = (RelayCellEx)m_bestServer;
         //        RelayCell relayCell = relayCellEx.RelayCell;
         //        this.m_ulActualIoT = relayCell.UlActualIoT;
         //        this.m_FreqBand = relayCell.FreqBand;
         //        this.m_RSPower = relayCell.RSPower;
         //        this.m_ActualUlLoad = relayCell.ActualUlLoad;
         //        this.m_LteAlgParam = relayCell.RelayAlgParameter;
         //        this.m_NoisePowerOfBandWidth = relayCellEx.RelayFreqBandEx.NoisePowerOfBandWidth;
         //    }
         //}
         if ((this.m_IRCSwitch && (this.m_ulActualIoT >= 3.0)) && (this.m_ulActualIoT <= 15.0))
         {
             gain = Huawei.UNet.Application.Common.IRC.IRC.CalculateIRCGain(m_bestServer.IRCFigure, this.m_ulActualIoT);
         }
         this.GetHighSinrGate(m_bestServer.ULDemodulationTable, this.m_HighMCS, out this.m_AcutalHighMcsIndex, out this.m_AcutalHighSinrGate);
         this.m_HighMCSSinr = Convert.ToInt16((double)(this.m_AcutalHighSinrGate * 100.0));
         if (terminal.CanUseRBNum)
         {
             rbNum = terminal.RBNum;
             this.GetPushSinrByFixedRB(index, terminal, rbNum, gain);
         }
         else
         {
             /*lteCell.FreqBand.RBNum 为100,lteCell.FreqBand.RBNum 为16*/
             rbNum = Convert.ToInt32((float)(m_FreqBand.RBNum * m_ActualUlLoad)) - m_LteAlgParam.UlPucchRbs;
             this.GetPuschSinr(index, terminal, rbNum, m_ActualUlLoad, gain);
         }
     }
     return true;
 } 
コード例 #12
0
ファイル: InterferenceCaseForUL.cs プロジェクト: xiaoyj/Space
        /// <summary>
        /// 判断bestserver和干扰小区同频或邻频
        /// </summary>
        /// <param name="cellex"></param>
        private void GetInterference(CellEx cellex)
        {
            if (m_BestServer is RelayCellEx)
            {
                GetInterf(cellex);
            }
            else
            {
                if (m_BestServer is LteCellEx)
                {
                    LteCellEx lteCellExBestServer = (LteCellEx)m_BestServer;
                    if (cellex is LteCellEx)
                    {
                        LteCellEx lteCellEx = (LteCellEx)cellex;
                        //double antParamDB = 0;
                        if (LTETools.IsSameFrequency(this.m_BestServer, cellex))
                        {
                            this.m_Interference += this.m_receivePowerTemp; 
                            //this.m_Interference += this.m_receivePowerTemp / UnitTrans.dBto(antParamDB);
                        }
                        else if (LTETools.IsNeighbourFrequency(this.m_BestServer, cellex))
                        {
                            this.m_Interference += this.m_receivePowerTemp / this.m_BestServer.ACIR;
                            //this.m_Interference += this.m_receivePowerTemp / UnitTrans.dBto(antParamDB) / this.m_BestServer.ACIR;
                        }
                    }
                    else 
                    {
                        GetInterf(cellex);
                    }

                }
            }
        }
コード例 #13
0
ファイル: InterferenceCaseForUL.cs プロジェクト: xiaoyj/Space
 private void GetInterf(CellEx cellex)
 {
     if (LTETools.IsSameFrequency(this.m_BestServer, cellex))
     {
         this.m_Interference += this.m_receivePowerTemp;
     }
     else if (LTETools.IsNeighbourFrequency(this.m_BestServer, cellex))
     {
         this.m_Interference += this.m_receivePowerTemp / this.m_BestServer.ACIR;
     }
 }
コード例 #14
0
ファイル: SCH_SINRCase.cs プロジェクト: xiaoyj/Space
 public bool IsBuildOneBinOk(int index)
 {
     m_BestCarrierID = m_BestServerCarrierID[index];
     if (m_BestCarrierID != m_InvalidateValue)
     {
         m_BestCellEx = m_DataManager.GetCellExByID(m_BestCarrierID);
         //m_LteCellEx = (LteCellEx)m_BestCellEx;
         //m_RelayCellEx = (RelayCellEx)m_RelayCellEx;
         if (m_RsShifting)
         {
             m_SCHLevel = ((float)m_OneBinValueTemp.DL_SCH_RP) / 100f;
             m_SCHLevel += m_OneBinValueTemp.m_ModelShadowMargin;
             m_Interference = (double) m_ShiftingInterfOfDLSCHSinr[index];
             if ( m_Interference != -2147483648.0)
             {
                  m_Interference *= LteConst.TIMES_TO_FLOAT;
                  m_Interference +=  m_OneBinValueTemp.m_ModelShadowMargin;
                  m_Interference = UnitTrans.todB((double)(UnitTrans.dBto( m_Interference) + ( m_BestCellEx.TerminalNoisePower / ((double) m_BestCellEx.RENumOfBandWidth))));
             }
             else
             {
                  m_Interference = UnitTrans.todB((double)(m_BestCellEx.TerminalNoisePower / ((double) m_BestCellEx.RENumOfBandWidth)));
             }
              m_OneBinValueTemp.SCH_SINR = Convert.ToInt16((double)((( m_SCHLevel -  m_Interference) -  m_OneBinValueTemp.m_C_i_nShadowMargin) * 100.0));
         }
         else if (m_BestCellEx is LteCellEx)
         {
             m_LteCellEx = (LteCellEx)m_BestCellEx;
             m_OneBinValueTemp.SCH_SINR = Convert.ToInt16((float)(((((float)m_OneBinValueTemp.DLRSSINR) / 100f) + m_LteCellEx.LteCell.SCHPoffset) * 100f));
         }
         else
         {
             if (m_BestCellEx is RelayCellEx)
             {
                 m_RelayCellEx = (RelayCellEx)m_BestCellEx;
                 m_OneBinValueTemp.SCH_SINR = Convert.ToInt16((float)(((((float)m_OneBinValueTemp.DLRSSINR) / 100f) + m_RelayCellEx.RelayCell.SCHPoffset) * 100f));
             }
         }
     }
     #region 原代码
     //this.m_BestCarrierID = this.m_BestServerCarrierID[index];
     //if (this.m_BestCarrierID != this.m_InvalidateValue)
     //{
     //    this.m_BestCellEx = this.m_DataManager.GetLTECellExByID(this.m_BestCarrierID);
     //    if (this.m_RsShifting)
     //    {
     //        this.m_SCHLevel = ((float) this.m_OneBinValueTemp.DL_SCH_RP) / 100f;
     //        this.m_SCHLevel += this.m_OneBinValueTemp.m_ModelShadowMargin;
     //        this.m_Interference = (double) this.m_ShiftingInterfOfDLSCHSinr[index];
     //        if (this.m_Interference != -2147483648.0)
     //        {
     //            this.m_Interference *= LteConst.TIMES_TO_FLOAT;
     //            this.m_Interference += this.m_OneBinValueTemp.m_ModelShadowMargin;
     //            this.m_Interference = UnitTrans.todB((double) (UnitTrans.dBto(this.m_Interference) + (this.m_BestCellEx.TerminalNoisePower / ((double) this.m_BestCellEx.RENumOfBandWidth))));
     //        }
     //        else
     //        {
     //            this.m_Interference = UnitTrans.todB((double) (this.m_BestCellEx.TerminalNoisePower / ((double) this.m_BestCellEx.RENumOfBandWidth)));
     //        }
     //        this.m_OneBinValueTemp.SCH_SINR = Convert.ToInt16((double) (((this.m_SCHLevel - this.m_Interference) - this.m_OneBinValueTemp.m_C_i_nShadowMargin) * 100.0));
     //    }
     //    else
     //    {
     //        this.m_OneBinValueTemp.SCH_SINR = Convert.ToInt16((float) (((((float) this.m_OneBinValueTemp.DLRSSINR) / 100f) + this.m_BestCellEx.LteCell.SCHPoffset) * 100f));
     //    }
     //}
     #endregion
     return true;
 }
コード例 #15
0
        private void CalcInterf(CellEx cellex)
        {
            if (this.m_LinkLoss != double.MaxValue)
            {
                this.m_LinkLoss = UnitTrans.dBto(this.m_LinkLoss);
                this.m_receivePowerTemp = (cellex.PTotalForPDCCH / this.m_LinkLoss) / cellex.PDCCHOverHeadRENum;
                if (cellex is LteCellEx)
                {
                    if (LTETools.IsSameFrequency(this.m_BestServer, cellex))
                    {
                        this.m_Interference += this.m_receivePowerTemp;
                    }
                    else if (LTETools.IsNeighbourFrequency(this.m_BestServer, cellex))
                    {
                        this.m_Interference += this.m_receivePowerTemp / this.m_BestServer.ACIR;
                    }
                    else if (LTETools.IsCrossFrequency(this.m_BestServer, cellex))
                    {
                        double coPercent = this.GetCoInterfPercent(this.m_BestServer, cellex);
                        double adPercent = this.GetAdjacentInterfPercent(this.m_BestServer, cellex);
                        this.m_Interference += coPercent * this.m_receivePowerTemp + adPercent * (this.m_receivePowerTemp / this.m_BestServer.ACIR);
                    }

                }
                else
                {
                    if (cellex is RelayCellEx)
                    {
                        if (m_isFdd)
                        {
                            if (LTETools.IsSameFrequency(this.m_BestServer, cellex))
                            {
                                this.m_Interference += 7 / 8 * this.m_receivePowerTemp;
                            }
                            else if (LTETools.IsNeighbourFrequency(this.m_BestServer, cellex))
                            {
                                this.m_Interference += 7 / 8 * this.m_receivePowerTemp / this.m_BestServer.ACIR;
                            }
                            else if (LTETools.IsCrossFrequency(this.m_BestServer, cellex))
                            {
                                double coPercent = this.GetCoInterfPercent(this.m_BestServer, cellex);
                                double adPercent = this.GetAdjacentInterfPercent(this.m_BestServer, cellex);
                                this.m_Interference += 7 / 8 * coPercent * this.m_receivePowerTemp + adPercent * (7 / 8 * this.m_receivePowerTemp / this.m_BestServer.ACIR);
                            }
                        }
                        else
                        {
                            if (LTETools.IsSameFrequency(this.m_BestServer, cellex))
                            {
                                this.m_Interference += m_a * this.m_receivePowerTemp + m_b * m_MaxPower / (1 * 12);

                            }
                            else if (LTETools.IsNeighbourFrequency(this.m_BestServer, cellex))
                            {
                                this.m_Interference += m_a * this.m_receivePowerTemp / this.m_BestServer.ACIR + m_b * m_MaxPower / (1 * 12);
                            }
                            else if (LTETools.IsCrossFrequency(this.m_BestServer, cellex))
                            {
                                double coPercent = this.GetCoInterfPercent(this.m_BestServer, cellex);
                                double adPercent = this.GetAdjacentInterfPercent(this.m_BestServer, cellex);
                                this.m_Interference += coPercent * (m_a * this.m_receivePowerTemp + m_b * m_MaxPower / (1 * 12)) + adPercent * (m_a * this.m_receivePowerTemp / this.m_BestServer.ACIR + m_b * m_MaxPower / (1 * 12));
                            }
                        }
                    }
                }
            }
        }
コード例 #16
0
ファイル: LTETools.cs プロジェクト: xiaoyj/Space
 public static bool IsCrossFrequency(CellEx sourceCell, CellEx targetCell)
 {
     return ((Math.Min((sourceCell.DLFrequency + sourceCell.DLBandWidth), (targetCell.DLFrequency + targetCell.DLBandWidth)) - Math.Max(sourceCell.DLFrequency, targetCell.DLFrequency)) > 0 && !((sourceCell.DLFrequency == targetCell.DLFrequency) && (sourceCell.DLFrequency+sourceCell.DLBandWidth == targetCell.DLFrequency+targetCell.DLBandWidth)));
 }
コード例 #17
0
ファイル: LTETools.cs プロジェクト: xiaoyj/Space
 public static bool IsSameFrequency(CellEx sourceCell, CellEx targetCell)
 {
     return ((sourceCell.DLBandWidth == targetCell.DLBandWidth) && (sourceCell.DLFrequency == targetCell.DLFrequency));
 }
コード例 #18
0
ファイル: LTETools.cs プロジェクト: xiaoyj/Space
 //add 2011.3.1
 public static bool IsNeighbourFrequency(CellEx sourceCell, CellEx targetCell)
 {
     return ((sourceCell.DLBandWidth == targetCell.DLBandWidth) && (Math.Abs((float)(sourceCell.DLFrequency - targetCell.DLFrequency)) == sourceCell.DLBandWidth));
 }
コード例 #19
0
ファイル: BestServerCase.cs プロジェクト: xiaoyj/Space
 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));
         }
     }
  }
コード例 #20
0
ファイル: BestServerCase.cs プロジェクト: xiaoyj/Space
 private void calActualRxIntf(int index, CellEx ex, double reNumOfBandWidth)
 {
     if (this.m_NeedCalActualRxIntf & ((this.m_ActualRxPower - reNumOfBandWidth) >= this.m_InterfRecpThreshold))
     {
         this.m_RxPowerOfBandWidthKey = ex.BandWidthAndStartFrequecyKey;
         this.CalActualRxIntf(index);
         this.m_UsedRxPowerOfBandWidthKey = this.m_RxPowerOfBandWidthKey;
     }
     if (this.m_NeedCalMaxRxIntf & ((this.m_MaxRxPower - reNumOfBandWidth) >= this.m_InterfRecpThreshold))
     {
         this.m_MaxRxPowerOfBandWidthKey = ex.BandWidthAndStartFrequecyKey;
         this.CalcmaxRcIntf(index);
         this.m_UsedMaxRxPowerOfBandWidthKey = this.m_MaxRxPowerOfBandWidthKey;
     }
 }