private double GetLinkLossUlByDl(int index, LTECell bestServerCarrier)
{
throw new NotImplementedException();
//double num = bestServerCarrier.RSPower - UnitTrans.ShortToDouble(this.m_BestServerRSRP[index]);
//AntConfig config = bestServerCarrier.Parent.AntConfiguration[0];
//return ((num - config.DlTotalLoss) + bestServerCarrier.get_SpaceBetweenDlAndUL());
}
private void addNewLteCarrier(string carrierName, ReceptionEquipment reception)
{
LTECell cell = new LTECell();
this.SetIACellProperty(carrierName, reception, cell);
cell.RefreshDLActualTxPower();
this.AddIACellToCarriers(cell);
}
public double CalculateUlNoisePower(int RbNum, LTECell carrier)
{
double num = 0.0;
FrequencyBand freqBand = carrier.FreqBand;
//num = freqBand.get_NoisePowerOfBandWidth() + carrier.get_NoiseFigureOfBts();
return (num + UnitTrans.todB((double) (((double) RbNum) / ((double) freqBand.RBNum))));
}
/// <summary>
/// 计算backhaul链路的路损
/// </summary>
/// <param name="lteCell"></param>
/// <param name="relayCell"></param>
/// <returns></returns>
public Dictionary<int, List<float>> CaclBackhaulPathLoss(LTECell lteCell, RelayCell relayCell)
{
//一个lteCell有两根天线，每根天线存一个路损值和天线值
float calcResolution = 0;
SetCellResolution(lteCell, ref calcResolution);
PathLossCalcParam[] cellCalcPara = m_CalcParamFactory.GetCellCalcPara(lteCell, calcResolution);
Dictionary<int, List<float>> antennaPathLoss = new Dictionary<int, List<float>>();
for (int i = 0; i < cellCalcPara.Length; i++)
{
float pathLoss = 0;
float antGain = 0;
SectionPathLossCalcParam sectionParam = cellCalcPara[i].SectionParamArray[0];
IPathLossCalculator calcMethod = GetCalcMethod(sectionParam);
if (calcMethod != null)
{
GeoXYLine geoXYLine = new GeoXYLine();
Dictionary<string, object> modelDetailDictionary = new Dictionary<string, object>();
pathLoss = calcMethod.CalculatePointPathLoss(sectionParam, geoXYLine, out modelDetailDictionary);
}
antGain = CalcAntGain(lteCell, relayCell);
List<float> list = new List<float>();
list.Add(pathLoss);
list.Add(antGain);
antennaPathLoss.Add(cellCalcPara[i].AntennaConfig.AntennaID, list);
}
return antennaPathLoss;
}
public Transceiver GetIAcell()
{
Transceiver transceiver = new Transceiver();
LTECell item = new LTECell();
transceiver.Cells.Add(item);
transceiver.Name = this.Name;
transceiver.ID = this.CellID;
transceiver.Cells[0].PropModels = this.PropModels;
transceiver.AntConfiguration = this.AntConfiguration;
if (transceiver.Parent == null)
{
transceiver.Parent = new Site();
}
transceiver.Parent.Name = this.SiteName;
transceiver.Parent.ID = this.SiteID;
((Site) transceiver.getParent()).Altitude = this.SiteAltitude;
transceiver.DeltaX = this.X;
transceiver.DeltaY = this.Y;
if (transceiver.Cells.Count == 0)
{
IACell cell2 = new LTECell();
transceiver.Cells.Add(cell2);
transceiver.Cells[0].FreqBand = new FrequencyBand();
}
transceiver.Cells[0].FreqBand = new FrequencyBand();
transceiver.Cells[0].FreqBand.DLFrequency = this.DLFrequency;
return transceiver;
}
public void AddCarrier(short us, LTECell carrier)
{
if (!this.m_CarrierIDToCarrierObject.ContainsValue(carrier))
{
this.m_CarrierIDToCarrierObject.Add(us, carrier);
this.m_CarrierObjectToCarrierID.Add(carrier, us);
}
}
public double CalcAntGain(LTECell carrier, User user)
{
if (!SimulationConstant.USE_PlatFormAntenna)
{
return this.CalcAntennaGain(carrier, user);
}
return this.CalcAntGain3D(carrier, user);
}
private double CalcAntennaGain(LTECell carrier, User user)
{
double num = 0.0;
num = ((user.X - carrier.Parent.X) == 0.0) ? 90.0 : ((Math.Atan2(user.X - carrier.Parent.X, user.Y - carrier.Parent.Y) / 3.1415926535897931) * 180.0);
num = ((num - carrier.Parent.AntConfiguration[0].Azimuth) + 360.0) % 360.0;
num = (num > 180.0) ? (num - 360.0) : num;
return (18.0 - Math.Min((double) ((12.0 * (num / 70.0)) * (num / 70.0)), (double) 20.0));
}
private void SetCellResolution(LTECell lteCell, ref float calcResolution)
{
foreach (PropModelConfig config in lteCell.PropModels)
{
if ((calcResolution < 0f) || (calcResolution == float.MaxValue))
{
calcResolution = Math.Min(calcResolution, (float)config.CalcResolution);
}
}
}
private float CalculateDlEquipmentLoss(LTECell carrier, User user)
{
double num = 0.0;
float lineValue = 0f;
foreach (AntConfig config in carrier.Parent.AntConfiguration)
{
lineValue += (config.Tma != null) ? (config.TxPowerRatio * SimulationTools.ConvertdBToLine(((config.DlJumpLossTmaToBs + config.DlJumpLossTmaToAnt) + config.DlTotalLoss) + config.Tma.DlLoss)) : (config.TxPowerRatio * SimulationTools.ConvertdBToLine((config.DlJumpLossTmaToBs + config.DlJumpLossTmaToAnt) + config.DlTotalLoss));
}
num = (((SimulationTools.ConvertLineTodB(lineValue) - this.CalcAntGain(carrier, user)) + SimulationTools.GetLTEServiceBodyLoss(user.Service)) + user.Terminal.NetTerminalList[0].Loss) - user.Terminal.Gain;
return (float) num;
}
private void GetPrachSinr(LTECell bestServerCarrier, int index)
{
FrequencyBand freqBand = bestServerCarrier.FreqBand;
int rbNum = 6;
double minValue = double.MinValue;
double linkLossUlByDl = 0.0;
linkLossUlByDl = this.GetLinkLossUlByDl(index, bestServerCarrier);
double num3 = this.m_PrachPower - linkLossUlByDl;
double ulActualIoT = bestServerCarrier.UlActualIoT;
double num6 = this.CalculateUlNoisePower(rbNum, bestServerCarrier);
minValue = num3 - (num6 + ulActualIoT);
this.m_OneBinValueTemp.PRACH_SINR = UnitTrans.DoubleToShort(minValue);
}
private double CalcAntGain3D(LTECell carrier, User user)
{
Transceiver parent = carrier.Parent;
StructAntennaParam calAntennaParam = new StructAntennaParam();
calAntennaParam.AntConfigSetUp = parent.AntConfiguration[0];
calAntennaParam.CellX = parent.X;
calAntennaParam.CellY = parent.Y;
calAntennaParam.IsSimple = false;
calAntennaParam.MsX = user.X;
calAntennaParam.MsY = user.Y;
calAntennaParam.AntHeight = 0;
calAntennaParam.MsHeight = 0;
return (double) this.m_CalculateGain.CalculateAntennaGain(calAntennaParam);
}
public static List<RelayCell> GetRCListFromLTECellList(LTECell lteCell)
{
List<RelayNode> relayNodes = new List<RelayNode>();
List<RelayCell> relayCells = new List<RelayCell>();
if (lteCell != null && lteCell.RNList != null)
{
relayNodes.AddRange(lteCell.RNList);
}
foreach (RelayNode rn in relayNodes)
{
relayCells.AddRange(rn.RCList);
}
return relayCells;
}
public static LTECell CreatLteCell()
{
LTECell lteCell = new LTECell();
lteCell.Parent = new Transceiver();
Site site = new Site();
site.Equipment = new BtsEquipment();
lteCell.Parent.Parent = site;
lteCell.FreqBand = new FrequencyBand();
lteCell.FreqBand.BandWidth = 20;
lteCell.FreqBand.ID = 4;
lteCell.PropModels.Add( MockPropModelCfg.CreatLtePropModelCfg());
RelayNode relayNode = MockRelayNode.CreatRelayNode();
lteCell.RNList.Add(relayNode);
lteCell.ID = 1;
//lteCell.RNList
return lteCell;
}
public bool IsBuildOneBinOk(int index)
{
this.m_BestCarrierID = this.m_BestServerCarrierID[index];
if (this.m_BestCarrierID != this.m_InvalidateValue)
{
this.m_bestCarrier = this.m_DataManager.GetCarrierByID(this.m_BestCarrierID);
FrequencyBand freqBand = this.m_bestCarrier.FreqBand;
double num = ((float) this.m_OneBinValueTemp.DL_SCH_RP) / 100f;
//double num2 = this.m_OneBinValueTemp.m_Total_I_N - freqBand.get_RENumOfBandWidth();
double num2 = this.m_OneBinValueTemp.m_Total_I_N - freqBand.RBNum;
num += this.m_OneBinValueTemp.m_ModelShadowMargin;
this.m_OneBinValueTemp.SCH_SINR = UnitTrans.DoubleToShort((num - num2) - this.m_OneBinValueTemp.m_C_i_nShadowMargin);
if (LTEPredictionLogForTest.IsDebugEnabled())
{
GeoXYPoint xYPoint = this.m_DataManager.BestServerRSRP.GetXYPoint(index);
LTEPredictionLogForTest.Debug(string.Concat(new object[] { DateTime.Now.ToString("G"), ",Study:SCH_SINR,BinIndex:", index, ",X:", xYPoint.X, ",Y:", xYPoint.Y, ",BestCarrier:", this.m_bestCarrier.Name, ",+" }));
}
}
return true;
}
private float CalculateDlTotalLoss(LTECell carrier, User user, LinkLossStruct dlLinkLossStruct)
{
if (dlLinkLossStruct.pathLoss == float.MinValue)
{
return float.MaxValue;
}
double num = 0.0;
float userClutterModeDiviation = UserManager.getInstance().GetUserClutterModeDiviation(this.m_SubSysInterface, user);
dlLinkLossStruct.pathLoss = Math.Max(dlLinkLossStruct.pathLoss, 73.35696f);
float num3 = this.CalculateShadowFadeValue(carrier, user, this.m_Coefficientabc, userClutterModeDiviation);
num = dlLinkLossStruct.pathLoss + num3;
double num4 = Math.Sqrt(((carrier.Parent.X - user.X) * (carrier.Parent.X - user.X)) + ((carrier.Parent.Y - user.Y) * (carrier.Parent.Y - user.Y)));
//Commented by wj
//×ÔÓɿռ䴫²¥ËðºÄ
double num5 = 32.4 + (20.0 * Math.Log10((carrier.FreqBand.DLFrequency * num4) / 1000.0));
num = (num < num5) ? num5 : num;
num += dlLinkLossStruct.otherTotalLoss;
return (float) num;
}
public void SetParent(LTECell cell)
{
this.Parent = cell;
if (!cell.RNList.Contains(this))
{
cell.RNList.Add(this);
}
}
public void CopyFrom(LTECell cell)
{
base.CopyFrom(cell);
this.ActualDlLoad = cell.ActualDlLoad;
this.ActualUlLoad = cell.ActualUlLoad;
this.BCHPoffset = cell.BCHPoffset;
this.SCHPoffset = cell.SCHPoffset;
this.PCFICHPoffset = cell.PCFICHPoffset;
this.PDCCHPoffset = cell.PDCCHPoffset;
this.PHICHPoffset = cell.PHICHPoffset;
this.UlActualIoT = cell.UlActualIoT;
this.DlActualTxPower = cell.DlActualTxPower;
this.DLRsSinrAccessThreshold = cell.DLRsSinrAccessThreshold;
this.SchedulePolicy = cell.SchedulePolicy;
this.RSPower = cell.RSPower;
this.HighSpeed = cell.HighSpeed;
this.GCI = cell.GCI;
this.PhyID = cell.PhyID;
this.AmsThreshold = cell.AmsThreshold;
this.Ams = cell.Ams;
this.CellPriority = cell.CellPriority;
this.PB = cell.PB;
this.CellReselPriority = cell.CellReselPriority;
this.LocalCellID = cell.LocalCellID;
this.TAC = cell.TAC;
this.m_CellRadius = cell.CellRadius;
this.m_MinRootSequenceIndex = cell.MinRootSequenceIndex;
this.LteAlgParameter = cell.LteAlgParameter;
this.FormatObj(cell);
this.m_RPDCCHPoffset = cell.m_RPDCCHPoffset;
this.m_RPDSCHPoffset = cell.m_RPDSCHPoffset;
}
private float CaculateSCHpower(LTECell carrier)
{
float num = this.CaculateRsRe(carrier);
return (float) (10.0 * Math.Log10(10.0 * Math.Pow(10.0, (double) ((num + carrier.SCHPoffset) / 10f))));
}
/// <summary>
/// backhaul路损 仿真
/// </summary>
/// <param name="carrier"></param>
/// <param name="userList"></param>
/// <returns></returns>
public LinkLossStruct[][][] GetBackhaulLinkLoss(LTECell carrier, List<RelayCell> rcList)
{
LinkLossStruct[] ulAndDlLinkLoss;
int num;
LinkLossStruct[][][] structArray = new LinkLossStruct[rcList.Count][][];
Transceiver parent = carrier.Parent;
this.m_StructAntennaParam.IsSimple = false;
//if (parent.AntConfiguration.Count == 1)
//{
this.isOutdoorAntenna(parent);
for (num = 0; num < rcList.Count; num++)
{
structArray[num] = new LinkLossStruct[][] { new LinkLossStruct[2] };
ulAndDlLinkLoss = GetBackhaulUlAndDlLinkLoss(parent, rcList[num]);
structArray[num][0][0] = ulAndDlLinkLoss[0];
structArray[num][0][1] = ulAndDlLinkLoss[1];
}
return structArray;
//}
//for (num = 0; num < rcList.Count; num++)
//{
// structArray[num] = new LinkLossStruct[][] { new LinkLossStruct[2] };
// ulAndDlLinkLoss = this.GetMultUlAndDlLinkLoss(parent, rcList[num]);
// structArray[num][0][0] = ulAndDlLinkLoss[0];
// structArray[num][0][1] = ulAndDlLinkLoss[1];
//}
//return structArray;
}
public void FormatObj(LTECell oriCarrier)
{
this.BestStartFrequency = this.CaculateBestStartFrequency(oriCarrier);
this.SCHPower = this.CaculateSCHpower(oriCarrier);
this.BCHPower = this.CaculateBCHpower(oriCarrier);
this.LteAlgParameter.UlPucchRbs = this.SetDefaultULPucch(oriCarrier);
}
private float CaculateRsRe(LTECell carrier)
{
return carrier.RSPower;
}
private int SetDefaultULPucch(LTECell carrier)
{
FrequencyBand freqBand = carrier.FreqBand;
if (!((freqBand == null) || PucchConfig.getPuccConf(freqBand.BandWidth).Pucch.Contains(carrier.LteAlgParameter.UlPucchRbs)))
{
return PucchConfig.getPuccConf(freqBand.BandWidth).DefaultPucchValue;
}
return carrier.LteAlgParameter.UlPucchRbs;
}
private void GetMaxRSPowerCarrier(LTECellCalcInfo cellInfo)
{
LTECell cell = new LTECell();
LTECell cell2 = new LTECell();
double minValue = double.MinValue;
double dlActualTxPower = double.MinValue;
double rSPower = double.MinValue;
foreach (LTECell cell3 in cellInfo.Tanceiver.Cells)
{
FrequencyBand freqBand = cell3.FreqBand;
rSPower = cell3.RSPower;
if (minValue < rSPower)
{
minValue = rSPower;
cell = cell3;
}
if (cell3.DlActualTxPower > dlActualTxPower)
{
dlActualTxPower = cell3.DlActualTxPower;
cell2 = cell3;
}
}
cellInfo.RSMaxCarrier = cell;
cellInfo.ActTxPowerCarrier = cell2;
}
public void MyTestInitialize()
{
m_NgbCarrierList = new List<ISimulationCarrier>();
m_AdCarrier1 = new SimulationCarrier();
m_AdCarrier2 = new SimulationCarrier();
m_AdCarrier1.AdmissionCarrierTag = new AdmissionCellTag();
m_AdCarrier2.AdmissionCarrierTag = new AdmissionCellTag();
m_LbThresHoldParam = new LBThresholdParam();
m_SUser1 = new SimulationUser();
m_SUser2 = new SimulationUser();
m_SUser1.AdmissionUserTag = new SimulationUser();
m_SUser2.AdmissionUserTag = new SimulationUser();
m_AdmissionCarrier = new SimulationCarrier();
LTECell ltecarrier = new LTECell();
m_AdmissionCarrier.Carrier = ltecarrier;
m_AdCarrier1.Carrier = ltecarrier;
m_AdCarrier2.Carrier = ltecarrier;
FrequencyBand freband = new FrequencyBand();
freband.BandWidth = 100;
ltecarrier.FreqBand = freband;
m_AdmissionCarrier.AdmissionCarrierTag = new AdmissionCellTag();
m_Lbth = new LBThresholdParam();
m_DLLB = new DlLoadBalancingService(m_CurrentTTI, m_Lbth);
m_LbUserList = new List<ISimulationUser>();
m_User1 = new SimulationUser();
m_User2 = new SimulationUser();
m_LbUserList.Add(m_User1);
m_LbUserList.Add(m_User2);
m_DlDataWaitUserList = new List<ISimulationUser>();
m_DlDataWaitUserList.Add(m_SUser1);
m_DlDataWaitUserList.Add(m_SUser2);
m_AdmissionCarrier.DlDataWaitUserList = m_DlDataWaitUserList;
m_DlVoiceWaitUserList = new List<ISimulationUser>();
m_DlVoiceWaitUserList.Add(m_SUser1);
m_DlVoiceWaitUserList.Add(m_SUser2);
m_AdmissionCarrier.DlVoiceWaitUserList = m_DlVoiceWaitUserList;
m_NgbList = new List<ISimulationCarrier>();
RelayCell relaycarrier = new RelayCell();
LteAlgParam ltealgparam = new LteAlgParam();
m_AdmissionCarrier.Carrier = relaycarrier;
m_AdCarrier1.Carrier = relaycarrier;
m_AdCarrier2.Carrier = relaycarrier;
m_DlUserList = new List<ISimulationUser>();
m_DlUserList.Add(m_SUser1);
m_DlUserList.Add(m_SUser2);
m_AdmissionCarrier.DlUserList = m_DlUserList;
m_CarrierListInComputerArea = new CarrierTotalLoss();
List<CarrierTotalLoss> listcarrier1 = new List<CarrierTotalLoss>();
CarrierTotalLoss a = new CarrierTotalLoss();
CarrierTotalLoss b = new CarrierTotalLoss();
listcarrier1.Add(a);
listcarrier1.Add(b);
SimulationCarrier carrier = new SimulationCarrier();
((SimulationUser)m_SUser1).CarrierListInComputeArea = listcarrier1.ToArray();
((SimulationUser)m_SUser2).CarrierListInComputeArea = listcarrier1.ToArray();
((SimulationUser)m_SUser1).CarrierListInComputeArea[0].Carrier = carrier;
((SimulationUser)m_SUser2).CarrierListInComputeArea[0].Carrier = carrier;
((SimulationUser)m_SUser1).CarrierListInComputeArea[1].Carrier = carrier;
((SimulationUser)m_SUser2).CarrierListInComputeArea[1].Carrier = carrier;
((SimulationUser)m_SUser1).CarrierListInComputeArea[0].Carrier.Carrier = relaycarrier;
((SimulationUser)m_SUser2).CarrierListInComputeArea[0].Carrier.Carrier = relaycarrier;
((SimulationUser)m_SUser1).CarrierListInComputeArea[1].Carrier.Carrier = relaycarrier;
((SimulationUser)m_SUser2).CarrierListInComputeArea[1].Carrier.Carrier = relaycarrier;
m_User1.CarrierListInComputeArea = listcarrier1.ToArray();
m_User2.CarrierListInComputeArea = listcarrier1.ToArray();
m_User1.CarrierListInComputeArea[0].Carrier = carrier;
m_User2.CarrierListInComputeArea[0].Carrier = carrier;
m_User1.CarrierListInComputeArea[1].Carrier = carrier;
m_User2.CarrierListInComputeArea[1].Carrier = carrier;
m_User1.CarrierListInComputeArea[0].Carrier.Carrier = relaycarrier;
m_User2.CarrierListInComputeArea[0].Carrier.Carrier = relaycarrier;
m_User1.CarrierListInComputeArea[1].Carrier.Carrier = relaycarrier;
m_User2.CarrierListInComputeArea[1].Carrier.Carrier = relaycarrier;
m_User1.BestServiceCellBeforeHandOver = a;
m_User1.StroNbrBeforeHandOver = b;
m_User2.BestServiceCellBeforeHandOver = a;
m_User2.StroNbrBeforeHandOver = b;
m_CarrierListInComputerArea.Carrier = carrier;
relaycarrier.RSPower = 100;
}
private float GetUlPathLoss(LTECell carrier, User user, bool isUse3GPP)
{
double num = 0.0;
double d = ((carrier.Parent.X - user.X) * (carrier.Parent.X - user.X)) + ((carrier.Parent.Y - user.Y) * (carrier.Parent.Y - user.Y));
double num3 = Math.Sqrt(d);
if (isUse3GPP)
{
num = SimulationConstant.SPM_RADIUS + (SimulationConstant.SPM_D * Math.Log10(num3 / 1000.0));
return ((num < 73.3569564819336) ? ((float) 73.3569564819336) : ((float) num));
}
num = SimulationConstant.COST_RADIUS + (SimulationConstant.COST_D * Math.Log10(num3 / 1000.0));
return ((num < 73.3569564819336) ? ((float) 73.3569564819336) : ((float) num));
}
/// <summary>
/// 计算宏小区到relay的天线增益
/// </summary>
/// <param name="lteCell"></param>
/// <param name="relayCell"></param>
/// <returns></returns>
private float CalcAntGain(LTECell lteCell, RelayCell relayCell)
{
StructAntennaParam calAntennaParam = new StructAntennaParam();
int sectorID = lteCell.Parent.AntConfiguration[0].AntennaID;
calAntennaParam.CellX = lteCell.Parent.Parent.X + lteCell.Parent.GetAntConfig(sectorID).DX;
calAntennaParam.CellY = lteCell.Parent.Parent.Y + lteCell.Parent.GetAntConfig(sectorID).DY;
calAntennaParam.IsSimple = false;
calAntennaParam.AntHeight = m_IGeoInfo.GetValueByGeoXYPoint(calAntennaParam.CellX, calAntennaParam.CellY, DemDataType.Height);
calAntennaParam.MsX = relayCell.ParentRN.X;//todo：加上偏置？
calAntennaParam.MsY = relayCell.ParentRN.Y;
calAntennaParam.MsHeight = m_IGeoInfo.GetValueByGeoXYPoint(relayCell.ParentRN.X, relayCell.ParentRN.Y, DemDataType.Height);
float antGain = 0;
calAntennaParam.AntConfigSetUp = lteCell.Parent.GetAntConfig(sectorID);
antGain = m_AntennaGainCalculator.Calculate3DGain(calAntennaParam);
return antGain;
}
public void CopyFrom(RelayNode rn)
{
base.Name = rn.Name;
base.Comments = rn.Comments;
this.Altitude = rn.Altitude;
base.Latitude = rn.Latitude;
base.Longitude = rn.Longitude;
base.Active = rn.Active;
base.Selected = rn.Selected;
base.Visible = rn.Visible;
base.X = rn.X;
base.Y = rn.Y;
this.Equipment = rn.Equipment;
this.RNID = rn.RNID;
this.RCList = rn.RCList;
this.Parent = rn.Parent;
this.RbNum = rn.RbNum;
}
public LinkLossStruct[][][] GetLinkLoss(LTECell carrier, List<User> userList)
{
LinkLossStruct[] ulAndDlLinkLoss;
int num;
LinkLossStruct[][][] structArray = new LinkLossStruct[userList.Count][][];
Transceiver parent = carrier.Parent;
this.m_StructAntennaParam.IsSimple = false;
if (parent.AntConfiguration.Count == 1)
{
this.isOutdoorAntenna(parent);
for (num = 0; num < userList.Count; num++)
{
structArray[num] = new LinkLossStruct[][] { new LinkLossStruct[2] };
ulAndDlLinkLoss = this.GetUlAndDlLinkLoss(parent, userList[num]);
structArray[num][0][0] = ulAndDlLinkLoss[0];
structArray[num][0][1] = ulAndDlLinkLoss[1];
}
return structArray;
}
for (num = 0; num < userList.Count; num++)
{
structArray[num] = new LinkLossStruct[][] { new LinkLossStruct[2] };
ulAndDlLinkLoss = this.GetMultUlAndDlLinkLoss(parent, userList[num]);
structArray[num][0][0] = ulAndDlLinkLoss[0];
structArray[num][0][1] = ulAndDlLinkLoss[1];
}
return structArray;
}
private float CaculateBestStartFrequency(LTECell carrier)
{
float num = 0f;
if (null != carrier.FreqBand)
{
num = carrier.FreqBand.DLFrequency + (carrier.FreqBand.BandWidth * carrier.ChannelIndex);
}
return num;
}
