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