示例#1
0
 private float CalculatePFGainValue(IUlScheduleUser uUser, IUlScheduleUser vUser, ref float sinrU, ref float sinrV)
 {
     this.m_Random = new Random();
     int num3 = this.m_Random.Next(GlobalParameter.getInstance().m_ChannelCoefficientList.Count - 1);
     float num4 = GlobalParameter.getInstance().m_ChannelCoefficientList[num3];
     float num = SimulationTools.ConvertdBToLine(uUser.FinalSinr);
     float ulMcsEff = uUser.UlMcsEff;
     float num2 = SimulationTools.ConvertdBToLine(UlScheduleTools.GetUserAvgSinr(vUser, base.CurTTI) + vUser.RandomSinr);
     sinrU = num * (1f - ((num4 * num4) * (num2 / (num2 + 1f))));
     sinrV = num2 * (1f - ((num4 * num4) * (num / (num + 1f))));
     sinrU = SimulationTools.ConvertLineTodB(sinrU);
     sinrV = SimulationTools.ConvertLineTodB(sinrV);
     float mcsBySinr = UlScheduleTools.GetMcsBySinr(uUser, sinrU);
     float eff = UlScheduleTools.GetMcsBySinr(vUser, sinrV);
     float num8 = UlScheduleTools.calBETBS(uUser, mcsBySinr, (float)uUser.UlRbNum, uUser.MIMOClutterGain);
     float num9 = UlScheduleTools.calBETBS(vUser, eff, (float)uUser.UlRbNum, vUser.MIMOClutterGain);
     float num10 = UlScheduleTools.calBETBS(uUser, ulMcsEff, (float)uUser.UlRbNum, uUser.MIMOClutterGain);
     if ((uUser.ActualAvgBr > 0f) && (vUser.ActualAvgBr > 0f))
     {
         float num11 = ((num8 / uUser.ActualAvgBr) + (num9 / vUser.ActualAvgBr)) - (num10 / uUser.ActualAvgBr);
         if (num11 > 0f)
         {
             return num11;
         }
     }
     return float.MinValue;
 }
示例#2
0
 public float NormalRandomSinr(IUlScheduleUser user)
 {
     float num2;
     double num3;
     double num5;
     double num6;
     float num = 0f;
     if ((user.BestServiceCarrier.AlgParameter.UlFreqSelOn && (user.LTEUser.Mobility.MeanSpeed <= SimulationConstant.UL_FS_USER_SPEED_THRESHOLD)) && (user.PreScheduleTime != -1))
     {
         num2 = SimulationConstant.UL_deviation_2;
     }
     else
     {
         num2 = SimulationConstant.UL_deviation_1;
     }
     do
     {
         num3 = (this.m_random.NextDouble() * 2.0) - 1.0;
         double num4 = (this.m_random.NextDouble() * 2.0) - 1.0;
         num5 = (num3 * num3) + (num4 * num4);
     }
     while (num5 >= 1.0);
     if (num5 < 0.0001)
     {
         num6 = 0.0;
     }
     else
     {
         num6 = num3 * ((float) Math.Sqrt((-2.0 * Math.Log(num5)) / num5));
     }
     return Convert.ToSingle((double) (num + (num2 * num6)));
 }
示例#3
0
 /// <summary>
 /// 计算用户所需最大的Rb值,综合考虑用户的功率控制以及当前的数据块所需的Rb
 /// </summary>
 /// <param name="isFreqSelUser"></param>
 /// <param name="user"></param>
 /// <param name="curTTI"></param>
 /// <param name="carrierResidualRb"></param>
 /// <param name="userAvgSinr"></param>
 /// <param name="mcsEff"></param>
 /// <returns></returns>
 private int CalUserMaxRBNum(ref bool isFreqSelUser, IUlScheduleUser user, int curTTI, int carrierResidualRb, float userAvgSinr, ref float mcsEff)
 {
     int num2 = 0;
     //UserPC根据功控获得用户Rb个数
     int bEUserAllowRbNum = UlScheduleTools.GetBEUserAllowRbNum(UlScheduleTools.GetUserPC(user));
     if ((mcsEff <= 0f) || (bEUserAllowRbNum < 1))
     {
         isFreqSelUser = false;
         user.IsSinrAdjusted = false;
     }
     else
     {
         mcsEff = this.CalMcs(isFreqSelUser, user, userAvgSinr);
     }
     float beTBS = UlScheduleTools.CalcTBSAvailable(user, curTTI);
     if (mcsEff <= 0f)
     {
         num2 = 0;
     }
     else
     {
         //计算根据数据块获得所需Rb值
         num2 = UlScheduleTools.calRBbyTBS(user, mcsEff, beTBS, user.MIMOClutterGain);
     }
     return Math.Min(Math.Min(Math.Min(bEUserAllowRbNum, num2), carrierResidualRb), SimulationConstant.UL_MAX_RB_NUM);
 }
