public void Initial()
{
cell = GSMMock.MockGsmSimTrx();
user = GSMMock.MockGsmSimUser();
gsmGetLinkLoss = new MockIGetLinkloss();
#region 添加用户最佳服务载波的干扰载波
List<ISimCellBase> interfCell = new List<ISimCellBase>();
Transceiver tranc1 = GSMMock.MockTranceiver();
user.BestServer.Cell = tranc1.Cells[0];//将tranc1设置为用户最佳服务载波所在的小区
//将用户同小区的载波加入到其干扰载波中
foreach (IACell acell in tranc1.Cells)
{
if (acell != user.BestServer.Cell)
{
ISimCellBase tempCell = new GSMSimTRX(acell);
tempCell.Parent = tranc1;
tempCell.Cell = acell;
interfCell.Add(tempCell);
}
}
//在加入其它小区的载波
Transceiver tranc2 = GSMMock.MockTranceiver();
foreach (IACell acell in tranc2.Cells)
{
ISimCellBase tempCell = new GSMSimTRX(acell);
tempCell.Cell = acell;
tempCell.Parent = tranc2;
interfCell.Add(tempCell);
}
user.BestServer.GSMInterCell = interfCell;
#endregion
}
/// <summary>
/// 快照初始化
/// </summary>
/// <param name="context"></param>
public void InitCells(SnapshotContext context)
{
//封装网元
List<IACell> allCells = context.Lookup<List<IACell>>(ContextKeys.IACellList);
m_GSMSimTRXs = new List<GSMSimTRX>();
//m_GSMCells = new List<ISimCellBase>();
m_GSMCells = context.Lookup<List<ISimCellBase>>(ContextKeys.GSMSimCellBase);
foreach(IACell cell in allCells)
{
if (cell.NetType == NetWorkType.GSM)
{
GSMSimTRX trx = new GSMSimTRX(cell);
m_GSMSimTRXs.Add(trx);
if (trx.NeTRX.TRXType == TRXType.BCCH)
{
m_GsmBcchTrx.Add(trx);
}
m_GSMCells.Add((ISimCellBase)trx);
}
}
//context.AddKey(ContextKeys.GSMSimCellBase, m_GSMCells);
m_GSMContext.AddKey(GsmContextkey.GSMSimTRXs, m_GSMSimTRXs);
m_GSMContext.AddKey(GsmContextkey.GSMBcchTrxs, m_GsmBcchTrx);
SnapshotInit(context);
}
/// <summary>
/// 干扰载波MAL初始化
/// </summary>
private void InterfTrxInitMAL(GSMSimTRX interfingTRX)
{
//if (((GSMTRX)interfingTRX.NeTRX).TRXType == TRXType.BCCH || interfingTRX.NeTRX.HopMode == HoppingMode.NonHopping)
//{
// m_MAL2 = new List<int>();
// m_MAL2.Add(interfingTRX.NeTRX.ChannelIndex);
//}
//else
//{
// m_MAL2 = interfingTRX.NeTRX.MALList;
//}
InitMAL(interfingTRX,ref m_MAL2);
}
/// <summary>
/// 计算跳频因子所需要的参数初始化(需要判断是否是BCCH TRX)
/// </summary>
private void Init(GSMSimTRX userTRX, GSMSimTRX interfingTRX, int freqPntOffset)
{
UserTrxInitMAL(userTRX);
InterfTrxInitMAL(interfingTRX);
m_IsSynChronize = userTRX.NeTRX.SynchroRank == interfingTRX.NeTRX.SynchroRank;
m_MAIO1 = userTRX.NeTRX.MAIO;
m_MAIO2 = interfingTRX.NeTRX.MAIO;
m_HSN1 = userTRX.NeTRX.HSN;
m_HSN2 = interfingTRX.NeTRX.HSN;
m_HopMode1 = userTRX.NeTRX.HopMode;
m_HopMode2 = interfingTRX.NeTRX.HopMode;
m_FreqPntOffSet = freqPntOffset;
}
/// <summary>
/// 有用载波MAL初始化
/// </summary>
private void UserTrxInitMAL(GSMSimTRX userTRX)
{
//if (((GSMTRX)userTRX.NeTRX).TRXType == TRXType.BCCH || userTRX.NeTRX.HopMode == HoppingMode.NonHopping)
//{
// m_MAL1 = new List<int>();
// m_MAL1.Add(userTRX.NeTRX.ChannelIndex);
//}
//else
//{
// m_MAL1 = userTRX.NeTRX.MALList;
//}
InitMAL(userTRX,ref m_MAL1);
}
public static List<ISimCellBase> InitialGSMInterfCell()
{
List<ISimCellBase> GSMInterfCellList = new List<ISimCellBase>();
IACell aCell = new GSMTRX();
GSMSimTRX GSMInterfCell = new GSMSimTRX(aCell);
GSMInterfCell.Cell.FreqBand.BandWidth = 3f;
GSMInterfCell.DlFrequency = 2000f;
GSMInterfCell.DlPower = 33;
List<ISimUser> simUserList = new List<ISimUser>();
ISimUser user = new MockGSMUser();
simUserList.Add(user);
GSMInterfCell.ULSimUsers = simUserList;
GSMInterfCellList.Add(GSMInterfCell);
return GSMInterfCellList;
}
/// <summary>
/// 计算BCCH信道受到一个GSM邻载波的干扰
/// </summary>
/// <param name="user">用户</param>
/// <param name="interfTRX">干扰载波</param>
public void CalcGsmBCCHInterf(GSMSimUser user,GSMSimTRX interfTRX,InterfCalcPara interfPara,TotalLossCalc totalLinkLoss,IInterfCalc interfCalc)
{
m_TotalLossCalc = totalLinkLoss;
m_IsCalcDLBCCH = true;
m_InterfPara = interfPara;
m_User = user;
m_IsUserCsService = user.IsCs;
m_InterfCalc = interfCalc;
GSMSimTRX userTRX = FindUsefulTrx(user, true, true);
m_IsSyn = interfTRX.NeTRX.SynchroRank == userTRX.NeTRX.SynchroRank;
m_IsOtherSignalDTX = interfTRX.NeTRX.IsUseDTX;
CalcHopFactor(interfTRX, userTRX, interfPara);
if ((base.scHopFactor==0)&(base.adjHopFactor==0)&(base.adj2HopFactor==0))
return ;
//创建信号
Signal userSignal = BuildGsmSignal(userTRX, true);
Signal source = BuildGsmSignal(interfTRX, true);
float sourcePwr = float.NegativeInfinity;
float loss = totalLinkLoss.GetAllLoss(user, interfTRX, NetWorkType.GSM, true);
CalcBcchInterf(interfTRX, userSignal, source, ref sourcePwr, loss);
}
/// <summary>
/// GSM小区对GSM用户的干扰（邻小区）
/// </summary>
/// <param name="user"></param>
/// <param name="isDL"></param>
/// <param name="interfCell"></param>
/// <param name="interfPara"></param>
/// <param name="totalLinkLoss"></param>
public void CalcTCHInterf(GSMSimUser user, bool isDL, GSMSimTRX interfCell, InterfCalcPara interfPara, TotalLossCalc totalLinkLoss, IInterfCalc interfCalc)
{
m_IsDL = isDL;
m_TotalLossCalc = totalLinkLoss;
m_InterfCalc = interfCalc;
m_InterfPara = interfPara;
m_User = user;
m_IsCalcDLBCCH = false;
m_IsUserCsService = user.IsCs;
GSMSimTRX userTrx = FindUsefulTrx(user, false, isDL);
m_IsSyn = interfCell.NeTRX.SynchroRank == userTrx.NeTRX.SynchroRank;
CalcHopFactor(interfCell, userTrx,interfPara);
if ((scHopFactor == 0) & (adjHopFactor == 0) & (adj2HopFactor == 0))
return;
Signal userSignal = BuildGsmSignal(userTrx, isDL);
Signal source = BuildGsmSignal(interfCell, isDL);
float sourcePwr = float.NegativeInfinity;
List<GSMTimeSlot> userTSs = FindUserTSs(user, isDL);
source.Frequency = CommonCalc.GSMFreqPointToFrequency(interfCell.NeTRX.FreqBand.DLFrequency, interfCell.NeTRX.FreqBand.BandWidth,
interfCell.NeTRX.FreqBand.StartChIndex, interfCell.NeTRX.ChannelIndex, isDL);
float loss = totalLinkLoss.GetAllLoss(user, interfCell, NetWorkType.GSM, isDL);
sourcePwr = CalcTchInterf(user, isDL, interfCell, userSignal, source, sourcePwr, userTSs, loss);
}
/// <summary>
/// 同步干扰计算
/// </summary>
/// <param name="otherTrx"></param>
/// <param name="userSignal"></param>
/// <param name="source"></param>
/// <param name="sourcePwr"></param>
/// <param name="loss"></param>
private void SynOneSourceInterf(GSMSimTRX otherTrx, Signal userSignal, Signal source, ref float sourcePwr, float loss)
{
bool isFindUser = false;
SyncFindUser(otherTrx, ref sourcePwr, ref isFindUser);
if (!isFindUser)
return;
source.RxPower = sourcePwr - loss;
source.LinkType = LinkType.Downlink;
CalcOneSourceInterf(userSignal, source);
}
/// <summary>
/// 寻找异步上行用户
/// </summary>
/// <param name="user"></param>
/// <param name="otherTrx"></param>
/// <param name="sourcePwr"></param>
/// <param name="loss"></param>
/// <param name="index"></param>
/// <param name="isFindOtherUser"></param>
private void FindAsycULUser(GSMSimUser user, GSMSimTRX otherTrx, ref float sourcePwr, ref float loss, int index, ref bool isFindOtherUser)
{
foreach (GSMSimUser otherUser in otherTrx.TSs[index].ULMsColl)
{
if (otherUser.CurULTxPower.ContainsKey(otherTrx.TSs[index]))
{
sourcePwr = otherUser.CurULTxPower[otherTrx.TSs[index]];
m_IsOtherSignalDTX = otherUser.IsUseDTX;
m_IsOtherUserCsService = otherUser.IsCs;
loss = m_TotalLossCalc.GetAllLoss(otherUser, user.BestServer, NetWorkType.GSM, false);
isFindOtherUser = true;
break;
}
if (otherUser.PreULTxPower.ContainsKey(otherTrx.TSs[index]))
{
sourcePwr = otherUser.PreULTxPower[otherTrx.TSs[index]];
m_IsOtherSignalDTX = otherUser.IsUseDTX;
m_IsOtherUserCsService = otherUser.IsCs;
loss = m_TotalLossCalc.GetAllLoss(otherUser, user.BestServer, NetWorkType.GSM, false);
isFindOtherUser = true;
break;
}
else
continue;
}
}
private int[] CalcLoad(GSMSimTRX trx)
{
int[] usedTs = new int[2];
foreach (GSMTimeSlot ts in trx.TSs)
{
bool temp;
temp = (ts.ULMsColl.Count != 0) && (usedTs[0]++ > 0);
temp = (ts.DLMsColl.Count != 0) && (usedTs[1]++ > 0);
}
return usedTs;
}
private void SetUserPowerForOtherNet(GSMSimUser user,GSMSimTRX cell)
{
if (user.TrafficUser.LinkType == Huawei.UNet.Traffic.Interface.LinkType.Uplink)
{
cell.ULSimUsers.Add(user);
user.UlPower = user.ResultStatistic.ULPowerList.Last();
user.Frequency = CommonCalc.GSMFreqPointToFrequency(user.UlTs[0].Parent.NeTRX.FreqBand.DLFrequency, user.UlTs[0].Parent.NeTRX.FreqBand.BandWidth,
user.UlTs[0].Parent.NeTRX.FreqBand.StartChIndex, user.UlTs[0].Parent.NeTRX.ChannelIndex, false);
}
else
{
user.UlPower = float.NegativeInfinity;
}
}
/// <summary>
/// 异步系统是否能够找到用户
/// </summary>
/// <param name="index"></param>
/// <param name="otherTrx"></param>
/// <param name="sourcePwr"></param>
/// <param name="isFindUser"></param>
private void AsycFindUser(int index, GSMSimTRX otherTrx, ref float sourcePwr, ref bool isFindUser)
{
if (otherTrx.NeTRX.TRXType == TRXType.BCCH & index == 0)
{
sourcePwr = otherTrx.NeTRX.TRXPower;
m_IsOtherUserCsService = true;
isFindUser = true;
}
else
{
FindAsycUser(index, otherTrx, ref sourcePwr, ref isFindUser);
}
}
/// <summary>
/// 查找上行用户
/// </summary>
private void FindSyULUser(GSMSimUser user, GSMSimTRX otherTrx, ref float sourcePwr, ref float loss, GSMTimeSlot ts, ref bool isFindOtherUser)
{
foreach (GSMSimUser otherUser in otherTrx.TSs[ts.Index].ULMsColl)
{
sourcePwr = ULSourcePwr(otherTrx, sourcePwr, ts, otherUser);
m_IsOtherSignalDTX = otherUser.IsUseDTX;
m_IsOtherUserCsService = otherUser.IsCs;
isFindOtherUser = true;
loss = m_TotalLossCalc.GetAllLoss(otherUser, user.BestServer, NetWorkType.GSM, false);
break;
}
}
/// <summary>
/// 给下行功率赋值
/// </summary>
/// <param name="otherTrx"></param>
/// <param name="sourcePwr"></param>
/// <param name="ts"></param>
/// <param name="otherUser"></param>
/// <returns></returns>
private float DLSourcePwr(GSMSimTRX otherTrx, float sourcePwr, GSMTimeSlot ts, GSMSimUser otherUser)
{
if (otherTrx.TSs[ts.Index].CurDLTxPower.ContainsKey(otherUser))
{
sourcePwr = otherTrx.TSs[ts.Index].CurDLTxPower[otherUser];
}//不需要区分是否是在BCCH的TRX上
else if (otherTrx.TSs[ts.Index].PreDLTxPower.ContainsKey(otherUser))
{
sourcePwr = otherTrx.TSs[ts.Index].PreDLTxPower[otherUser];
}
else
{
sourcePwr = otherTrx.NeTRX.TRXPower;
}
return sourcePwr;
}
/// <summary>
/// 寻找同步下行用户
/// </summary>
/// <param name="otherTrx"></param>
/// <param name="sourcePwr"></param>
/// <param name="ts"></param>
/// <param name="isFindOtherUser"></param>
private void FindSynDlUser(GSMSimTRX otherTrx, ref float sourcePwr, GSMTimeSlot ts, ref bool isFindOtherUser)
{
foreach (GSMSimUser otherUser in otherTrx.TSs[ts.Index].DLMsColl)
{
sourcePwr = DLSourcePwr(otherTrx, sourcePwr, ts, otherUser);
m_IsOtherUserCsService = otherUser.IsCs;
m_IsOtherSignalDTX = otherTrx.NeTRX.IsUseDTX;
isFindOtherUser = true;
//因为是静态仿真，只要找到一个用户即可。多个用户共享一个时隙是对一个时隙的帧（8个时隙长度）复用
break;
}
}
/// <summary>
/// 同步下行计算
/// </summary>
private void SyncDLInterf(GSMSimTRX otherTrx, Signal userSignal, Signal source, ref float sourcePwr, List<GSMTimeSlot> userTSs, float loss)
{
//用户支持多时隙
foreach (GSMTimeSlot ts in userTSs)
{
m_UserTS = ts;
bool isFindOtherUser = false;
//BCCH信道
if (otherTrx.NeTRX.TRXType == TRXType.BCCH & (ts.Index == 0))
{
sourcePwr = otherTrx.NeTRX.TRXPower;
m_IsOtherSignalDTX = false;
m_IsOtherUserCsService = true;
isFindOtherUser = true;
}
else
{
//查找其他TRX下同个时隙的用户
FindSynDlUser(otherTrx, ref sourcePwr, ts, ref isFindOtherUser);
}
//如果Other TRX的该时隙下没有用户或者没有BCCH信号
if (!isFindOtherUser)
continue;
source.RxPower = sourcePwr - loss;
CalcOneSourceInterf(userSignal, source);
}
}
/// <summary>
/// 实际计算TCH系统内干扰
/// </summary>
/// <returns></returns>
private float CalcTchInterf(GSMSimUser user, bool isDL, GSMSimTRX interfCell, Signal userSignal, Signal source, float sourcePwr, List<GSMTimeSlot> userTSs, float loss)
{
//两小区同步
if (m_IsSyn)
{
SyncCellInterf(user, interfCell, isDL, userSignal, source, ref sourcePwr, userTSs, loss);
}
//两个小区异步
else
{
for (int index = 0; index < 8; index++)
{
AsyncCellInterf(user, interfCell, isDL, userSignal, source, ref sourcePwr, userTSs, loss, index);
}
}
return sourcePwr;
}
private int[] GetUserTypeNum(GSMSimTRX cell)
{
int[] usrNum = new int[2];
foreach (GSMSimUser user in cell.CellUsers)
{
if (user.IsPolyModelUser == true)
{
usrNum[1]++;
}
else
{
usrNum[0]++;
}
}
return usrNum;
}
/// <summary>
/// 异步干扰计算
/// </summary>
/// <param name="index"></param>
/// <param name="otherTrx"></param>
/// <param name="userSignal"></param>
/// <param name="source"></param>
/// <param name="sourcePwr"></param>
/// <param name="loss"></param>
private void AsyOneSourceInterf(int index, GSMSimTRX otherTrx, Signal userSignal, Signal source, ref float sourcePwr, float loss)
{
bool isFindUser = false;
AsycFindUser(index, otherTrx, ref sourcePwr, ref isFindUser);
if (!isFindUser)
return;
source.RxPower = sourcePwr - loss;
CalcOneSourceInterf(userSignal, source);
}
/// <summary>
/// 同步系统是否能够找到用户
/// </summary>
/// <param name="otherTrx"></param>
/// <param name="sourcePwr"></param>
/// <param name="isFindUser"></param>
private void SyncFindUser(GSMSimTRX otherTrx, ref float sourcePwr, ref bool isFindUser)
{
//BCCH载波
if (otherTrx.NeTRX.TRXType == TRXType.BCCH)
{
sourcePwr = otherTrx.NeTRX.TRXPower;
m_IsOtherUserCsService = true;
isFindUser = true;
}
//TCH载波
else
{
FindSyncUser(otherTrx, ref sourcePwr, ref isFindUser);
}
}
/// <summary>
/// 给上行源功率赋值
/// </summary>
private float ULSourcePwr(GSMSimTRX otherTrx, float sourcePwr, GSMTimeSlot ts, GSMSimUser otherUser)
{
if (otherUser.CurULTxPower.ContainsKey(otherTrx.TSs[ts.Index]))
{
sourcePwr = otherUser.CurULTxPower[otherTrx.TSs[ts.Index]];
}
else if (otherUser.PreULTxPower.ContainsKey(otherTrx.TSs[ts.Index]))
sourcePwr = otherUser.PreULTxPower[otherTrx.TSs[ts.Index]];
else
sourcePwr = otherUser.TrafficUser.Terminal.GetNetWorkTerminal(NetWorkType.GSM).MaxTxPower;
return sourcePwr;
}
private void FindAsycUser(int index, GSMSimTRX otherTrx, ref float sourcePwr, ref bool isFindUser)
{
foreach (GSMSimUser otherUser in otherTrx.TSs[index].DLMsColl)
{
if (otherTrx.TSs[index].CurDLTxPower.ContainsKey(otherUser))
{
sourcePwr = otherTrx.TSs[index].CurDLTxPower[otherUser];
m_IsOtherUserCsService =otherUser.IsCs;
isFindUser = true;
break;
}
if (otherTrx.TSs[index].PreDLTxPower.ContainsKey(otherUser))
{
sourcePwr = otherTrx.TSs[index].PreDLTxPower[otherUser];
m_IsOtherUserCsService = otherUser.IsCs;
isFindUser = true;
break;
}
//else
// continue;
}
}
/// <summary>
/// 计算跳频因子
/// </summary>
/// <param name="otherTrx">干扰载波</param>
/// <param name="userTrx">用户载波</param>
protected void CalcHopFactor(GSMSimTRX otherTrx, GSMSimTRX userTrx,InterfCalcPara interfPara)
{
scHopFactor = adjHopFactor = adj2HopFactor = 0;
scHopFactor = m_HopFactor.CalcFactor(userTrx, otherTrx, 0);
if (interfPara.IsCalcAdjFreq)
adjHopFactor = m_HopFactor.CalcFactor(userTrx, otherTrx, 1);
if (interfPara.IsCalcAdj2Freq)
adj2HopFactor = m_HopFactor.CalcFactor(userTrx, otherTrx, 2);
}
/// <summary>
/// 实际计算下行BCCH干扰
/// </summary>
/// <param name="interfTRX"></param>
/// <param name="userSignal"></param>
/// <param name="source"></param>
/// <param name="sourcePwr"></param>
/// <param name="loss"></param>
private void CalcBcchInterf(GSMSimTRX interfTRX, Signal userSignal, Signal source, ref float sourcePwr, float loss)
{
if (m_IsSyn)
{
SynOneSourceInterf(interfTRX, userSignal, source, ref sourcePwr, loss);
return;
}
else
{
for (int index = 0; index < 8; index++)
{
AsyOneSourceInterf(index, interfTRX, userSignal, source, ref sourcePwr, loss);
}
}
}
/// <summary>
/// 异步上行干扰计算
/// </summary>
private void AsycULInterf(GSMSimUser user, GSMSimTRX otherTrx, Signal userSignal, Signal source, ref float sourcePwr, List<GSMTimeSlot> userTSs, float loss, int index)
{
foreach (GSMTimeSlot ts in userTSs)
{
m_UserTS = ts;
bool isFindOtherUser = false;
//BCCH信道
if (otherTrx.NeTRX.TRXType == TRXType.BCCH & (index == 0 /*|| index == 1*/))
{
continue;
}
else
{
//查找该时隙下的用户
FindAsycULUser(user, otherTrx, ref sourcePwr, ref loss, index, ref isFindOtherUser);
}
if (!isFindOtherUser)
continue;
source.RxPower = sourcePwr - loss;
CalcOneSourceInterf(userSignal, source);
}
}
/// <summary>
/// 异步系统计算
/// </summary>
private void AsyncCellInterf(GSMSimUser user, GSMSimTRX otherTrx, bool isDL, Signal userSignal, Signal source, ref float sourcePwr, List<GSMTimeSlot> userTSs, float loss, int index)
{
if (isDL)
{
source.LinkType = LinkType.Downlink;
AsynDLInterf(otherTrx, userSignal, source, ref sourcePwr, userTSs, loss, index);
}
else
{
source.LinkType = LinkType.Uplink;
AsycULInterf(user, otherTrx, userSignal, source, ref sourcePwr, userTSs, loss, index);
}
}
private void AddLoad(GSMSimTRX trx)
{
int[] load = CalcLoad(trx);
trx.UlLoad = load[0] / 8f;
trx.DlLoad = load[1] / 8f;
trx.CoSimuLoad = (trx.UlLoad + trx.DlLoad) ;
}
public void Initial()
{
allUsers = GSMMock.MockGsmSimUserList();
allUsers[0].TrafficUser.LinkType = LinkType.Uplink;
allUsers[0].TrafficUser.Id = 0;
allUsers[2].Access = true;
allUsers[1].TrafficUser.LinkType = LinkType.Downlink;
allUsers[1].TrafficUser.Id = 1;
allUsers[2].TrafficUser.LinkType = LinkType.Uplink;
allUsers[2].TrafficUser.Id = 2;
allUsers[3].TrafficUser.LinkType = LinkType.Downlink;
allUsers[3].TrafficUser.Id = 4;
allUsers[4].TrafficUser.LinkType = LinkType.Downlink;
allUsers[4].TrafficUser.Terminal.GetNetWorkTerminal(NetWorkType.GSM).MaxTxPower = -30f;
allUsers[4].TrafficUser.Id = 5;
allUsers[5].TrafficUser.LinkType = LinkType.Downlink;
allUsers[5].TrafficUser.Id = 6;
//添3个BCCH载波，一个TCH载波，每个载波的位置分别为（0,0）,（0,1000），（0,2000），（0,3000）
gsmCells = new List<GSMSimTRX>();
Site[] sites = new Site[4];
Transceiver[] trancs = new Transceiver[4];
for (int i = 0; i < 4; i++)
{
sites[i] = new Site();
sites[i].X = 0;
sites[i].Y = i * 1000;
trancs[i] = GSMMock.MockTranceiver();
trancs[i].Parent = sites[i];
trancs[i].ID = (short)i;
GSMSimTRX trx = GSMMock.MockGsmSimTrx();
trx.NeTRX.TRXType = TRXType.BCCH;
trx.Cell.Parent = trancs[i];
gsmCells.Add(trx);
}
gsmCells[3].NeTRX.TRXType = TRXType.TCH;
allUsers[5].BestServer = null;
#region 为前3个载波添加干扰载波
for (int i = 0; i < 3; i++)
{
int j = 0;
List<ISimCellBase> interfCell = new List<ISimCellBase>();
//将trancs[i]设置为该载波所在的小区
gsmCells[i].Cell = trancs[i].Cells[0];
//设置载波的发射功率
gsmCells[i].NeTRX.TRXPower = 46 - i;
//将该载波同小区的载波加入到其干扰载波中
foreach (IACell acell in trancs[i].Cells)
{
if (acell != gsmCells[i].Cell)
{
ISimCellBase tempCell = new GSMSimTRX(acell);
tempCell.Parent = trancs[i];
tempCell.Cell = acell;
//为干扰载波设置不同的发射功率
((GSMSimTRX)tempCell).NeTRX.TRXPower = 44 + j;
j++;
interfCell.Add(tempCell);
}
}
//在加入其它小区的载波
Transceiver tranc2 = GSMMock.MockTranceiver();
foreach (IACell acell in tranc2.Cells)
{
ISimCellBase tempCell = new GSMSimTRX(acell);
tempCell.Cell = acell;
tempCell.Parent = tranc2;
//为干扰载波设置不同的发射功率
((GSMSimTRX)tempCell).NeTRX.TRXPower = 40 + j;
j++;
interfCell.Add(tempCell);
}
gsmCells[i].GSMInterCell = interfCell;
}
#endregion
linkLossProvider = new MockIGetLinkloss();
bestServer = new BestServer();
}
/// <summary>
/// 异步下行干扰计算
/// </summary>
private void AsynDLInterf(GSMSimTRX otherTrx, Signal userSignal, Signal source, ref float sourcePwr, List<GSMTimeSlot> userTSs, float loss, int index)
{
foreach (GSMTimeSlot ts in userTSs)
{
m_UserTS = ts;
bool isFindOtherUser = false;
//BCCH信道
if (otherTrx.NeTRX.TRXType == TRXType.BCCH & (index == 0))
{
sourcePwr = otherTrx.NeTRX.TRXPower;
m_IsOtherUserCsService = true;
m_IsOtherSignalDTX = false;
isFindOtherUser = true;
}
else
{
FindAsynDLUser(otherTrx, ref source, ref sourcePwr, index, ref isFindOtherUser);
}
if (!isFindOtherUser)
continue;
source.RxPower = sourcePwr - loss;
CalcOneSourceInterf(userSignal, source);
}
}
