public void initial()
{
m_user1 = MockTDSimUser.CreatTDSimUser_CSDL();
m_user2 = MockTDSimUser.CreatTDSimUser_CSUL();
m_user3 = MockTDSimUser.CreatTDSimUser_PSDL();
m_user4 = MockTDSimUser.CreatTDSimUser_PSUL();
m_user5 = MockTDSimUser.CreatTDSimUser_PSDL();
m_UnAccessedUsers = new List<TDSimUser>();
m_Cell1 = MockTDSimCell.CreatTDSimCell();
m_Cell1.CarrType = CarrierTypeOfTD.R4;
m_Cells=new List<TDSimCell>();
m_Cells.Add(m_Cell1);
m_Tran = new TDSimTran(m_Cells);
initialUser(m_user1, m_Cell1, m_Tran);
initialUser(m_user2, m_Cell1, m_Tran);
initialUser(m_user3, m_Cell1, m_Tran);
initialUser(m_user4, m_Cell1, m_Tran);
m_Carrier1 = new TDSCDMACarrier();
m_Transceiver = new Transceiver();
m_R4_CellAssign = new R4_CellAssign();
}
/// <summary>
/// 获取当前用户的ServiceCell的当前时隙的可用功率
/// </summary>
/// <param name="tsnum">时隙号</param>
/// <param name="user">当前用户</param>
/// <returns></returns>
public static float GetAvailablePower(TS tsNum, TDSimUser user)
{
float usedPower = user.ServiceCell.Slots[(int)tsNum].CurPower;//单位为db值
float maxCellPower = user.ServiceCell.Slots[(int)tsNum].MaxPowerforR4;//小区R4最大的发射功率（具体的取值跟功率分配策略有关：静态功率分配，动态功率分配），单位为db值
float result = (float)UnitTrans.dBto(maxCellPower) - (float)UnitTrans.dBto(usedPower);//单位为线性值
return (float)UnitTrans.todB(Math.Abs(result));
}
[TestInitialize()]//初始化
public void MyTestInitialize()
{
ue = MockUPAUser.CreateUPAuser();
cell = MockUPAcell.CreatUPACell();
ue.ServiceCell = cell;
target = new UserManager(3, 3, 3);//MaxLossTTi,MinCIR,FastLossRemain
}
private float CalcSuccUser(TDSimUser ue)
{
float tsinterf = 0;
foreach (TimeSlot ts in ue.UETimeSlot)
{
tsinterf += CalcTsInterf(ue, ts);
}
tsinterf /= ue.UETimeSlot.Count;
return tsinterf;
}
/// <summary>
/// 初始化上行用户链路
/// </summary>
/// <param name="user">用户</param>
/// <param name="nt">用户的终端类型</param>
/// <param name="linkParam">用户所在的链路的信息</param>
private void InitUlLinkParam(TDSimUser user, TSLinkParam linkParam)
{
float ulTotalLoss = m_LossCalc.GetULTotalLoss(user, user.ServiceCell);
float bsSensitivity = CalcBsSensitivity(user);
float gain = m_SmartGain.GetSmartAntMainGain(user);
float ulTxPower = ulTotalLoss + bsSensitivity - gain;
ulTxPower = Math.Max(ulTxPower, user.MinTxPower);
linkParam.TxPower = Math.Min(ulTxPower, user.MaxTxPower);
linkParam.BsRxPower = linkParam.TxPower - ulTotalLoss + gain;
}
/// <summary>
/// 初始化上行信道功率,上行移动端的发射功率，基站端的接收功率
/// </summary>
/// <param name="user"></param>
private void InitULPower(TDSimUser user)
{
foreach (KeyValuePair<TS, TSLinkParam> tsParam in user.LinkSet)
{
TSLinkParam linkParam = tsParam.Value;
InitUlLinkParam(user, linkParam);
float tempCurrPower = user.ServiceCell.Slots[(int)tsParam.Key].CurPower;
float adjPower = linkParam.BsRxPower;
user.ServiceCell.Slots[(int)tsParam.Key].CurPower = (float)UnitTrans.AdddB(tempCurrPower, adjPower);
}
}
private float CalcUnSuccUser(TDSimUser ue)
{
float tsinterf = 0;
//for (int i = 1; i <= ue.ServiceCell.SwitchPoint; i++)
foreach(TimeSlot ts in ue.ServiceCell.HSUPATimeSlots)
{
tsinterf += CalcTsInterf(ue, ts);
}
tsinterf /= ue.ServiceCell.HSUPATimeSlots.Count;
return tsinterf;
}
/// <summary>
/// 根据用户接入的成功与否，来区别用户
/// </summary>
/// <param name="usr"></param>
/// <returns></returns>
private GeoPointStyle FindAccessSituByUser(TDSimUser usr)
{
if (usr.ServiceCell != null)
{
return m_SS.Styles[0];
}
else
{
return m_SS.Styles[1];
}
}
/// <summary>
/// 根据用户的链路方向来区别用户
/// </summary>
/// <param name="usr"></param>
/// <returns></returns>
public GeoPointStyle FindLinkSituByUser(TDSimUser usr)
{
if (usr.LinkDirection == LinkType.Uplink)
{
return m_SS.Styles[0];
}
else
{
return m_SS.Styles[1];
}
}
/// <summary>
/// 对一个用户作接纳控制
/// </summary>
/// <param name="user">作接纳控制的用户</param>
/// <returns>接入成功返回true；否则返回false</returns>
private bool Assign(TDSimUser user)
{
//if (user.TrafficCell.Count == 0)
//{
// user.FailReason = FailReason.RscpFail;
// return false;
//}
m_Slots = new List<TimeSlot>();
SortSlot(user.ServiceCell, user.LinkDirection);
return m_Access.Excute(user, m_Slots);
}
public void MyTestInitialize()
{
TDSimCell cell = null;
TimeSlot[] slots = new TimeSlot[7];
m_TDSimUser = MockTDSimUser.CreatTDSimUser_PSUL();
cell = MockTDSimCell.CreatTDSimCell();
m_TDSimUser.ServiceCell = cell;
slots = MockTDSlots.CreatSlots();
cell.Slots = slots;
}
/// <summary>
/// 初始化业务信道的功率
/// </summary>
/// <param name="user"></param>
private void InitPowerForOneUser(TDSimUser user)
{
if (user.LinkDirection == LinkType.Uplink)
{
InitULPower(user);
user.IsNew = false;
}
else
{
InitDLPower(user);
user.IsNew = false;
}
}
public AssignCellTest()
{
maxLoad = 10;
target = new AssignCell(maxLoad);
user = MockUPAUser.CreateUPAuser();
List<TDSimCell> celllist = new List<TDSimCell>();
celllist.Add(cella);
celllist.Add(cellb);
TDSimTran tdtran = new TDSimTran(celllist);
user.PrimeCell = cella;
}
//构造使用CS业务的TD用户
public static TDSimUser CreatTDSimUser_CS()
{
User user=CreatUser_CS();
TDSimUser tdSimUser = new TDSimUser(user);
tdSimUser.InitialR4();
//tdSimUser.LinkSet = MockTDLinkSetDictionary.CreatTSLinkSetDictionary();
tdSimUser.TargetEbNo = 10;
tdSimUser.BackNoise = 3;
tdSimUser.PG = 3;
tdSimUser.ServiceCell = MockCell.CreatTDSimCell();
return tdSimUser;
}
/// <summary>
/// 计算用户的激活集
/// </summary>
/// <param name="user"></param>
public bool CalculateActive(TDSimUser user)
{
m_ActiveCell = SelectTryAssignCell(user);
if (m_ActiveCell == null)
{
user.FailReason = FailReason.RscpFail;
return false;
}
float Io = (float)UnitTrans.todB(m_CalcEcIo.GetIo(user, user.PrimeCell));
float EcIo = user.Rscp - Io;
user.Ecio = EcIo;
return true;
}
public void initial()
{
user=MockTDSimUser.CreatTDSimUser_CSDL();
m_AccessUsers = new List<TDSimUser>();
m_PreUsers = new List<TDSimUser>();
m_UnAccessUsers = new List<TDSimUser>();
m_Param = new TDCalcCommonParam();
m_AccessUsers.Add(user);
m_PreUsers.Add(user);
m_UnAccessUsers.Add(user);
m_Param.R4AccessUsers=m_AccessUsers;
m_Param.R4PreUsers=m_PreUsers;
m_Param.R4UnAccessUsers=m_UnAccessUsers;
m_Update=new UpdateDataForOneIteration(m_Param);
}
public void MyInit()
{
m_cell1 = CreatTDCell(3);
m_PreCells = new List<TDSimCell>();
m_PreCells.Add(m_cell1);
m_user1 = MockTDSimUser.CreatTDSimUser_CSDL();
m_user2 = MockTDSimUser.CreatTDSimUser_PSUL();
m_user2.ServiceCell = null;
m_PreUsers = new List<TDSimUser>();
m_PreUsers.Add(m_user1);
m_PreUsers.Add(m_user2);
m_ss = new StyleStruct();
m_VecData = new R4SimulationVectorData(m_PreCells, m_PreUsers, m_ss);
}
public void Initial()
{
m_Param = new TDCalcCommonParam();
m_Param.CalcLinkLoss = new MockTDLinkLossCalc();
m_Param.SmartAntGain = new MockSmartAntCalcGain();
m_User = MockTDSimUser.CreatTDSimUser_CSDL();
m_Cell = MockTDSimCell.CreatTDSimCell();
m_Cell.IsMainCarrier = true;
m_CellList = new List<TDSimCell>();
m_CellList.Add(m_Cell);
m_ActiveCellConfirm = new ActiveCellConfirm(m_CellList);
m_ActiveCellConfirm.CommonParam = m_Param;
}
/// <summary>
/// 遍历时隙,计算用户受到的干扰，db值
/// </summary>
/// <param name="ue"></param>
public void CalcUserInterf(TDSimUser ue)
{
//内部都用线性值计算，最后返回DB值
float totalinterf = 0;
float tsinterf = 0;
if (ue.IsSheduleSuccess)
{
tsinterf = CalcSuccUser(ue);
}
else
{
tsinterf = CalcUnSuccUser(ue);
}
//float GsmInterf = CalcGSMInterf(ue);
//float UmtsInterf = CalcUMTSInterf(ue);
totalinterf = tsinterf + (float)UnitTrans.dBmTomw(ue.OtherSystemIntef);
//ue.OtherSystemIntef = (float)UnitTrans.todB(GsmInterf + UmtsInterf);
ue.TotalIntef = (float)UnitTrans.todB(totalinterf);
}
public void MyTestInitialize()
{
m_SimUser1=MockTDSimUser.CreatTDSimUser_CSDL();
m_SimUser2 = MockTDSimUser.CreatTDSimUser_CSUL();
m_IntefUser = MockTDSimUser.CreatTDSimUser_PSDL();
m_Param = new TDCalcCommonParam();
m_Param.SmartAntGain = new MockSmartAntCalcGain();
m_Cell = MockTDSimCell.CreatTDSimCell();
m_User = MockTDSimUser.CreatUser_CSDL();
m_SmartAntGain = new SmartAntGain(m_Param.SmartAntGain);
//LinkLossAssist.Init();
//m_TDCalcCommonParam = new TDCalcCommonParam();
//m_TDCalcCommonParam.SmartAntGain = new MockSmartAntCalcGain();
//m_TDSimUser = MockTDSimUser.CreatTDSimUser_CS();
//m_IntefUser = MockTDSimUser.CreatTDSimUser_PS();
//m_TDSimCell = MockTDSimCell.CreatTDSimCell();
//m_SmartAntGain = new SmartAntGain(m_TDCalcCommonParam.SmartAntGain);
}
private TDSimCell SelectTryAssignCell(TDSimUser user)
{
m_CalcEcIo = new EcIoCaculation(m_CommonParam);
List<TDSimCell> bestCellsInCalcRadius = GetCellsInCalcRadius(user);
TDSimCell bestCell = null;
float rscp = m_CommonParam.TdUIParam.RSCPThreshold;
foreach (TDSimCell cell in bestCellsInCalcRadius)
{
float tempRscp = (float)(UnitTrans.todB(m_CalcEcIo.GetEc(user, cell)));
if ( rscp <= tempRscp)
{
rscp = tempRscp;
bestCell = cell;
}
}
user.Rscp = rscp;
user.PrimeCell = bestCell;
return bestCell;
}
/// <summary>
/// 计算干扰
/// 为了实现接口
/// </summary>
/// <param name="user"></param>
/// <param name="txPower">对该用户的发射功率</param>
/// <returns></returns>
public float CalcInterfereVale(TDSimUser user, TS indexOfTimeslot)
{
float iOwn = CalculateCurInterference(user, indexOfTimeslot);
if (float.IsNegativeInfinity(iOwn))
{
iOwn = TimeSlot.HSDPAZeroPower;
}
float iOther = CalculateNeighborInterference(user, indexOfTimeslot);
if (float.IsNegativeInfinity(iOther))
{
iOther = TimeSlot.HSDPAZeroPower;
}
float N = user.ServiceCell.BackNoise_DB;
float result = AddPower(iOwn, iOther, N);
return result;
}
/// <summary>
/// 初始化DPA的用户
/// </summary>
/// <param name="user"></param>
private void InitialDPAUser(TDSimUser user)
{
TDTerminal temp = (TDTerminal)(user.TrafficUser.Terminal.GetNetWorkTerminal(NetWorkType.TDSCDMA));
UnionPsService psService = user.TrafficUser.Service as UnionPsService;
//
//add by lcguo
//
//TODO:暂时这么做，以后要通过terminal取
temp.TDHsdpaUeCategory = new TDHSDPAUECategory();
//temp.TDHsdpaUeCategory.UECategoryIndex = 1;
//temp.TDHsdpaUeCategory.MaxHSPDSCHNum = 16;
//temp.TDHsdpaUeCategory.MaxBlockSize = 2788;
//temp.TDHsdpaUeCategory.MaxHSPDSCHTS = 2;
//temp.TDHsdpaUeCategory.Modulation = 0;
//
//
//
if (temp.TDHsdpaUeCategory == null)
{
user.HSDPAMaxDataSpeed = 0;
}
else
{
//hsdpa 使用的最大传输速率是终端定义的终端最大传输能力支持的速率，这里的单位是bit
float terminalSurpportMaxRate = temp.TDHsdpaUeCategory.MaxBlockSize;
//最大的业务速率
float maxServiceData = HSDPAConvertor.Convert_DataSpeed_To_BlockSizeInTTI(psService.DlMaxThroughputDemand);
user.HSDPAMaxDataSpeed = Math.Min(terminalSurpportMaxRate, maxServiceData);
}
user.ApplicationDataSpeed = HSDPAConvertor.Convert_DataSpeed_To_BlockSizeInTTI(psService.DlAveThroughputDemand);
user.HSDPAArgDataSpeed = HSDPAConvertor.Convert_DataSpeed_To_BlockSizeInTTI(psService.DlAveThroughputDemand);
user.HSDPAMinDataSpeed = HSDPAConvertor.Convert_DataSpeed_To_BlockSizeInTTI(psService.DlMinThroughputDemand);
user.HSDPATransDataSizeInTTI = 0;
user.HSDPATransDataSize = 0;
user.CIR = user.Ecio+10;
//暂时初始化为ec/io列表的第一个值，某次调试下的值为13.66
}
/// <summary>
/// 计算上行同频本小区干扰
/// </summary>
/// <param name="user"></param>
/// <param name="tsnum"></param>
/// <param name="link"></param>
/// <returns>上行同频本小区干扰，单位为线性值</returns>
public float CalcULIntraIntf(TDSimUser user, TS tsNum)
{
float totalIntef = 0.0f;
TimeSlot slot = user.ServiceCell.Slots[(int)tsNum];
foreach (TDSimUser intfUser in slot.AccessedUsers)
{
//为该用户自己，自己的功率不算做干扰功率
if (intfUser == user)
{
continue;
}
else
{
float ulTotalLoss = m_TotalLoss.GetULTotalLoss(intfUser
, user.ServiceCell);
float sASideGain = m_SmartAnt.GetSmartAntSideGain(user, intfUser, LinkType.Uplink);
totalIntef += (float)UnitTrans.dBmTomw(intfUser.LinkSet[tsNum].TxPower - ulTotalLoss + sASideGain);
}
}
return totalIntef;
}
/// <summary>
/// 计算上行同频邻小区干扰
/// </summary>
/// <param name="user"></param>
/// <param name="tsnum"></param>
/// <param name="link"></param>
/// <returns>上行同频邻小区干扰，单位为线性值</returns>
public float CalcULInterInf(TDSimUser user, TS tsNum)
{
float totalIntef = 0.0f;
List<TDSimCell> intefCells = GetSameIntefCells(user);
foreach (TDSimCell cell in intefCells)
{
if (cell != user.ServiceCell)
{
if (cell.Slots[(int)tsNum].LinkDirection != user.ServiceCell.Slots[(int)tsNum].LinkDirection)
{
continue;
}
foreach (TDSimUser intfUser in cell.Slots[(int)tsNum].AccessedUsers)
{
float ulTotalLoss = m_TotalLoss.GetULTotalLoss(intfUser, user.ServiceCell);
float gain = m_SmartAnt.GetSmartAntSideGain(user, intfUser, LinkType.Uplink);
totalIntef += (float)UnitTrans.dBmTomw(intfUser.LinkSet[tsNum].TxPower - ulTotalLoss + gain);
}
}
}
return totalIntef;
}
private void ScheduleInCodeCategory(TDSimUser user, TDSimCell tdCell)
{
int NotAssignedCodeNum = 0;
int CanAssignedCodeNum=0;
CanAssignedCodeNum = GetRemainCodeNumInTs(tdCell);
if (user.BearerAndResouceRatio.CodeNum > CanAssignedCodeNum)
{
user.FailReason = FailReason.HSDPAScheduleFailed;
}
else
{
NotAssignedCodeNum = Math.Min(CanAssignedCodeNum, user.BearerAndResouceRatio.CodeNum);
foreach (TimeSlot ts in tdCell.HSDPATimeslot)
{
if ((ts.HSDPARemainCENum == 0)||(ts.CodeDictonary .Count >ts.HSDPAMaxTSServicedNum ))
{
continue;
}
else
{
if (ts.HSDPARemainCodeNum< NotAssignedCodeNum)
{
NotAssignedCodeNum -= ts.HSDPARemainCodeNum;
ts.HSDPAConsumedCENum = ConstantParam.RUNumInOneTimeslot;
ts.HSDPARemainCodeNum = 0;
ts.HSDPAConsumedPower = tdCell.TxPowerPerCode * ts.HSDPAConsumedCodeNum ;
ts.HSDPARemainPower = 0;
ts.HSDPAScheduledUsers.Add(user);
user.CodeDictonary.Add( ts.TsNum,ts.HSDPAConsumedCENum);
ts.CodeDictonary.Add( user,ts.HSDPAConsumedCodeNum);
}
else
{
ts.HSDPAConsumedCENum += NotAssignedCodeNum;
ts.HSDPARemainCodeNum -= NotAssignedCodeNum;
ts.HSDPAConsumedPower = tdCell.TxPowerPerCode * ts.HSDPAConsumedCodeNum;
ts.HSDPARemainPower -= ts.HSDPAConsumedPower;
NotAssignedCodeNum = 0;
ts.HSDPAScheduledUsers.Add(user);
user.CodeDictonary.Add(ts.TsNum,ts.HSDPAConsumedCENum);
ts.CodeDictonary.Add( user,ts.HSDPAConsumedCodeNum);
}
}
}
user.HSDPAAssignPower = tdCell.TxPowerPerCode * user.BearerAndResouceRatio.CodeNum;
user.IsFirstServed = false;
user.HSDPAAssignCodeNum = user.BearerAndResouceRatio.CodeNum;
user.HSDPANumSlotServedPerTTI = user.CodeDictonary.Count;
tdCell.HSDPAServedUserList.Add(user);
user.HSDPATotalNumSlotServed += 1;
}
}
private void ScheduleInTsCategory(TDSimUser user, TDSimCell tdCell)
{ int ScheduleTsNum=0;
int needAssignedNum=user .BearerAndResouceRatio .CodeNum ;
foreach (TimeSlot ts in tdCell.HSDPATimeslot)
{
if (ts.IsTimeSlotScheduled == true)//判断时隙是否
{
continue;
}
else
{
if (needAssignedNum < ConstantParam.RUNumInOneTimeslot)
{
ts.HSDPAConsumedCodeNum = needAssignedNum;
ts.HSDPARemainCodeNum = ConstantParam.RUNumInOneTimeslot - ts.HSDPAConsumedCodeNum;
ts.HSDPAConsumedPower = tdCell.TxPowerPerCode * needAssignedNum;
ts.HSDPARemainPower = tdCell.HSDPAPower - ts.HSDPAConsumedPower;
ts.HSDPAScheduledUsers.Add(user);
user.CodeDictonary.Add(ts.TsNum, ts.HSDPAConsumedCENum);
ts.CodeDictonary.Add( user,ts.HSDPAConsumedCodeNum);
ts.IsTimeSlotScheduled = true;
user.HSDPAAssignCodeNum += needAssignedNum;
break;
}
else
{
ScheduleTsNum ++;
needAssignedNum -=ConstantParam .RUNumInOneTimeslot ;
ts.HSDPAConsumedCodeNum = ConstantParam.RUNumInOneTimeslot;
ts.HSDPARemainCodeNum = 0;
ts.HSDPAConsumedPower = tdCell.HSDPAPower;
ts.HSDPARemainPower = 0;
ts.HSDPAScheduledUsers.Add(user);
ts.IsTimeSlotScheduled = true;
ts.CodeDictonary.Add( user,ts.HSDPAConsumedCodeNum);
user.CodeDictonary.Add( ts.TsNum,ts.HSDPAConsumedCENum);
user.HSDPAAssignCodeNum += ConstantParam.RUNumInOneTimeslot;
}
}
}
user.IsFirstServed =false ;
user.HSDPAAssignPower = tdCell.TxPowerPerCode * user.HSDPAAssignCodeNum ;
user.HSDPANumSlotServedPerTTI = user.CodeDictonary.Count;
user.HSDPATotalNumSlotServed += 1;
tdCell.HSDPAServedUserList.Add(user) ;
tdCell.HSDPARemainTSNum -= user.BearerAndResouceRatio.TsNum;
}
private void JudegeScheduleCategory(TDSimUser user, TDSimCell tdCell, ref bool isCanSchedule, ref bool TsSchedule, BearerAndResouceRatio bestBearerContainer)
{
if (tdCell.HSDPARemainTSNum > 0)
{
isCanSchedule = true;
TsSchedule = true;
user.BearerAndResouceRatio.TsNum = Math.Min(bestBearerContainer.TsNum, tdCell.HSDPATsNum);
}
if ((tdCell.HSDPARemainTSNum == 0) && (m_IsCDMAon == true))
{
isCanSchedule = true;
TsSchedule = false;
user.BearerAndResouceRatio.CodeNum = Math.Min(bestBearerContainer.CodeNum, tdCell.HSDPACodeNum);
}
else
{ }
}
/// <summary>
/// 检查当前时隙是否可用
/// </summary>
/// <param name="scheduledTS"></param>
/// <param name="ts"></param>
/// <returns></returns>
//private bool CheckTSAvailable(List<TimeSlot> scheduledTS, TimeSlot ts)
//{
// bool check = true;
// if (ts.HSDPARemainCodeNum == 0)
// {
// check = false;
// }
// if (ts.HSDPARemainPower <= TimeSlot.HSDPAProtectedPower - float.Epsilon)
// {
// check = false;
// }
// //添加ce控制
// //在初始化网元的地方加入ce资源的初始化，需要r4提供剩余的ce个数，并用该个数初始化dpa使用的ce资源。
// //在timeslot中定义hsdpa使用的最大ce个数
// //这里的判断就是当调度到得用户数小于等于最大的ce个数时，不再调度后面的用户
// if (ts.HSDPARemainCENum <= 0)
// {
// check = false;
// }
// if (ts.HSDPARemainSCCHNum <= 0)
// {
// check = false;
// }
// #region 检查该时隙是否已经被调度过(需考察是否还需要)
// if (scheduledTS.Contains(ts))
// {
// check = false;
// }
// return check;
// #endregion
//}
/// <summary>
/// 以码资源多少，对服务用户的小区的时隙进行排序，码资源多的放在前面
/// </summary>
/// <param name="user"></param>
/// <returns>返回该小区排好序的时隙</returns>
//private List<TimeSlot> SortCarrierTimeSlot(TDSimUser user)
//{
// TDSimCell cell = user.ServiceCell;
// List<TimeSlot> sortList = new List<TimeSlot>();
// sortList.AddRange(cell.HSDPATimeslot);
// int indexRange = sortList.Count - 1;
// while (indexRange > 0)
// {
// for (int index = 0; index < indexRange; index++)
// {
// int compare = SlotCompareByCode(sortList[index], sortList[index + 1]);
// ExchangeSlot(sortList, index, compare);
// }
// indexRange--;
// }
// return sortList;
//}
/// <summary>
/// 将剩余资源最小的时隙往列表的后面排
/// </summary>
/// <param name="server"></param>
/// <param name="index"></param>
/// <param name="compare"></param>
//private void ExchangeSlot(List<TimeSlot> sortList, int index, int compare)
//{
// if (compare < 0)
// {
// TimeSlot temp = sortList[index];
// sortList[index] = sortList[index + 1];
// sortList[index + 1] = temp;
// }
//}
/// <summary>
/// 按码资源比较两个时隙
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
//private int SlotCompareByCode(TimeSlot x, TimeSlot y)
//{
// if (x.HSDPARemainCodeNum < y.HSDPARemainCodeNum)
// {
// return -1;
// }
// else if (x.HSDPARemainCodeNum > y.HSDPARemainCodeNum)
// {
// return 1;
// }
// else
// {
// return 0;
// }
//}
///// <summary>
/// 判断用户是否具有调度资格
/// （考察用户支持的最小传输间隔和服务小区接入的DPA用户数有没有达到上线）
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
private bool AdjustScheduleQualification(TDSimUser user,TDSimCell tdcell)
{
bool isCanSchedule = true ;
if ((tdcell .HSDPARemainTSNum <1)&&(m_IsCDMAon ==false ))
{
isCanSchedule = false ;
}
if ((tdcell .HSDPANumScch <1)||(tdcell .HSDPACodeNum <1))
{
isCanSchedule = false;
}
if (user.ApplicationDataSpeed < 0)
{
isCanSchedule = false;
}
return isCanSchedule;
}
/////// <summary>
/////// 将承载上的定义的ci值转换成目标ci值(该计算公式有华为给出)
/////// </summary>
/////// <param name="bearerCIValue"></param>
/////// <param name="codeNum"></param>
/////// <returns></returns>
////private double GetTargetCIFromBearerCI(double bearerCIValue, int codeNum)
////{
//// return bearerCIValue;
////}
///// <summary>
///// 为重传用户分配承载
///// </summary>
///// <param name="user"></param>
///// <returns></returns>
//private BearerAndResouceRatio BestBearerForRetransmitedUser(TDSimUser user, BearerAndResouceRatio bestBearerContainer)
//{
// if (user.IsHSDPARetransmited )
// {
// //bestBearerContainer = bestBearerContainerRemain;
// user.IsHSDPARetransmited = false;
// //m_IsCodeLimited = false;
// }
// //对重传用户配置bestBearerContainer参数
// else if (user.IsHSDPARetransmited == true)
// {
// bestBearerContainer = new BearerAndResouceRatio();
// bestBearerContainer.Bearer = user.HSDPABingdingBearer;
// bestBearerContainer.CodeNum = user.HSDPAAssignCodeNum;
// bestBearerContainer.PowerAssign = user.HSDPAAssignPower;
// user.IsHSDPARetransmited = false;
// }
// //如果是非重传用户，那么就把承载直接返回
// return bestBearerContainer;
//}
/// <summary>
/// 分配资源
/// </summary>
/// <param name="scheduleSlot"></param>
/// <param name="user"></param>
//private void ScheduleResource(TDSimCell tdCell, TimeSlot scheduleSlot, TDSimUser user, float powerAssigned,
// int codeNumAssigned)
//{
// //if (scheduleSlot != null)
// //{
// if (!tdCell.HSDPAServedUserList.Contains(user))
// {
// tdCell.HSDPAServedUserList.Add(user);
// }
// scheduleSlot.HSDPAScheduledUsers.Add(user);
// scheduleSlot.HSDPARemainCENum--;
// scheduleSlot.HSDPARemainPower = (float)(UnitTrans.mwTodBm(UnitTrans.dBmTomw(scheduleSlot.HSDPARemainPower) -
// UnitTrans.dBmTomw(powerAssigned)));
// scheduleSlot.HSDPARemainCodeNum -= codeNumAssigned;
// scheduleSlot.HSDPARemainSCCHNum--;
// scheduleSlot.HSDPAConsumedPower = (float)(UnitTrans.mwTodBm(UnitTrans.dBmTomw(scheduleSlot.HSDPAConsumedPower) +
// UnitTrans.dBmTomw(powerAssigned)));
// scheduleSlot.HSDPAConsumedCodeNum += codeNumAssigned;
// scheduleSlot.HSDPAConsumedCENum++;
// user.HSDPAAssignCodeNum = codeNumAssigned;
// user.HSDPAAssignPower = powerAssigned;
// user.HSDPATotalNumSlotServed++;
// user.HSDPANumSlotServedPerTTI++;
// user.IsFirstServed = false;
// //}
//}
/// <summary>
/// 从可用的BearList里面找到最合适的承载
/// </summary>
/// <param name="bearerToUse"></param>
/// <param name="ts"></param>
/// <returns></returns>
//private BearerAndResouceRatio FindBestBear(List<BearerAndResouceRatio> bearerToUse, TimeSlot ts)
//{
// BearerAndResouceRatio bestBearerContainer = new BearerAndResouceRatio();
// double standardResouceRatio = BearerAndResouceRatio.CalculateResouceRatio(ts.HSDPARemainPower,
// ts.HSDPARemainCodeNum);
// double detector = double.MaxValue;
// foreach (BearerAndResouceRatio bearerContainer in bearerToUse)
// {
// if (bearerContainer.CodeNum <= 0)
// {
// continue;
// }
// double distance = Math.Abs(standardResouceRatio - bearerContainer.ResouceRatio);
// if (detector > distance)
// {
// detector = distance;
// bestBearerContainer = bearerContainer;
// }
// }
// return bestBearerContainer;
//}
///// <summary>
/// 是否为该用户找到了可用的承载列表
/// </summary>
/// <param name="user"></param>
/// <param name="bearerToUse">已经包装好的可用的承载列表</param>
/// <param name="ts"></param>
/// <returns>是否为该用户找到了可用的承载列表</returns>
private bool CalcBearerList(TDSimUser user, ref List<BearerAndResouceRatio> bearerToUse, TDSimCell tdcell)
{
bool isFindBearer = false;
float lastPower = user.HSDPAAssignPower;
double userCIValue = double.MinValue;
List<TDHSDPABearer> bearerList = new List<TDHSDPABearer>();
if (lastPower > tdcell .HSDPAAssignedPower )
{
//判断上一次的功率与当前剩余的所有功率之间的大小
//如果剩余功率小于上一次分配的功率，则将剩余功率全部都给该用户，
//并用该功率除以上一次的干扰，得到一个ci，用这个ci来查找承载，确定码字
userCIValue = tdcell .HSDPAAssignedPower - m_GetTDLinkLoss.GetDLTotalLoss(user, user.ServiceCell) - user.HSDPAInterfere;
bearerList = this.m_AMCArithmetic.SelectBearerForUser(userCIValue, user.HSDPAMinDataSpeed);
//承载表中无法找到相应的承载
if (bearerList == null || bearerList.Count == 0)
{
//下一次用在什么地方？
user.CIR += 0.5f;
}
else
{
this.InitialBearerAndResouceRatioList(ref bearerToUse, bearerList);
isFindBearer = true;
}
}
else
{
this.m_AMCArithmetic.SelectCandidateList(user);
//承载表中无法找到相应的承载
if (user.HSDPABearerCandidateList == null || user.HSDPABearerCandidateList.Count == 0)
{
user.CIR += 0.5f;
}
else
{
this.InitialBearerAndResouceRatioList(ref bearerToUse, user.HSDPABearerCandidateList);
isFindBearer = true;
}
}
return isFindBearer;
}