示例#4
0
 protected void UpdateUserRbInfo(IUlScheduleUser user, List<byte> rbIndexs)
 {
     foreach (byte num in rbIndexs)
     {
         this.SimulationCarrier.UlRbUserDic.Add(num, user);
     }
 }
示例#5
0
 /// <summary>
 /// 根据传输快大小计算所需Rb
 /// </summary>
 /// <param name="ulScheduleUser"></param>
 /// <param name="eff"></param>
 /// <param name="beTBS"></param>
 /// <param name="MIMOClutterGain"></param>
 /// <returns></returns>
 public static int calRBbyTBS(IUlScheduleUser ulScheduleUser, float eff, float beTBS, float MIMOClutterGain)
 {
     if (SimulationConstant.IS_HARQ_ON)
     {
         return (int) Math.Ceiling((double) ((SimulationConstant.CRC_NUM + ((beTBS * 1000f) / MIMOClutterGain)) / (((1f - ulScheduleUser.ULBLER) * SimulationConstant.UL_RBRE_NUM) * eff)));
     }
     return (int) Math.Ceiling((double) ((SimulationConstant.CRC_NUM + ((beTBS * 1000f) / MIMOClutterGain)) / (SimulationConstant.UL_RBRE_NUM * eff)));
 }
示例#6
0
 /// <summary>
 /// 保存未调度用户信息
 /// </summary>
 /// <param name="user"></param>
 /// <param name="userList"></param>
 protected void SaveNoneScheduledUser(IUlScheduleUser user, List<ISimulationUser> userList)
 {
     user.MacTBS = 0f;
     user.realScheduleTBS = 0f;
     user.RbList.Clear();
     user.State = State.Wait;
     userList.Add(user);
 }
示例#7
0
 public byte GetNonFreqSelUserBeginSbIndex(IUlScheduleUser user, ScheduleResource res)
 {
     if (user.IsEdgeUser)
     {//ÈôÊDZßÑØÓû§Ôò¡¤¡¤¡¤
         return this.GetFirstEdgeIndex(user, res);
     }
     return this.GetFirstCenterIndex(res);
 }
示例#8
0
 public static float calBETBS(IUlScheduleUser ulScheduleUser, float eff, float RbNum, float MIMOClutterGain)
 {
     if (SimulationConstant.IS_HARQ_ON)
     {
         return (((float) Math.Floor((double) ((((((1f - ulScheduleUser.ULBLER) * SimulationConstant.UL_RBRE_NUM) * RbNum) * eff) - SimulationConstant.CRC_NUM) * MIMOClutterGain))) / 1000f);
     }
     return (((float) Math.Floor((double) ((((SimulationConstant.UL_RBRE_NUM * RbNum) * eff) - SimulationConstant.CRC_NUM) * MIMOClutterGain))) / 1000f);
 }
示例#9
0
 /// <summary>
 /// 判断是否可以进行调度,功控信噪比减去用户Rb所需值后一定大于0才能被调度。Why??
 /// </summary>
 /// <param name="user"></param>
 /// <param name="residualRb"></param>
 /// <param name="needRbNum"></param>
 /// <param name="measureSinr"></param>
 /// <param name="eff"></param>
 /// <returns></returns>
 private bool CanAssignUserRes(IUlScheduleUser user, int residualRb, ref int needRbNum, ref float measureSinr, ref float eff)
 {
     double num = -1.0;
     if (residualRb >= needRbNum)
     {
         num = this.IsPowerHeadroomOrMcsEffBear(user, ref needRbNum, ref measureSinr, ref eff, residualRb);//Todo···
     }
     return (num >= 0.0);
 }
