/// <summary>
/// 计算下行接收功率
/// </summary>
private void CalcDLRxPower(GSMSimUser user)
{
float loss = m_GetLinkLoss.GetLinkLoss(NetWorkType.GSM, user.BestServer.Cell.ID, user.TrafficUser.Id, LinkType.Downlink);
foreach (GSMTimeSlot ts in user.DlTs)
{
float trxTxPower;
if (ts.CurDLTxPower.ContainsKey(user))
{
trxTxPower = ts.CurDLTxPower[user];
}
else if (ts.PreDLTxPower.ContainsKey(user))
{
trxTxPower = ts.PreDLTxPower[user];
}
else
{
trxTxPower = user.DlTs[0].Parent.NeTRX.TRXPower;
}
float rxPower = trxTxPower - loss - m_InterfPara.PwrReBack;
if (user.DLRxPower.ContainsKey(ts))
{
user.DLRxPower[ts] = rxPower;
}
else
user.DLRxPower.Add(ts, rxPower);
}
}
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>
/// 下行Ps初始化
/// </summary>
/// <param name="user"></param>
private void InitPsDlPower(GSMSimUser user)
{
foreach (GSMTimeSlot ts in user.DlTs)
{
ts.PreDLTxPower.Add(user, user.BestServer.NeTRX.MaxPower);
}
}
/// <summary>
/// 单个用户数据信道分配,返回信道是否分配成功
/// </summary>
private bool APsUserAllocation(GSMSimUser user)
{
m_Terminal = user.TrafficUser.Terminal.GetNetWorkTerminal(NetWorkType.GSM) as GSMTerminal;
if (m_Terminal.Technology == GsmTechnologyType.GSM)
{
return false;
}
InitUserParam(user);
int shareNum = m_IsDl ? m_ChnAllocation.DLShareNum : m_ChnAllocation.ULShareNum;
//寻找空闲的静态PDCH信道
List<GSMTimeSlot> emptyPDCH = HasStaticEmpty(user);
//分配信道
EmptyChnAllc(user, emptyPDCH);
if (IsUnderMultiTs(user) & GetUserRate(user) < m_PsReqRate)
{
//寻找小于复用动态门限的PDCH信道（TCH->PDCH）
emptyPDCH = HasEmptyTs(user, m_ChnAllocation.DynamicMultiplexNum,true);
EmptyChnAllc(user, emptyPDCH);
}
if (IsUnderMultiTs(user) & GetUserRate(user) < m_PsReqRate)
{
//寻找小于复用门限的所有PDCH信道
emptyPDCH = HasEmptyTs(user, shareNum,false);
EmptyChnAllc(user, emptyPDCH);
}
if (GetUserRate(user) > m_PsAssureRate)
{
return true;
}
else
{
ClearUserData(user);
return false;
}
}
/// <summary>
/// 获取一个GSM用户到各个制式的总路损
/// </summary>
/// <param name="user"></param>
/// <param name="carrier"></param>
/// <param name="isDL"></param>
/// <returns></returns>
public float GetAllLoss(GSMSimUser user, ISimCellBase carrier, NetWorkType netType, bool isDL)
{
if (isDL)
return m_GetLinkLoss.GetLinkLoss(netType, carrier.Cell.ID, user.TrafficUser.Id, LinkType.Downlink);
else
return m_GetLinkLoss.GetLinkLoss(netType, carrier.Cell.ID, user.TrafficUser.Id, LinkType.Uplink);
}
public void Inital()
{
m_User = MockGSMSimUser.CreateGSMSimUser();
m_IGetLinkloss = new MockIGetLinkloss();
totalLinkLoss = new TotalLossCalc(m_IGetLinkloss);
interfPara = new InterfCalcPara();
interfCalc = new MockIInterfCalc();
m_TchCalc = new TCHInterfCalc();
}
/// <summary>
/// 寻找可用的TRX
/// </summary>
/// <param name="user">用户</param>
/// <param name="isCalcDLBCCH"></param>
/// <param name="isDL"></param>
/// <returns></returns>
public GSMSimTRX FindUsefulTrx(GSMSimUser user,bool isCalcDLBCCH,bool isDL)
{
if (isCalcDLBCCH)
return user.BestServer;
if (isDL)
return user.DlTs[0].Parent;
else
return user.UlTs[0].Parent;
}
public void MyInitial()
{
m_IGetLinkloss = new MockIGetLinkloss();
m_TotalLossCalc = new TotalLossCalc(m_IGetLinkloss);
m_InterfCalc = new MockIInterfCalc();
m_InterfPara = new InterfCalcPara();
m_DlBCCHCIR = new DLBCCHCIR(m_IGetLinkloss, m_InterfPara, m_InterfCalc);
//InitialUser();
m_User = MockGSMSimUser.CreateGSMSimUser();
}
/// <summary>
/// 初始化Ps上行
/// </summary>
/// <param name="user"></param>
private void InitPsUlPower(GSMSimUser user)
{
float trxAllowMaxPwr = user.BestServer.NeTRX.MsMaxPower;
float termimalMaxPwr = user.TrafficUser.Terminal.GetNetWorkTerminal(NetWorkType.GSM).MaxTxPower;
float Power = Math.Min(trxAllowMaxPwr, termimalMaxPwr);
foreach (GSMTimeSlot ts in user.UlTs)
{
user.PreULTxPower.Add(ts, Power);
}
}
public void CalcOtherNetBCCHIMP3(GSMSimUser user)
{
m_IsCalcDLBCCH = true;
m_IsDL = true;
GSMSimTRX userTRX = FindUsefulTrx(user, true, true);
if (user.TrafficUser.LinkType == LinkType.Uplink)
{
CalcBCCHOtherNetIMP3(user);
}
}
/// <summary>
/// 单个用户功率控制
/// </summary>
/// <param name="simUser"></param>
private void AUserPowerCtrl(GSMSimUser simUser)
{
if (simUser.IsCs)
{
CsPowerCtrl(simUser);
}
else
{
PsPowerCtrl(simUser);
}
}
/// <summary>
/// 单个用户功率初始化
/// </summary>
/// <param name="users">已接入的单个用户</param>
public void InitTxPower(GSMSimUser user,IGetLinkloss linkLoss)
{
if (user.TrafficUser.LinkType == LinkType.Uplink )
{
InitUlPower(user, linkLoss);
}
else
{
InitDlPower(user,linkLoss);
}
}
/// <summary>
/// 计算TCH背景噪声
/// </summary>
/// <param name="user"></param>
/// <param name="isDL"></param>
public void CalcBgNoise(GSMSimUser user, bool isDL)
{
if (isDL)
{
DLNoise(user);
}
else
{
ULNoise(user);
}
}
/// <summary>
/// 初始化下行用户的功率
/// </summary>
/// <param name="user"></param>
private void InitDlPower(GSMSimUser user,IGetLinkloss linkLoss)
{
if (user.TrafficUser.Service.CommonType == CommonServiceType.CSService)
{
//InitCsDlPower(user,linkLoss);
}
else
{
InitPsDlPower(user);
}
}
/// <summary>
/// 计算接收功率
/// </summary>
private void CalcRxPower(GSMSimUser user, bool isDL)
{
if (isDL)
{
user.DLInterf.Clear();
CalcDLRxPower(user);//计算用户下行接受功率
}
else
{
user.ULInterf.Clear();
//CalcULTxPower(user);//计算用户上行发射功率
}
}
/// <summary>
/// 计算BCCH信道异制式干扰
/// </summary>
/// <param name="user"></param>
public void CalcBCCHOtherNetInterf(GSMSimUser user)
{
GSMSimTRX userTRX = FindUsefulTrx(user, true, true);
List<ISimCellBase> umtsNeighborList = userTRX.UMTSInterCell;
for (int i = 0; i < umtsNeighborList.Count; i++)
{
CalcOtherNetOneSrcInterf(user, true, false, umtsNeighborList[i], NetWorkType.UMTS);
}
List<ISimCellBase> tdNeighborList = userTRX.TDInterCell;
for (int i = 0; i < tdNeighborList.Count; i++)
{
CalcOtherNetOneSrcInterf(user, true, false, tdNeighborList[i], NetWorkType.TDSCDMA);
}
}
/// <summary>
/// 计算TCH信道异制式干扰
/// </summary>
/// <param name="user"></param>
/// <param name="isDL"></param>
public void CalcTCHOtherNetInterf(GSMSimUser user, bool isDL)
{
GSMSimTRX userTrx = FindUsefulTrx(user, false, isDL);
List<ISimCellBase> umtsNeighborList = userTrx.UMTSInterCell;
for (int i = 0; i < umtsNeighborList.Count; i++)
{
CalcOtherNetOneSrcInterf(user, false, isDL, umtsNeighborList[i], NetWorkType.UMTS);
}
List<ISimCellBase> tdNeighborList = userTrx.TDInterCell;
for (int i = 0; i < tdNeighborList.Count; i++)
{
CalcOtherNetOneSrcInterf(user, false, isDL, tdNeighborList[i], NetWorkType.TDSCDMA);
}
}
/// <summary>
/// CIR计算入口
/// </summary>
/// <param name="user"></param>
/// <param name="isDL"></param>
public void Calc(GSMSimUser user, bool isDL)
{
CalcRxPower(user, isDL);
GSMInterfCalc interfCalc = new GSMInterfCalc(m_GetLinkLoss, m_InterfCalc);
interfCalc.CalcTCHInterf(user, isDL, m_InterfPara);
//float totalInterf = float.NegativeInfinity;
if (isDL)
{
//totalInterf = CalcTotalDLInterf(user, totalInterf);
CalcDLCir(user);
}
else
{
//totalInterf = CalcTotalULInterf(user, totalInterf);
CalcULCir(user);
}
}
public static GSMSimUser MockGsmPsSimUser()
{
User trafficUser = new User();
trafficUser.Service = new MockService();
trafficUser.Service.CommonType = CommonServiceType.PSService;
GSMSimUser user = new GSMSimUser(trafficUser);
GSMSimTRX trx1 = MockGsmSimTrx();
user.BestServer = trx1;
user.BestServer.NeTRX.TRXType = TRXType.BCCH;
user.BestServer.CellUsers = new List<GSMSimUser>();
GSMPsService gsmPsService = new GSMPsService();
UnionPsService psService = new UnionPsService();
psService.PSServiceDic.Add(NetWorkType.GSM, gsmPsService);
user.TrafficUser.Service = psService;
GSMTerminal gsmTerminal = new GSMTerminal();
gsmTerminal.NetType = NetWorkType.GSM;
Terminal terminal = new Terminal();
terminal.Technology = NetWorkType.GSM;
terminal.NetTerminalList.Add(gsmTerminal);
user.TrafficUser.Terminal = terminal;
Site site = MockSite();
Transceiver tran = new Transceiver();
user.BestServer.Parent = tran;
user.BestServer.Parent.Parent = site;
//Dictionary<GSMTimeSlot, float> dlInterf = new Dictionary<GSMTimeSlot, float>();
//Dictionary<GSMTimeSlot, float> dlcirs = new Dictionary<GSMTimeSlot, float>();
////Dictionary<GSMTimeSlot, float> preUlTxPower = new Dictionary<GSMTimeSlot, float>();
//for (int i = 0; i < 8; i++)
//{
// dlcirs.Add(TSes[i], 15 + i * 2);
//}
//user.DlCirs = dlcirs;
//user.PreULTxPower = preUlTxPower;
return user;
}
/// <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="simUser"></param>
/// <param name="powerError"></param>
private void CsHasPowerCtrl(GSMSimUser simUser)
{
if (simUser.TrafficUser.LinkType == LinkType.Uplink)
{
ULPowerCtrl(simUser);
}
else
{
DLPowerCtrl(simUser);
}
}
/// <summary>
/// 数据业务上行功率控制
/// </summary>
private void PsULPowerCtrl(GSMSimUser simUser)
{
foreach (GSMTimeSlot timeSlot in simUser.UlTs)
{
//if (simUser.PreULTxPower.ContainsKey(timeSlot))
//{
// if (simUser.CurULTxPower.ContainsKey(timeSlot))
// {
// simUser.CurULTxPower[timeSlot] = simUser.PreULTxPower[timeSlot];
// }
// else
// {
simUser.CurULTxPower.Add(timeSlot, simUser.PreULTxPower[timeSlot]);
//}
//simUser.ULTxPower[timeSlot] = simUser.PreULTxPower[timeSlot];
//}
}
}
/// <summary>
/// 数据业务功控
/// </summary>
/// <param name="simUser"></param>
private void PsPowerCtrl(GSMSimUser simUser)
{
if (simUser.UlTs.Count != 0)
{
PsULPowerCtrl(simUser);
}
else
{
PsDLPowerCtrl(simUser);
}
}
public static float CalcIdealCIR(GSMSimUser simUser)
{
float sinrTh;
if (simUser.ServiceType == CSServiceType.AFS)
{
sinrTh = (PowerControlConst.AFSDLQualityDownLimit + PowerControlConst.AFSDLQualityUpLimit) / 2;
}
else if (simUser.ServiceType == CSServiceType.AHS)
{
sinrTh = (PowerControlConst.AHSDLQualityDownLimit + PowerControlConst.AHSDLQualityUpLimit) / 2;
}
else if (simUser.ServiceType == CSServiceType.HS)
{
sinrTh = (PowerControlConst.HSDLQualityDownLimit + PowerControlConst.HSDLQualityUpLimit) / 2;
}
else
{
sinrTh = (PowerControlConst.FSEFSDLQualityDownLimit + PowerControlConst.FSEFSDLQualityUpLimit) / 2;
}
return sinrTh;
}
public static void CalcULStep(GSMSimUser simUser)
{
float sinrTh = PowerControlCommonCalc.CalcIdealCIR(simUser);
float stepOne = PowerControlConst.StepOneDLPwrFactor * (simUser.ULFilterRxPower - PowerControlConst.ULReqRXPower) + PowerControlConst.StepOneDLCirFactor * (simUser.ULFilterCIR - sinrTh);
float stepTwo = PowerControlConst.StepTwoDLPwrFactor * (simUser.ULFilterRxPower - PowerControlConst.ULReqRXPower) + PowerControlConst.StepTwoDLPwrFactor * (simUser.ULFilterCIR - sinrTh);
if ((Math.Max(stepOne, stepTwo) - simUser.ULPowerStep) < PowerControlConst.ULPwrMaxDownStep)
{
simUser.ULPowerStep = simUser.ULPowerStep + PowerControlConst.ULPwrMaxDownStep;
}
else if ((Math.Max(stepOne, stepTwo) - simUser.ULPowerStep) > PowerControlConst.ULPwrMaxUpStep)
{
simUser.ULPowerStep = simUser.ULPowerStep + PowerControlConst.ULPwrMaxUpStep;
}
else
{
simUser.ULPowerStep = Math.Max(stepOne, stepTwo);
}
}
/// <summary>
/// 语音业务下行功率控制
/// </summary>
/// <param name="simUser"></param>
private void DLPowerCtrl(GSMSimUser simUser)
{
//取补偿功率
float compensatePwr = simUser.DlTs[0].Parent.NeTRX.MaxPower - simUser.DlTs[0].PreDLTxPower[simUser];
m_TchCir.Calc(simUser, true);
if (simUser.IsFirstServed)
{
simUser.DLFilterCIR = PowerControlCommonCalc.CalcIdealCIR(simUser);
simUser.DLFilterRxPower = PowerControlConst.DLReqRXPower;
}
float length_CirFilter = (simUser.DlCirs[simUser.DlTs[0]] + compensatePwr < simUser.DLFilterCIR) ? 3 : 9;
float alpha_SCir = (1.012f * length_CirFilter - 0.7505f) / (1.848f + length_CirFilter);
simUser.DLFilterCIR=alpha_SCir*simUser.DlCirs[simUser.DlTs[0]]+(1-alpha_SCir)*simUser.DLFilterCIR;
float length_RxPowerFliter = (simUser.DLRxPower[simUser.DlTs[0]] + compensatePwr < simUser.DLFilterRxPower) ? 3 : 9;
float alpha_RxPower = (1.012f * length_RxPowerFliter - 0.7505f) / (1.848f + length_RxPowerFliter);
simUser.DLFilterRxPower = alpha_RxPower * simUser.DLRxPower[simUser.DlTs[0]] + (1 - alpha_RxPower) * simUser.DLFilterRxPower;
PowerControlCommonCalc.CalcDLStep(simUser);
float requestDLPower = simUser.DlTs[0].Parent.NeTRX.MaxPower - simUser.DLPowerStep;
requestDLPower = Math.Min(requestDLPower, simUser.DlTs[0].Parent.NeTRX.MaxPower);
requestDLPower = Math.Max(requestDLPower, simUser.DlTs[0].Parent.NeTRX.MinPower);
//simUser.DLRxPower[simUser.DlTs[0]] = requestDLPower;
simUser.DlTs[0].CurDLTxPower.Add(simUser, requestDLPower);
}
/// <summary>
/// 语音业务上行功率控制
/// </summary>
/// <param name="simUser"></param>
private void ULPowerCtrl(GSMSimUser simUser)
{
float simUserMaxPwr = Math.Min(simUser.BestServer.NeTRX.MsMaxPower, simUser.TrafficUser.Terminal.GetNetWorkTerminal(NetWorkType.GSM).MaxTxPower);
float compensatePwr=simUserMaxPwr-simUser.PreULTxPower[simUser.UlTs[0]];
m_TchCir.Calc(simUser, false);
if (simUser.IsFirstServed)
{
simUser.ULFilterCIR = PowerControlCommonCalc.CalcIdealCIR(simUser);
simUser.ULFilterRxPower = PowerControlConst.ULReqRXPower;
}
float length_CirFilter=(simUser.UlCirs[simUser.UlTs[0]]+compensatePwr<simUser.ULFilterCIR)?3:9;
float alpha_SCir = (1.012f * length_CirFilter - 0.7505f) / (1.848f + length_CirFilter);
simUser.ULFilterCIR = alpha_SCir * simUser.UlCirs[simUser.UlTs[0]] + (1 - alpha_SCir) * simUser.ULFilterCIR;
float linkLoss = m_GetLinkLoss.GetLinkLoss(NetWorkType.GSM, simUser.UlTs[0].Parent.NeTRX.ID, simUser.TrafficUser.Id, LinkType.Uplink);
float TrxRxPower=simUser.PreULTxPower[simUser.UlTs[0]]-linkLoss;
float length_RxPowerFliter = (TrxRxPower + compensatePwr < simUser.ULFilterRxPower) ? 3 : 9;
float alpha_RxPower = (1.012f * length_RxPowerFliter - 0.7505f) / (1.848f + length_RxPowerFliter);
simUser.ULFilterRxPower = alpha_RxPower * TrxRxPower + (1 - alpha_RxPower) * simUser.ULFilterRxPower;
PowerControlCommonCalc.CalcULStep(simUser);
float requestULPower = simUserMaxPwr - simUser.ULPowerStep;
requestULPower = Math.Min(requestULPower, simUserMaxPwr);
requestULPower = Math.Max(simUser.TrafficUser.Terminal.GetNetWorkTerminal(NetWorkType.GSM).MinTxPower, requestULPower);
//simUser.ULRxPower[simUser.UlTs[0]] = requestULPower;
simUser.CurULTxPower.Add(simUser.UlTs[0], requestULPower);
}
/// <summary>
/// 语音业务功率控制
/// </summary>
private void CsPowerCtrl(GSMSimUser simUser)
{
if (m_IsPowerCtrl)
{
CsHasPowerCtrl(simUser);
}
else
{
CsNotPowerCtrl(simUser);
}
}
/// <summary>
/// 语音业务不功控时功率的更新
/// </summary>
/// <param name="simUser"></param>
private void CsNotPowerCtrl(GSMSimUser simUser)
{
if (simUser.TrafficUser.LinkType == LinkType.Uplink)
{
//simUser.ULTxPower[simUser.UlTs[0]] = simUser.PreULTxPower[simUser.UlTs[0]];
simUser.CurULTxPower.Add(simUser.UlTs[0], simUser.PreULTxPower[simUser.UlTs[0]]);
}
else
{
//if (simUser.DlTs[0].CurDLTxPower.ContainsKey(simUser))
//{
// simUser.DlTs[0].CurDLTxPower[simUser] = simUser.DlTs[0].PreDLTxPower[simUser];
//}
//else
//{
simUser.DlTs[0].CurDLTxPower.Add(simUser, simUser.DlTs[0].PreDLTxPower[simUser]);
//}
}
}
