public void Init()
{
cellResultUpdater = new HSUPA_CellResultUpdater();
commonParam = new HSUPA_CommonParam(MockContext.CreatContext());
cell = MockCell.CreatUMTSSimCell(0, 0);
user = MockUser.CreatUMTSPSUser();
user2 = MockUser.CreatUMTSPSUser();
user3 = MockUser.CreatUMTSPSUser();
user.HSUPA_ULTxPowerList.Add(10);
user2.HSUPA_ULTxPowerList.Add(10);
user3.HSUPA_ULTxPowerList.Add(10);
user.HSUPA_ULThroughputList.Add(64000);
user2.HSUPA_ULThroughputList.Add(32000);
user3.HSUPA_ULThroughputList.Add(10000);
user.HSUPA_ScheduleRateList.Add(64000);
user2.HSUPA_ScheduleRateList.Add(64000);
user3.HSUPA_ScheduleRateList.Add(64000);
cell.ServerdHSUPAUser.Clear();
cell.ServerdHSUPAUser.Add(user);
cell.ServerdHSUPAUser.Add(user2);
cell.ServerdHSUPAUser.Add(user3);
commonParam.CellList.Add(cell);
commonParam.SimTTINumber = 1;
cellResultUpdater.CommonParams = commonParam;
}
public UMTSHSDPABearer FindBearByRate(UMTSSimCell cell, UMTSSimUser user)
{
List<UMTSHSDPABearer> bearList = new List<UMTSHSDPABearer>();
foreach (UMTSHSDPABearer bear in m_BearList)
{
if (bear.RlcPeakthroughput > user.RequestRate)
{
bearList.Add(bear);
}
}
//存在某个速率对应多个承载的问题
float minRate = GetMinRateInBear(bearList);
List<UMTSHSDPABearer> availbaleBearList = new List<UMTSHSDPABearer>();
foreach (UMTSHSDPABearer bear in bearList)
{
if (bear.RlcPeakthroughput == minRate)
{
availbaleBearList.Add(bear);
}
}
SortBear(availbaleBearList, user, cell);
if (bearList[0].HspdschNum < cell.HSDPA_NotUsedCode)
{
//返回最接近的承载
return availbaleBearList[0];
}
else
{
return null;
}
}
public static UMTSSimCell CreatUMTSSimCell(double x,double y)
{
IACell cell = new UMTSCell();
Transceiver trans = new Transceiver();
Site site = new Site();
List<UMTSSimUser> serverdUserList = new List<UMTSSimUser>();
serverdUserList.Add(MockUser.CreatUMTSPSUser());
site.X = x;
site.Y = y;
site.Equipment = new BtsEquipment();
site.Equipment.NoiseFigure = 3;
cell.Parent = trans;
trans.Parent = site;
UMTSSimCell simCell = new UMTSSimCell(cell);
simCell.NECell.PilotPower = 33f;
simCell.NECell.FreqBand.BandWidth = 3f;
simCell.DlFrequency = 2100f;
simCell.UlFrequency = 2000f;
simCell.GSMInterfCells = InitialGSMInterfCell();
simCell.TDInterfCells = InitialTDInterfCell();
simCell.ServerdHSUPAUser = serverdUserList;
simCell.ULCENum = 15;
simCell.TotalNoiserThreshold = 10;
return simCell;
}
/// <summary>
/// 计算下行EbNt的Nt
/// </summary>
/// <param name="user"></param>
/// <param name="cell"></param>
/// <returns></returns>
public float CalcDLNt(UMTSSimCell cell ,UMTSSimUser user)
{
float intraInterf = m_CommonParam.ServiceProvider.UMTSInterfCalc.CalcIor(user.MaxRSCPCell, user);
float interInterf = CalcDLInterInterf(user.MaxRSCPCell, user);
user.No = (float)UnitTrans.dBmTomw(m_CommonParam.UMTSUIParam.ThermalNoise) * 3840000 * (float)UnitTrans.dBmTomw(user.Terminal.NoiseFigure);
float userDLNt = (1 - m_CommonParam.UMTSUIParam.OrthCoef) * intraInterf + interInterf + user.No + user.UlInterfFromOtherSys;
return userDLNt;
}
private float CalcDLInterInterf(UMTSSimCell cell, UMTSSimUser user)
{
float interInterf = 0f;
foreach (UMTSSimCell interfCell in cell.UMTSInterfCells)
{
interInterf += m_CommonParam.ServiceProvider.UMTSInterfCalc.CalcIoc(cell, interfCell, user);
}
return interInterf;
}
private void GenerateUMTSCells(List<IACell> iaCellList, List<ISimCellBase> umtsCellBase)
{
foreach (IACell cell in iaCellList)
{
if (cell.NetType != NetWorkType.UMTS)
continue;
ISimCellBase cellBase = new UMTSSimCell(cell);
umtsCellBase.Add(cellBase);
}
}
public float CalcULNt(UMTSSimCell cell, UMTSSimUser user)
{
float ulLoss = float.MinValue;
//除去当前计算链路的全带宽的接收功率（干扰）
float cellIo = 0.0f;
ulLoss = m_CommonParam.ServiceProvider.LinkLossCalc.GetLinkLoss(NetWorkType.UMTS, cell.NECell.ID, user.TrafficUser.Id, LinkType.Uplink);
cellIo = cell.CurRxPower - user.TxPower / (float)UnitTrans.dBto(ulLoss);
//CurRxPower里面已经包含背景噪声和异系统干扰
return cellIo;
}
private bool JudgeIfCanScheduledSuccess(UMTSSimCell cell, UMTSSimUser user, bool IsScheduledSuccessed)
{
if (user.HSUPABearer == null)
{
IsScheduledSuccessed = false;
}
else
{
IsScheduledSuccessed = JudgeNoiseRise(cell, user);
}
return IsScheduledSuccessed;
}
/// <summary>
/// 本小区干扰
/// </summary>
/// <param name="cell"></param>
/// <param name="user"></param>
/// <returns></returns>
private float CalcDLIntraIntf(UMTSSimCell cell, UMTSSimUser user)
{
float IntraIntf = 0f;
if (cell.CellType == CarrierTypeOfUMTS.HSDPA)
{
IntraIntf = HSDPA_CommonCalc.CalcIntraIntf(m_UIParam.OrthCoef, cell.HSDPA_UsedPower, user.AssignedPower, cell.HSDPA_UsedHsscchPower, (float)UnitTrans.dBmTomw(cell.NECell.PilotPower), user.DLLoss);
}
else if (cell.CellType == CarrierTypeOfUMTS.R99AndHSDPA)
{
IntraIntf = HSDPA_CommonCalc.CalcIntraIntf(m_UIParam.OrthCoef, cell.HSDPA_UsedPower, user.AssignedPower, cell.HSDPA_UsedHsscchPower, cell.CurTxPower, user.DLLoss);
}
return IntraIntf;
}
private void ScheduleUser(UMTSSimCell cell)
{
foreach (UMTSSimUser user in cell.ServerdHSDPAUser)
{
//每个小区调度结束的条件是：调度用户数已达SCCH信道数或者小区功率和码资源其中之一用完
bool canNotScheduleInTTI = m_SCCHNum == 0 || cell.HSDPA_NotUsedCode == 0 || (cell.HSDPA_NotUsedPower - cell.HSDPA_UsedHsscchPower <= float.Epsilon);
if (canNotScheduleInTTI)
{
user.IsScheduledInTTI = false;
break;
}
PerformSchedule(cell, user);
}
}
/// <summary>
/// 本制式内邻小区干扰
/// </summary>
/// <param name="cell"></param>
/// <param name="user"></param>
/// <returns></returns>
private float CalcUMTSInterIntf(UMTSSimCell cell, UMTSSimUser user)
{
float intf = 0.0f;
Signal usefulSignal = new Signal();
usefulSignal.NetType = NetWorkType.UMTS;
usefulSignal.LinkType = LinkType.Downlink;
usefulSignal.FreqBand = cell.NECell.FreqBand.BandWidth;
usefulSignal.Frequency = cell.DlFrequency;
foreach (UMTSSimCell UMTScell in cell.UMTSInterfCells)
{
GetUMTSInterIntf(UMTScell, user, usefulSignal, ref intf);
}
return intf;
}
private void AccessControl(UMTSSimCell cell)
{
cell.AccessFailedUserNumList.Clear();
for (int i = 0; i < cell.ServerdR99User.Count; i++)
{
UMTSSimUser user = cell.ServerdR99User[i];
if (user.IsAccess)
continue;
//一个用户可以同时接入它激活集里面的多个小区
bool isSHO = IsInSHO(user);
RunAccess(user, isSHO);
Update(cell, user, ref i);
}
}
/// <summary>
/// HSUPA用户资源调度
/// </summary>
/// <param name="user"></param>
public void Run(UMTSSimCell cell, UMTSSimUser user)
{
bool IsScheduledSuccessed = false;
if ((user.Tti == m_CommonParams.TTI10) && ((m_CommonParams.CurTTIIndex - user.LastServerdTTI) % 5 != 0)
|| IsBlockSizeEnough(user))
{
return;
}
if (user.ReTransNumber == 0)//用户处于重传状态不进行速率调整
{
m_RateCtrl.UserScheduleRateCtrl(user);
}
//用户已经完成绑定承载过程，下面需要结合小区的接收功率执行真正的调度，同时更新主服务小区的接收功率，干扰小区暂时不考虑
IsScheduledSuccessed = JudgeIfCanScheduledSuccess(cell, user, IsScheduledSuccessed);
ScheduleSuccessOrFail(cell, user, IsScheduledSuccessed);
}
private void PerformSchedule(UMTSSimCell cell, UMTSSimUser user)
{
if (!user.IsCanSchedule)
{
user.IsScheduledInTTI = false;
return;
}
if (user.ServiceType == CommonServiceType.CSService)
{
FindBearForCS(cell, user);
}
else
{
FindBearForPS(cell, user);
}
}
private List<ISimCellBase> InitialUmtsInterfCell()
{
List<ISimCellBase> umtsInterfCellList = new List<ISimCellBase>();
Site site = new Site();
BtsEquipment equipment = new BtsEquipment();
equipment.NoiseFigure = 8f;
site.Equipment = equipment;
Transceiver tran = new Transceiver();
tran.Parent = site;
IACell aCell = new UMTSCell();
aCell.Parent = tran;
UMTSSimCell umtsInterfCell = new UMTSSimCell(aCell);
umtsInterfCell.Cell.FreqBand.BandWidth = 5f;
umtsInterfCell.DlFrequency = 1805.1f;
umtsInterfCell.DlPower = 40;
umtsInterfCellList.Add(umtsInterfCell);
return umtsInterfCellList;
}
public void Init()
{
calcIo = new HSUPA_CalcIo();
context = MockContext.CreatContext();
commonParam = new HSUPA_CommonParam(context);
interfCalc = new MockInterfCalc();
getLinkLoss = new MockGetLinkloss();
bearerSelector = new HSUPA_BearerSelector(commonParam);
calcIo.UMTSInterfCalc = new UMTSInterfCalc(interfCalc, getLinkLoss);
cell = MockCell.CreatUMTSSimCell(0, 0);
cell.CellType = CarrierTypeOfUMTS.HSUPA;
user1 = MockUser.CreatUMTSPSUser();
user1.MaxRSCPCell = cell;
user1.MaxRSCPCell.UMTSInterfCells = new List<ISimCellBase>();
user1.MaxRSCPCell.HSUPA_CurRxPower = 10;
user1.MaxRSCPCell.HSUPA_UsedRxPower = 10;
user1.IsScheduledInTTI = true;
calcIo.CommonParams = commonParam;
}
public void Init()
{
commonParam = new HSUPA_CommonParam(MockContext.CreatContext());
cell = MockCell.CreatUMTSSimCell(0, 0);
user = MockUser.CreatUMTSPSUser();
user2 = MockUser.CreatUMTSPSUser();
user3 = MockUser.CreatUMTSPSUser();
userPrioritySort = new HSUPA_UserPrioritySort();
user.UserPriority = 1;
user.ServicePriority = 1;
user2.UserPriority = 1;
user2.ServicePriority = 2;
user3.UserPriority = 3;
user3.ServicePriority = 1;
cell.ServerdHSUPAUser.Clear();
cell.ServerdHSUPAUser.Add(user);
cell.ServerdHSUPAUser.Add(user2);
cell.ServerdHSUPAUser.Add(user3);
commonParam.CellList.Add(cell);
userPrioritySort.CommonParam = commonParam;
userPrioritySort.Execute();
}
public void Init()
{
scheduler = new HSUPA_Scheduler();
context = MockContext.CreatContext();
commonParam = new HSUPA_CommonParam(context);
commonParam.NewSimTTIStart(commonParam.TTILength);
rateCtrl = new HSUPA_UserScheduleRateCtrl();
calcIo = new HSUPA_CalcIo();
interfCalc = new MockInterfCalc();
getLinkLoss = new MockGetLinkloss();
bearerSelector = new HSUPA_BearerSelector(commonParam);
rateCtrl.CommonParams = commonParam;
scheduler.CommonParams = commonParam;
calcIo.CommonParams = commonParam;
calcIo.UMTSInterfCalc = new UMTSInterfCalc(interfCalc, getLinkLoss);
scheduler.HSUPA_CalcIo = calcIo;
scheduler.RateCtrl = rateCtrl;
cell = MockCell.CreatUMTSSimCell(0,0);
user = MockUser.CreatUMTSPSUser();
user.MaxRSCPCell = cell;
rateCtrl.BearerSelector = bearerSelector;
scheduler.HSUPA_BearerSelector = bearerSelector;
}
private void ScheduleSuccessOrFail(UMTSSimCell cell, UMTSSimUser user,bool IsScheduledSuccess)
{
if (IsScheduledSuccess)
{
OperateAfterSuccessedSchedule(cell, user);
}
else
{
user.IsScheduledInTTI = false;
user.TxPower = 0;
}
}
/// <summary>
/// 计算小区接收到某用户的上行CIR
/// </summary>
/// <param name="currentCell">小区</param>
/// <param name="user">用户</param>
/// <returns></returns>
private float GetULCIR(UMTSSimCell currentCell, UMTSSimUser user)
{
float ulLoss = 0.0f;
ulLoss = (float)UnitTrans.dBto(m_CommonParam.ServiceProvider.LinkLossCalc.GetLinkLoss(NetWorkType.UMTS, currentCell.NECell.ID, user.TrafficUser.Id, LinkType.Uplink));
float ULCIR = (user.TxPower / ulLoss) / (currentCell.CurRxPower - user.TxPower / ulLoss);
return ULCIR;
}
private void FindBearForPS(UMTSSimCell cell, UMTSSimUser user)
{
UMTSHSDPABearer bear = m_BearSelect.FindBearByCIR(cell, user);
if (bear.RlcPeakthroughput < user.RequestRate)
{
OperateAfterSuccessedSchedule(cell, user, bear);
return;
}
else
{
m_BearSelect.FindBearByRate(cell, user);
OperateAfterSuccessedSchedule(cell, user, bear);
return;
}
}
private void GetUMTSInterIntf(UMTSSimCell currentCell, UMTSSimUser user, Signal usefulSignal, ref float intf)
{
Signal source = new Signal();
source.RxPower = float.NegativeInfinity;
source.LinkType = LinkType.Downlink;
source.NetType = NetWorkType.UMTS;
if (currentCell.CellType == CarrierTypeOfUMTS.HSDPA)
{
source.RxPower = (float)UnitTrans.mwTodBm(currentCell.HSDPA_UsedPower + currentCell.HSDPA_UsedHsscchPower + (float)UnitTrans.dBmTomw(currentCell.NECell.PilotPower)) - m_LinkLoss.GetDLLinkLoss(currentCell, user, false);
}
else if (currentCell.CellType == CarrierTypeOfUMTS.R99AndHSDPA)
{
source.RxPower = (float)UnitTrans.mwTodBm(currentCell.HSDPA_UsedPower + currentCell.HSDPA_UsedHsscchPower + currentCell.CurTxPower) - m_LinkLoss.GetDLLinkLoss(currentCell, user, false);
}
source.FreqBand = currentCell.NECell.FreqBand.BandWidth;
source.Frequency = currentCell.DlFrequency;
InterfResult intfResult = m_CommonParam.ServiceProvider.InterfCalc.CalcOneSourceInf(usefulSignal, source);
intf += HSDPA_CommonCalc.AddAllInterf(intfResult);
}
/// <summary>
/// 计算小区对用户的目标发射功率，考虑软切换影响
/// </summary>
/// <param name="user"></param>
/// <param name="dlSHOGain"></param>
/// <returns></returns>
private float CalcTargetTxPower(UMTSSimUser user,UMTSSimCell currentCell, float dlSHOGain)
{
//float EbNo = m_CommonParam.ServiceProvider.TrafficMgr.GetR99EbNo(user.R99Bearer.Name, user.TrafficUser.Mobility.Name, LinkType.Downlink);
//EbNo = (float)UnitTrans.dBto(EbNo);
//float DLTargetCIRatio = EbNo / (m_CommonParam.UMTSUIParam.Rc / (user.R99Bearer.DLNominalRate * 1000));
////用户接受端的功率
//return DLTargetCIRatio * user.Io / dlSHOGain;
float targetDLEbNt = m_CommonParam.ServiceProvider.TrafficMgr.GetR99EbNo(user.R99Bearer.Name, user.TrafficUser.Mobility.Name, LinkType.Downlink);
float targetDLEcNt = (float)UnitTrans.dBto(targetDLEbNt) / (m_CommonParam.UMTSUIParam.Rc / (user.R99Bearer.DLNominalRate * 1000));
float dlNt = m_InterfCalc.CalcDLNt(currentCell, user);
float dlLoss = (float)UnitTrans.dBto(m_CommonParam.ServiceProvider.LinkLossCalc.GetLinkLoss(NetWorkType.UMTS, currentCell.NECell.ID, user.TrafficUser.Id, LinkType.Downlink));
float targetDLTxPower = targetDLEcNt * dlNt * dlLoss / dlSHOGain;
targetDLTxPower = Math.Max(targetDLTxPower, (float)UnitTrans.dBmTomw(user.R99Bearer.PtchMin));
targetDLTxPower = Math.Min(targetDLTxPower, (float)UnitTrans.dBmTomw(user.R99Bearer.PtchMax));
return targetDLTxPower;
}
/// <summary>
/// 获取同站的小区列表
/// </summary>
/// <param name="list"></param>
/// <param name="tempList"></param>
/// <param name="currentCell"></param>
private void GetCellsInTheSameSite(List<UMTSSimCell> list, List<UMTSSimCell> tempList,UMTSSimCell currentCell)
{
foreach (UMTSSimCell cell in list)
{
bool flag = (currentCell.NECell.Parent.Parent == cell.NECell.Parent.Parent && !tempList.Contains(cell));
if (flag)
{
tempList.Add(cell);
}
}
}
/// <summary> /// 获得每个小区中的服务用户数 /// </summary> /// <param name="cell"></param> /// <returns></returns> protected abstract int GetServedUserNum(UMTSSimCell cell,LinkType linkType);
/// <summary>
/// 计算下行链路损耗
/// </summary>
/// <param name="cell"></param>
/// <param name="user"></param>
private float CalcDLLinkLoss(UMTSSimCell cell, UMTSSimUser user, bool flag)
{
float DLloss = m_LinkLoss.GetDLLinkLoss(cell, user, flag);
DLloss = (float)UnitTrans.dBto(DLloss);
return DLloss;
}
/// <summary>
/// 计算噪声
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
private float CalcNoise(UMTSSimCell cell, UMTSSimUser user)
{
////背景噪声＝噪声功率谱密度×带宽×噪声系数
float N = (float)UnitTrans.dBmTomw(m_UIParam.ThermalNoise) * 3840000 * (float)UnitTrans.dBmTomw(user.Terminal.NoiseFigure);
return N;
}
private void CalcUserEbNo(UMTSSimCell cell, UMTSSimUser user)
{
user.DLLoss = CalcDLLinkLoss(cell, user, true);
if (user.IsScheduledInTTI)
{
user.Ior = CalcDLIntraIntf(cell, user);
user.AverageIor += user.Ior;
user.Ioc = CalcUMTSInterIntf(cell, user) + user.DlInterfFromOtherSystemCell;
user.AverageIoc += user.Ioc;
user.No = CalcNoise(cell, user);
user.Io = user.Ior + user.Ioc + user.No;
user.AverageIo += user.Io;
user.EbNo = HSDPA_CommonCalc.CalculateCIR(user.AssignedPower, user.Io, user.DLLoss);
}
}
/// <summary>
/// 判断是否会因为小区干扰受限而不能调度
/// </summary>
/// <param name="cell"></param>
/// <param name="user"></param>
/// <returns></returns>
private bool JudgeNoiseRise(UMTSSimCell cell, UMTSSimUser user)
{
UMTSTerminal terminal = user.TrafficUser.Terminal.GetNetWorkTerminal(NetWorkType.UMTS) as UMTSTerminal;
UnionPsService service = user.TrafficUser.Service as UnionPsService;
float newCellRxPower = (float)(UnitTrans.dBto(m_HSUPA_BearerSelector.FindEcNtByBearIndex(user.HSUPABearer)) * user.HSUPA_Nt);
if (newCellRxPower > cell.HSUPA_NotUsedPower)
{
return false;
}
return true;
}
private void OperateAfterSuccessedSchedule(UMTSSimCell cell, UMTSSimUser user)
{
//user.LastSchedulingRate = user.SchedulingRate;
user.IsScheduledInTTI = true;
float linkloss = (float)UnitTrans.dBto(m_CommonParams.ServiceProvider.LinkLossCalc.GetLinkLoss(
NetWorkType.UMTS, cell.NECell.ID, user.TrafficUser.Id, LinkType.Uplink));
float fastloss = (float)UnitTrans.dBto(m_CommonParams.ServiceProvider.FastFadingCalc.GetFastFadingdB(cell, user, LinkType.Uplink));
user.TxPower = (float)UnitTrans.dBto(m_HSUPA_BearerSelector.FindEcNtByBearIndex(user.HSUPABearer)) * user.HSUPA_Nt * (linkloss + fastloss);
cell.HSUPA_UsedRxPower += (float)UnitTrans.dBto(m_HSUPA_BearerSelector.FindEcNtByBearIndex(user.HSUPABearer)) * user.HSUPA_Nt;
if (user.Tti == m_CommonParams.TTI2)
{
//user.HSUPA_ShortTTINum++;
user.ServedTimeSlotNum++;
}
int waitTTINum = m_CommonParams.CurTTIIndex - user.LastServerdTTI;
if (user.LastServerdTTI<0)
{
waitTTINum = m_CommonParams.CurTTIIndex;
}
user.CSUserWaitDelay.Add(waitTTINum);
user.LastServerdTTI = (short)m_CommonParams.CurTTIIndex;
user.WaitTime = 0;
}