示例#10
0
 private void AssortUser(IUlScheduleUser user, int curTTI, List<IUlScheduleUser> lessThanGBRList, List<IUlScheduleUser> lessThanNonGBRList, List<IUlScheduleUser> GBRHappyList, List<IUlScheduleUser> NonGBRHappyList, List<IUlScheduleUser> nonScheduledList)
 {
     if (user.PreScheduleTime == -1)
     {
         nonScheduledList.Add(user);
     }
     else if (!user.IsVMIMOUser)
     {
         this.AssortServicedUser(user, curTTI, lessThanGBRList, lessThanNonGBRList, GBRHappyList, NonGBRHappyList);
     }
 }
示例#11
0
 private void AssortUser(int curTTI, List<IUlScheduleUser> accessUserList, List<IUlScheduleUser> noPacketUserList, IUlScheduleUser user)
 {
     if (user.PreScheduleTime == -1)
     {
         accessUserList.Add(user);
     }
     else if (!user.IsTTIBunlingUser)
     {
         this.AssortServicedUser(curTTI, accessUserList, noPacketUserList, user);
     }
 }
示例#12
0
 private void AssortServicedUser(int curTTI, List<IUlScheduleUser> accessUserList, List<IUlScheduleUser> noPacketUserList, IUlScheduleUser user)
 {
     if (((curTTI - user.PreScheduleTime) % SimulationConstant.UL_VIOCE_SERVICE_PERIOD) == 0)
     {
         accessUserList.Add(user);
     }
     else
     {
         noPacketUserList.Add(user);
     }
 }
示例#13
0
 private void AssortUserByAvgBr(IUlScheduleUser user, List<IUlScheduleUser> lessThanAvgBr, List<IUlScheduleUser> moreThanAvgBr, float minThroughputDemand)
 {
     if (user.ActualAvgBr < minThroughputDemand)
     {
         lessThanAvgBr.Add(user);
     }
     else
     {
         moreThanAvgBr.Add(user);
     }
 }
示例#14
0
 public byte GetFreqSelUserBeginSbIndex(IUlScheduleUser user, ScheduleResource res, IUlSchuduleCarrier carrier)
 {
     if (user.IsSameSiteEdgeUser)
     {
         return this.GetSelSSiteEdgeBeginRbIndex(res, carrier);
     }
     if (user.IsEdgeUser)
     {
         return this.GetSelDSiteEdgeBeginRbIndex(res, carrier);
     }
     return this.GetSelCenterBeginSbIndex(res, carrier);
 }
示例#15
0
 protected void AssortUser(int curTTI, List<IUlScheduleUser> scheduledList, List<IUlScheduleUser> nonScheduledList, List<IUlScheduleUser> noPacketUserList, IUlScheduleUser user)
 {
     ScheduleUser ulScheduleUserTag = user.UlScheduleUserTag as ScheduleUser;
     if (user.PreScheduleTime == -1)
     {
         nonScheduledList.Add(user);
     }
     else if (!user.IsTTIBunlingUser)
     {
         this.AssortServicedUser(user, curTTI, scheduledList, noPacketUserList);
     }
 }
示例#16
0
 /// <summary>
 /// 计算Mcs编码增益,如果是频选用户需要加UL_OFFSET_OF_FS_TO_NONFS
 /// </summary>
 /// <param name="isFreqSelUser"></param>
 /// <param name="user"></param>
 /// <param name="userAvgSinr"></param>
 /// <returns></returns>
 private float CalMcs(bool isFreqSelUser, IUlScheduleUser user, float userAvgSinr)
 {
     float naN = float.NaN;
     if (isFreqSelUser)
     {
         naN = (userAvgSinr + user.RandomSinr) + SimulationConstant.UL_OFFSET_OF_FS_TO_NONFS;
     }
     else
     {
         naN = userAvgSinr + user.RandomSinr;
     }
     return UlScheduleTools.GetMcsBySinr(user, naN);
 }
示例#17
0
 private void AssortServicedUser(IUlScheduleUser user, int curTTI, List<IUlScheduleUser> lessThanGBRList, List<IUlScheduleUser> lessThanNonGBRList, List<IUlScheduleUser> GBRHappyList, List<IUlScheduleUser> NonGBRHappyList)
 {
     UnionPsService unionPsService = SimulationTools.GetUnionPsService(user.LTEUser.Service);
     LTEService service2 = unionPsService.PSServiceDic[NetWorkType.LTE] as LTEService;
     if (service2.IsGBR)
     {
         this.AssortUserByAvgBr(user, lessThanGBRList, GBRHappyList, unionPsService.UlMinThroughputDemand);
     }
     else
     {
         this.AssortUserByAvgBr(user, lessThanNonGBRList, NonGBRHappyList, user.UlMacMinThroughputDemand);
     }
 }
