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;
}
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 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;
}
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;
}
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++;
}
}
}
}
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
}
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;
}
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;
}
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;
}
/// <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);
}
}
}
}
/// <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);
}
}
}
}
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;
}
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);
}
}
}
}
}