示例#18
0
 public static UlResAssignOutput FreqUserExpandRB(IUlScheduleUser user, IUlSchuduleCarrier carrier, ScheduleResource res, byte beginRbIndex, int userMaxRbNum, int tti)
 {
     List<byte> rbs = new List<byte>();
     List<byte> centerRbs = new List<byte>();
     List<byte> edgeRbs = new List<byte>();
     res.RbLists[0].ForEach(delegate (RBData rb) {
         centerRbs.Add(rb.Index);
     });
     res.RbLists[1].ForEach(delegate (RBData rb) {
         edgeRbs.Add(rb.Index);
     });
     rbs.AddRange(centerRbs);
     rbs.AddRange(edgeRbs);
     rbs.Sort();
     List<byte> list2 = new List<byte>();
     list2.Add(beginRbIndex);
     res.RemoveRbRes(beginRbIndex);
     int idxLeft = rbs.FindIndex(delegate (byte rbIndex) {
         return rbIndex == beginRbIndex;
     });
     int idxRight = idxLeft;
     bool flag = list2.Count < userMaxRbNum;
     bool canLeftExpand = true;
     bool canRightExpand = true;
     while (flag)
     {
         float maxValue = float.MaxValue;
         float inRight = float.MaxValue;
         canLeftExpand = (canLeftExpand && (idxLeft >= 1)) && (Math.Abs((int) (rbs[idxLeft - 1] - rbs[idxLeft])) == 1);
         if (canLeftExpand)
         {
             maxValue = carrier.UlRbInterferenceNoiseList[rbs[idxLeft - 1]];
         }
         canRightExpand = (canRightExpand && (idxRight <= (rbs.Count - 2))) && (Math.Abs((int) (rbs[idxRight + 1] - rbs[idxRight])) == 1);
         if (canRightExpand)
         {
             inRight = carrier.UlRbInterferenceNoiseList[rbs[idxRight + 1]];
         }
         byte num5 = GetExpandRbIndex(canLeftExpand, canRightExpand, ref idxLeft, ref idxRight, maxValue, inRight, rbs);
         if (num5 == 0xff)
         {
             break;
         }
         res.RemoveRbRes(num5);
         list2.Add(num5);
         flag = list2.Count < userMaxRbNum;
     }
     UlResAssignOutput output = new UlResAssignOutput();
     output.RbIndexs = list2;
     return output;
 }
示例#19
0
 private void AdjustSinr(IUlScheduleUser user, ref int needRbNum, ref float measureSinr, ref float eff, int residualRb, float userPc, ref double delta)
 {
     int rbNum = Convert.ToInt32(Math.Min((double) SimulationConstant.CARRIER_MAX_BANDWIDTH_RBNUM, Math.Ceiling((double) UlScheduleTools.ConvertdBToLine((measureSinr + userPc) - user.UlSinrTarget))));//Todo···
     float voicePacketSize = user.VoicePacketSize;
     if (rbNum <= residualRb)
     {
         delta = this.TryAdjust(rbNum, user, userPc, voicePacketSize, ref measureSinr, ref eff, ref needRbNum);
     }
     else
     {
         float mcsBySinr = UlScheduleTools.GetMcsBySinr(user, user.UlSinrTarget);
         delta = this.IsTBSMeet(user, voicePacketSize, user.UlSinrTarget, mcsBySinr, residualRb, ref measureSinr, ref eff, ref needRbNum);
     }
 }
示例#20
0
 /// <summary>
 /// 根据用户的优先级进行降序排序
 /// </summary>
 /// <param name="userA"></param>
 /// <param name="userB"></param>
 /// <returns></returns>
 public static int CompareUserPriority(IUlScheduleUser userA, IUlScheduleUser userB)
 {
     ScheduleUser ulScheduleUserTag = userA.UlScheduleUserTag as ScheduleUser;
     ScheduleUser user2 = userB.UlScheduleUserTag as ScheduleUser;
     if (ulScheduleUserTag.Priority > user2.Priority)
     {
         return -1;
     }
     if (ulScheduleUserTag.Priority < user2.Priority)
     {
         return 1;
     }
     return 0;
 }
示例#21
0
 public byte GetFreqSelUserBeginSbIndex(IUlScheduleUser user, ScheduleResource res, IUlSchuduleCarrier carrier)
 {
     byte index = res.RbLists[0][0].Index;
     float maxValue = float.MaxValue;
     List<float> ulRbInterferenceNoiseList = carrier.UlRbInterferenceNoiseList;
     for (int i = 0; i < res.RbLists[0].Count; i++)
     {
         float num3 = ulRbInterferenceNoiseList[res.RbLists[0][i].Index];
         if (maxValue > num3)
         {
             maxValue = num3;
             index = res.RbLists[0][i].Index;
         }
     }
     return index;
 }
示例#22
0
 /// <summary>
 /// 计算用户所需最大的Rb值,综合考虑用户的功率控制以及当前的数据块所需的Rb
 /// </summary>
 /// <param name="isFreqSelUser"></param>
 /// <param name="user"></param>
 /// <param name="curTTI"></param>
 /// <param name="carrierResidualRb"></param>
 /// <param name="userAvgSinr"></param>
 /// <param name="mcsEff"></param>
 /// <returns></returns>
 private int CalUserMaxRBNum(IUlScheduleUser user, int curTTI, int carrierResidualRb, ref float relayBuff, float userAvgSinr, ref float mcsEff)
 {
     int rbNum = 0;
     //UserPC根据功控获得用户Rb个数
     //这个地方有疑问,尚待研究Edited By liangwenli 20110428
     //int bEUserAllowRbNum = UlScheduleTools.GetBEUserAllowRbNum(UlScheduleTools.GetUserPC(user));
     int bEUserAllowRbNum = UlScheduleTools.GetBEUserAllowRbNum(UlScheduleTools.GetUserPC(user));
     if ((mcsEff <= 0f) || (bEUserAllowRbNum < 1))
     {
         user.IsSinrAdjusted = false;
     }
     else
     {
         mcsEff = this.CalMcs(user, userAvgSinr);
     }
     float beTBS = UlScheduleTools.CalcTBSAvailable(user, curTTI);
     //relauBuff不为-1则说明是relay在调度用户,此时要考虑relay缓冲区大小
     if (relayBuff != -1)
     {
         if (relayBuff == 0)
         {
             return 0;         //缓冲区满则不调度
         }
         beTBS = Math.Min(beTBS, relayBuff);         //将缓冲区剩余大小与用户待传数据取较小值,作为用户要传输的数据量
     }
     if (mcsEff <= 0f)
     {
         rbNum = 0;
     }
     else
     {
         //计算根据数据块获得所需Rb值
         rbNum = UlScheduleTools.calRBbyTBS(user, mcsEff, beTBS, user.MIMOClutterGain);
     }  
    
     rbNum = Math.Min(Math.Min(Math.Min(bEUserAllowRbNum, rbNum), carrierResidualRb), SimulationConstant.UL_MAX_RB_NUM);
     
      //relauBuff不为-1则说明是relay在调度用户,此时要更新relay缓冲区大小
     if (relayBuff != -1)
     {
         float usedBuff = UlScheduleTools.calBETBS(user, mcsEff, rbNum, user.MIMOClutterGain);
         usedBuff = Math.Min(usedBuff, beTBS);                       //实际传输的数据量应该是请求的数据量,以及根据最小RB所能传输数据量中的较小值。
         this.SimulationCarrier.RelayUlUsedBuffer += usedBuff;
         relayBuff -= usedBuff;
     }
     return rbNum;
 }
示例#23
0
 //Todo···计算还有多少TBS存在
 public static float CalcTBSAvailable(IUlScheduleUser user, int TTI)
 {
     float num4;
     float ulMacMaxThroughputDemand = user.UlMacMaxThroughputDemand;
     float totalTBS = user.TotalTBS;
     float num3 = (SimulationConstant.UL_TIME_WINDOW * ulMacMaxThroughputDemand) / 1000f;
     if (user.UlGBRDegrateTTI > 0)
     {
         float num5 = user.BestServiceCarrier.UlGBRUserPriorityDic[user.LTEUser.Priority] * ulMacMaxThroughputDemand;
         num4 = ((ulMacMaxThroughputDemand * ((user.UlGBRDegrateTTI - user.AccessTti) + 1)) + (num5 * (TTI - user.UlGBRDegrateTTI))) - totalTBS;
         num3 = (SimulationConstant.UL_TIME_WINDOW * num5) / 1000f;
     }
     else
     {
         num4 = ((ulMacMaxThroughputDemand * ((TTI - user.AccessTti) + 1)) / 1000f) - totalTBS;
     }
     float num6 = num3 - (totalTBS - user.TimeWindowTotalTBS);
     return Math.Min(num4, num6);
 }
示例#24
0
 /// <summary>
 /// 判断是否需要启动TTI捆绑调度,判断标准首先要是AMR编码方式一种,功控信噪比大于6.02则不需要启动
 /// </summary>
 /// <param name="user"></param>
 /// <param name="measureSinr"></param>
 /// <param name="userPc"></param>
 /// <returns></returns>
 private bool IsNeedTTIBundling(IUlScheduleUser user, float measureSinr, float userPc)
 {
     List<float> list = new List<float>();
     UnionPsService unionPsService = SimulationTools.GetUnionPsService(user.LTEUser.Service);
     if (!TTIBundlingThreshold.AMRCodeRateList.Contains(unionPsService.UlAveThroughputDemand))
     {
         return false;
     }
     list = TTIBundlingThreshold.TTI_BUNDLING_THRESHOLD_Dic[unionPsService.UlAveThroughputDemand];
     float maxValue = float.MaxValue;
     float minValue = float.MinValue;
     int num3 = this.CalIndexByUserPc(userPc);
     if (num3 != -1)
     {
         maxValue = list[num3] - 4.8f;
         minValue = list[num3] - 1f;
     }
     return ((measureSinr <= minValue) && (measureSinr >= maxValue));
 }
示例#25
0
 private byte GetFirstEdgeIndex(IUlScheduleUser user, ScheduleResource res)
 {
     byte num = 0;
     if (res.RbLists[1].Count > 0)
     {
         return res.RbLists[1][0].Index;
     }
     if (res.RbLists[0].Count <= 0)
     {
         return num;
     }
     int count = res.RbLists[0].Count;
     ISimulationCarrier sfSbStroNbr = user.SfSbStroNbr;
     if (this.ResConflict(user, sfSbStroNbr))
     {
         return res.RbLists[0][0].Index;
     }
     return res.RbLists[0][count - 1].Index;
 }
示例#26
0
 public static List<byte> AssignRBLocation(IUlScheduleUser user, ScheduleResource res, byte beginIndex, int userMaxRbNumM)
 {
     int num2;
     int num3;
     List<RBData> list = new List<RBData>(res.RbLists[1]);
     list.Reverse();
     list.InsertRange(0, res.RbLists[0]);
     List<byte> list2 = new List<byte>();
     int num = 1;
     list2.Add(beginIndex);
     if (list[0].Index == beginIndex)
     {
         num2 = 0;
         num3 = 1;
     }
     else
     {
         num2 = list.Count - 1;
         num3 = -1;
     }
     res.RemoveRbRes(beginIndex);
     for (num = 2; num <= userMaxRbNumM; num++)
     {
         if ((((num2 + num3) >= 0) && ((num2 + num3) < list.Count)) && (((list[num2].Index + 1) == list[num2 + num3].Index) || ((list[num2].Index - 1) == list[num2 + num3].Index)))
         {
             num2 += num3;
             byte index = list[num2].Index;
             list2.Add(index);
             res.RemoveRbRes(index);
         }
         else
         {
             return list2;
         }
     }
     return list2;
 }
示例#27
0
 private float CalMoreThanBrUser(IUlScheduleUser user)
 {
     return (user.UlMacMaxThroughputDemand * user.BestServiceCarrier.UlGBRUserPriorityDic[user.LTEUser.Priority]);
 }
示例#28
0
 public abstract float GetUserPriority(IUlScheduleUser user, int TTI);
示例#29
0
 private bool ResConflict(IUlScheduleUser iUlScheduleUser, ISimulationCarrier carrier)
 {
     if (null == carrier)
     {
         return false;
     }
     if (!carrier.IsUlIcicOn)
     {
         return false;
     }
     int ulEdgeUserFreNum = (int) carrier.AlgParameter.UlEdgeUserFreNum;
     int num2 = (int) iUlScheduleUser.BestServiceCarrier.AlgParameter.UlEdgeUserFreNum;
     return m_ICICMatrix[num2, ulEdgeUserFreNum];
 }
示例#30
0
 public override float GetUserPriority(IUlScheduleUser user, int TTI)
 {
     return (((SimulationTools.GetServicePriority(user.LTEUser.Service) * user.LTEUser.Priority) * (user.PuschSinr - user.BestServiceCarrier.DLRsSinrAccessThreshold)) * (user.VoiceContinueLost + 1));
 }