public override RayMethodParam BuildCalcParam(SectionPathLossCalcParam areaParam, int rayIndex, Dictionary<DemDataType, GisPreLoadData> gisData) { RayMethodParam rayParam = base.BuildCalcParam(areaParam, rayIndex, gisData); GisPreLoadData data = gisData[DemDataType.Height]; short[] altitudes = base.GeoDataProvider.GetGeoInfoByRay(areaParam.X, areaParam.Y, rayParam, data.DemDataArray, data.Bound); base.m_AltitudeHeights = altitudes; GisPreLoadData data2 = gisData[DemDataType.Building]; base.m_BuildHeights = base.GeoDataProvider.GetGeoInfoByRay(areaParam.X, areaParam.Y, rayParam, data2.DemDataArray, data2.Bound); GisPreLoadData data3 = gisData[DemDataType.Clutter]; base.m_ClutterTypeIDs = base.GeoDataProvider.GetGeoInfoByRay(areaParam.X, areaParam.Y, rayParam, data3.DemDataArray, data3.Bound); rayParam.RxEffHeight = base.m_Hre.GetRayEffHeight(altitudes, areaParam.RxAntennaHeight, rayParam.StartIndex, rayParam.EndIndex); rayParam.RxEffHeight[0] = areaParam.RxAntennaHeight; ITURPPropagationModel model = areaParam.PropagModel as ITURPPropagationModel; EffectTxHeightBase base2 = model.EffTxHeightCalcuMethod as EffectTxHeightBase; if (base2 != null) { rayParam.TxEffHeight = base2.CalcRayEffTxHt(areaParam, base.m_AltitudeHeights, rayParam.StartIndex, rayParam.EndIndex); } else { rayParam.TxEffHeight = new float[altitudes.Length]; rayParam.TxEffHeight[0] = areaParam.TxAntennaHeight; } rayParam.Frequency = areaParam.Frequency; return rayParam; }
public override float CalcPointEffTxHt(SectionPathLossCalcParam param, short[] altitudes) { float midEffHeights = base.CalcPointEffTxHt(param, altitudes); midEffHeights = base.m_TxHeight + Math.Abs((int) (altitudes[0] - altitudes[altitudes.Length - 1])); base.JudgeEffHeight(ref midEffHeights); return midEffHeights; }
/// <summary> /// 构造函数 /// </summary> /// <param name="difLossCalcPara">扇形片路径损耗计算参数</param> /// <param name="geoDataObserver"></param> public DiffractionLossCalculator(SectionPathLossCalcParam difLossCalcPara, IPropaGeoDataObserver geoDataObserver) { this.m_DifLossCalcPara = difLossCalcPara; this.m_Spmodel = difLossCalcPara.PropagModel; this.m_CalcDifLossMethod = (DiffractionLossBase) difLossCalcPara.PropagModel.DifLossMethod; this.m_GeoDataProvider = geoDataObserver; }
//这个方法好像没有调用的地方 public float[] CalcPointPathLoss(IPropagationModel prop, IACell carrier, AntConfig ant, GeoXYLine xyLine, float resolution, float rxHeight, out Dictionary<string, object> modelDetail) { if (prop == null) { modelDetail = null; return new float[2]; } AntConfig config = ant; IPropagationModel model = prop; SectionPathLossCalcParam param = new SectionPathLossCalcParam(); param.TxAntennaHeight = config.Height; if (!(AntConfig.IS_ANTENNA_HEIGHT_INCLUDE_BUILDING || !this.GeoDataProvider.IGeoProvider.IsBuildingLoaded)) { param.TxAntennaHeight += this.GeoDataProvider.GisInfo.GetValueByGeoXYPoint(xyLine.Points[0], DemDataType.Building, false); } param.RxAntennaHeight = rxHeight; param.Frequency = carrier.FreqBand.DLFrequency; param.MergeEdgeMaxDis = 80f; param.PropagModel = model; param.CalcResolution = resolution; param.CalcEndRadius = (float) xyLine.GetDistance(); param.X = (float) xyLine.Points[0].X; param.Y = (float) xyLine.Points[0].Y; return this.CalcPointPathLoss(param, xyLine, carrier.FreqBand.ULFrequency, out modelDetail); }
private float[] CalcPointPathLoss(SectionPathLossCalcParam param, GeoXYLine xyLine, float UlFrequency, out Dictionary<string, object> modelDetail) { IPathLossCalculator calcMethod = this.GetCalcMethod(param); float num = calcMethod.CalculatePointPathLoss(param, xyLine, out modelDetail); float num2 = num + calcMethod.CalcDeltaLossFrmDLToUL(param.PropagModel, param.Frequency, UlFrequency, param.RxAntennaHeight); return new float[] { num2, num }; }
public override float CalculatePointPathLoss(SectionPathLossCalcParam param, GeoXYLine xyLine, out Dictionary<string, object> modelDetail) { base.CalculatePointPathLoss(param, xyLine, out modelDetail); RelayUEPropagationModel propModel = param.PropagModel as RelayUEPropagationModel; float distance= (float)(xyLine.GetDistance() / 1000); float prob=CalcProbability(propModel,distance); return GetPathLoss(propModel, distance, prob); }
public override float CalcPointEffTxHt(SectionPathLossCalcParam param, short[] altitudes) { int pointIndex = altitudes.Length; float midEffHeights = base.CalcPointEffTxHt(param, altitudes); midEffHeights = this.GetPointEffHeights(pointIndex, altitudes, param, midEffHeights); base.JudgeEffHeight(ref midEffHeights); return midEffHeights; }
public void testCalcPointEffTxHt3() { EffectTxSlopeAtReceiver temp = new EffectTxSlopeAtReceiver(); SectionPathLossCalcParam param = new SectionPathLossCalcParam(); param.CalcResolution = 0.1f; short[] altitudes = new short[] { 10, 11, 12, 13 }; Assert.AreEqual(26.99f, temp.CalcPointEffTxHt(param, altitudes), 2); }
public void testCalcPointEffTxHt2() { EffectTxSlopeAtReceiver temp = new EffectTxSlopeAtReceiver(); SectionPathLossCalcParam param = new SectionPathLossCalcParam(); param.CalcResolution = 10; short[] altitudes = new short[] { 300, 25, 100, 10 }; Assert.AreEqual(320.0f, temp.CalcPointEffTxHt(param, altitudes)); }
public void TestCalcRayEffTxHt() { EffectTxEnhancedSlope testEffectTxEnhancedSlope = new EffectTxEnhancedSlope(); SectionPathLossCalcParam param = new SectionPathLossCalcParam(); param.TxAntennaHeight = 5f; param.CalcResolution = 5f; StreamReader sr = new StreamReader(@"D:\UNet2012\TestCode\Huawei.UNet.Propagation.Plugins.Test\TextFile4.txt"); int startIndex = 0; int endIndex = 5; string line0 = null; while (null != (line0 = sr.ReadLine())) { //第一行赋值给期望结果 string lineExpected = line0.Trim(); if (lineExpected.StartsWith("#")) { continue; } string[] tokenExpected = lineExpected.Split(' '); List<float> listExpected = new List<float>(); for (int i = 0; i < tokenExpected.Length; i++) { listExpected.Add(float.Parse(tokenExpected[i])); } float[] expected = listExpected.ToArray(); //次行第一个给TxAntennaHeight赋值,第二个给CalcResolution赋值 string lineParam = sr.ReadLine().Trim(); string[] tokenParam = lineParam.Split(' '); param.TxAntennaHeight = float.Parse(tokenParam[0]); param.CalcResolution = float.Parse(tokenParam[1]); //第三行赋值给数组altitudes string lineAltitudes = sr.ReadLine().Trim(); string[] tokenAltitudes = lineAltitudes.Split(' '); List<short> list = new List<short>(); for (int i = 0; i < tokenAltitudes.Length; i++) { list.Add(short.Parse(tokenAltitudes[i])); } short[] altitudes = list.ToArray(); float[] result = testEffectTxEnhancedSlope.CalcRayEffTxHt(param, altitudes, startIndex, endIndex); //foreach (float f in result) //{ // Console.WriteLine(f.ToString()); //} Assert.AreEqual(expected, result); } sr.Close(); }
public void testGetSlope2() { EffectTxSlopeAtReceiver temp = new EffectTxSlopeAtReceiver(); SectionPathLossCalcParam param = new SectionPathLossCalcParam(); param.CalcResolution = 100; short[] altitudes = new short[] { 10, 25, 100, 300 }; int nIndex = 4; Assert.AreEqual(1.0f, temp.GetSlope(param, altitudes, nIndex)); }
protected Dictionary<short, float> InitialKClutters(SectionPathLossCalcParam param) { if (!(param.PropagModel is SpmPropagationModel)) { return new Dictionary<short, float>(); } SpmPropagationModel model = param.PropagModel as SpmPropagationModel; Dictionary<short, string> stringDic = model.KTerrainsDictionary; return this.TransStringToSingle(stringDic); }
public override float CalculatePointPathLoss(SectionPathLossCalcParam param, GeoXYLine xyLine, out Dictionary<string, object> modelDetail) { float num = 0f; modelDetail = null; KeenanMotleyPropagationModel model = param.PropagModel as KeenanMotleyPropagationModel; float num2 = (float) Math.Log10((double) param.Frequency); float num3 = (float) Math.Log10(xyLine.GetDistance() / 1000); num = ((model.K1 + (model.K2 * num2)) + (model.K3 * num3)) + (model.K4 * model.K5); float num4 = 0f; return (num + (num4 * model.KDiffraction)); }
public override float[] CalcRayClutterLoss(SectionPathLossCalcParam param, short[] clutters, int startIndex, int endIndex) { float[] destinationArray = new float[(endIndex - startIndex) + 1]; Dictionary<short, float> dictionary = base.InitialKClutters(param); float[] sourceClutterLos = new float[clutters.Length]; float distanceRT = ((endIndex - startIndex) + 1) * param.CalcResolution; float temp = clutters.Length * param.CalcResolution; this.MorethanDistance(param, clutters, distanceRT, ref sourceClutterLos, temp); Array.Copy(sourceClutterLos, startIndex, destinationArray, 0, destinationArray.Length); return destinationArray; }
public override float CalculatePointPathLoss(SectionPathLossCalcParam param, GeoXYLine xyLine, out Dictionary<string, object> modelDetail) { float num = 0f; modelDetail = null; ITURPPropagationModel iTURPModel = param.PropagModel as ITURPPropagationModel; float num2 = (float) Math.Log10((double) param.Frequency); float num3 = (float) Math.Log10(xyLine.GetDistance()); num = ((iTURPModel.K2 + (iTURPModel.K1 * num2)) + (iTURPModel.N * num3)) + this.GetLf(iTURPModel); float num4 = 0f; return (num + (num4 * iTURPModel.KDiffraction)); }
public override float CalcPointEffTxHt(SectionPathLossCalcParam param, short[] altitudes) { float midEffHeights = base.CalcPointEffTxHt(param, altitudes); if (altitudes[0] > altitudes[altitudes.Length - 1]) { midEffHeights = (altitudes[0] - altitudes[altitudes.Length - 1]) + base.m_TxHeight; } else { midEffHeights = base.m_TxHeight; } base.JudgeEffHeight(ref midEffHeights); return midEffHeights; }
public override float[] CalcRayEffTxHt(SectionPathLossCalcParam param, short[] altitudes, int startIndex, int endIndex) { float[] numArray = base.CalcRayEffTxHt(param, altitudes, startIndex, endIndex); for (int i = startIndex; i <= endIndex; i++) { if (altitudes[i] == -32768) { numArray[i - startIndex] = -32768f; } else { base.JudgeEffHeight(ref this.m_TxHeight); numArray[i - startIndex] = base.m_TxHeight; } } return numArray; }
public void testCalcRayEffTxHt() { EffectTxSlopeAtReceiver temp = new EffectTxSlopeAtReceiver(); SectionPathLossCalcParam param = new SectionPathLossCalcParam(); param.CalcResolution = 10; short[] altitudes = new short[] { 10, 25, 100, 300, -32768 }; float[] results = temp.CalcRayEffTxHt(param, altitudes, 0, 4); for (int i = 0; i < 5; i++) { if (altitudes[i] == -32768f) { Assert.AreEqual(-32768f, results[i]); } else { Assert.AreEqual(30.0f, results[i]); } } }
public override float[] CalcRayEffTxHt(SectionPathLossCalcParam param, short[] altitudes, int startIndex, int endIndex) { int pointIndex = altitudes.Length; float[] numArray = base.CalcRayEffTxHt(param, altitudes, startIndex, endIndex); float midEffHeights = 0f; for (int i = startIndex; i <= endIndex; i++) { if (altitudes[i] == -32768) { numArray[i - startIndex] = -32768f; } else { midEffHeights = this.GetPointEffHeights(pointIndex, altitudes, param, midEffHeights); base.JudgeEffHeight(ref midEffHeights); numArray[i - startIndex] = midEffHeights; } } return numArray; }
public SPMAdjustDT(IBaseService iBaseService, DataForAdjust dataForAdjust, IList<FileInfoBase> dtFileList) { base.m_IBaseService = iBaseService; this.m_antennaGain = ServiceHelper.Lookup<ICalcGain>(iBaseService); base.m_GeoDataObserver = ServiceHelper.Lookup<IPropaGeoDataObserver>(iBaseService); this.m_StatusBarService = ServiceHelper.Lookup<IStatusBarService>(iBaseService); this.m_SectionPathLossCalcParam = new SectionPathLossCalcParam(); base.modelBeforeAdjust = dataForAdjust.PropModel as SpmPropagationModel; base.modelAfterAdjust = (SpmPropagationModel) base.modelBeforeAdjust.Clone(); this.m_SectionPathLossCalcParam.PropagModel = base.modelAfterAdjust; this.m_ClutterLossMethod = base.modelAfterAdjust.ClutLossCalcuMethod as ClutterLossBase; this.m_EffTxHeightMethod = base.modelAfterAdjust.EffTxHeightCalcuMethod as EffectTxHeightBase; base.endCondition = dataForAdjust.EndCondition; base.isCoeNeedAdjust = dataForAdjust.IsCoeNeedAdjust; this.m_DTFileList = dtFileList; this.m_DataForAdjust = dataForAdjust; base.m_ClutterTypeNum = base.m_GeoDataObserver.GisInfo.GetAllClutter().Count; base.lossesperClutterMatrix = new float[base.m_ClutterTypeNum]; base.modelCoeValue = new float[] { base.modelBeforeAdjust.K1, base.modelBeforeAdjust.K2, base.modelBeforeAdjust.K3, base.modelBeforeAdjust.K4, base.modelBeforeAdjust.K5, base.modelBeforeAdjust.K6, base.modelBeforeAdjust.K7 }; base.modelCoeNum = base.isCoeNeedAdjust.Length; }
private float GetPointEffHeights(int pointIndex, short[] altitudes, SectionPathLossCalcParam param, float midEffHeights) { short fRxPosAlt = altitudes[pointIndex - 1]; if (fRxPosAlt == -32768) { midEffHeights = base.m_TxHeight; return midEffHeights; } float fDistance = pointIndex * param.CalcResolution; short fTxPosAlt = altitudes[0]; if (altitudes[pointIndex - 1] > fTxPosAlt) { float fSloAng = this.GetSlope(param, altitudes, pointIndex); midEffHeights = this.RxMoreThanTx(midEffHeights, fDistance, altitudes, fRxPosAlt, fTxPosAlt, fSloAng); midEffHeights = Math.Max(20f, midEffHeights); midEffHeights = Math.Min(200f, midEffHeights); } else { midEffHeights = (base.m_TxHeight + fTxPosAlt) - fRxPosAlt; } return midEffHeights; }
public override RayMethodParam BuildCalcParam(SectionPathLossCalcParam sectionParam, int rayIndex, Dictionary<DemDataType, GisPreLoadData> gisData) { RayMethodParam rayParam = base.BuildCalcParam(sectionParam, rayIndex, gisData); GisPreLoadData hightData = gisData[DemDataType.Height]; base.m_AltitudeHeights = base.GeoDataProvider.GetGeoInfoByRay(rayParam.X, rayParam.Y, rayParam, hightData.DemDataArray, hightData.Bound); GisPreLoadData buildingData = gisData[DemDataType.Building]; base.m_BuildHeights = base.GeoDataProvider.GetGeoInfoByRay(rayParam.X, rayParam.Y, rayParam, buildingData.DemDataArray, buildingData.Bound); GisPreLoadData clutterData = gisData[DemDataType.Clutter]; base.m_ClutterTypeIDs = base.GeoDataProvider.GetGeoInfoByRay(rayParam.X, rayParam.Y, rayParam, clutterData.DemDataArray, clutterData.Bound); rayParam.RxEffHeight = base.m_Hre.GetRayEffHeight(m_AltitudeHeights, sectionParam.RxAntennaHeight, rayParam.StartIndex, rayParam.EndIndex); //rayParam.RxEffHeight[0] = sectionParam.RxAntennaHeight; RelayUEPropagationModel ralayPropModel = sectionParam.PropagModel as RelayUEPropagationModel; EffectTxHeightBase txHeight = ralayPropModel.EffTxHeightCalcuMethod as EffectTxHeightBase; if (txHeight != null) { rayParam.TxEffHeight = txHeight.CalcRayEffTxHt(sectionParam, m_AltitudeHeights, rayParam.StartIndex, rayParam.EndIndex); } else { rayParam.TxEffHeight = new float[m_AltitudeHeights.Length]; rayParam.TxEffHeight[0] = sectionParam.TxAntennaHeight; } return rayParam; }
public float GetSlope(SectionPathLossCalcParam param, short[] altitudes, int nIndex) { int fNumber = (int) (param.MergeEdgeMaxDis / (4f * param.CalcResolution)); if (fNumber < 1) { fNumber = 1; } fNumber = Math.Min(this.Trim(fNumber, 5, 10), nIndex); float[] a = new float[fNumber * 2]; float[] y = new float[fNumber]; int num2 = nIndex; for (int i = 0; i < fNumber; i++) { a[i] = num2 * param.CalcResolution; y[i] = altitudes[num2 - 1]; num2--; } float[] numArray3 = new float[2]; float[] numArray4 = new float[3]; LinearRegression regression = new LinearRegression(); MatrixOperation operation = new MatrixOperation(); regression.mvfitgn(a, y, numArray3, fNumber, 2, false); return numArray3[1]; }
/// <summary> /// 获取具体的传模计算类 /// </summary> /// <param name="param"></param> /// <returns></returns> private IPathLossCalculator GetCalcMethod(SectionPathLossCalcParam param) { Type type = param.PropagModel.GetType(); return m_PLCalcCollection[type]; }
public virtual float[] CalcRayClutterLoss(SectionPathLossCalcParam param, short[] clutters, int startIndex, int endIndex) { throw new Exception("The method or operation is not implemented."); }
private float CalcEffecTxHt(CellInformation cellInfo, BinInformation binInfo) { GeoXYLine geoXYLine = new GeoXYLine(cellInfo.XYPoint, binInfo.XYPoint); short[] altitudes = base.m_GeoDataObserver.GisInfo.GetValueByGeoXYLine(geoXYLine, (double) cellInfo.Resolution, DemDataType.Height); this.m_EffTxHeightMethod = base.modelBeforeAdjust.EffTxHeightCalcuMethod as EffectTxHeightBase; SectionPathLossCalcParam param = new SectionPathLossCalcParam(); param.CalcResolution = cellInfo.Resolution; param.TxAntennaHeight = cellInfo.TxHeight; param.RxAntennaHeight = 1.5f; param.MergeEdgeMaxDis = 80f; param.PropagModel = base.modelBeforeAdjust; param.Frequency = cellInfo.Frequency; param.TransmitterName = cellInfo.CellName; float num = (this.m_EffTxHeightMethod == null) ? cellInfo.TxHeight : this.m_EffTxHeightMethod.CalcPointEffTxHt(param, altitudes); return (float) Math.Log10((double) num); }
/// <summary> /// 计算天线有效高度 /// </summary> /// <param name="param"></param> /// <param name="xyLine"></param> public void CalculateTxHeights(SectionPathLossCalcParam param, GeoXYLine xyLine) { float calcResolution = param.CalcResolution; short[] altitudes = GeoDataProvider.GisInfo.GetValueByGeoXYLine(xyLine, (double) calcResolution, DemDataType.Height); EffectTxHeightBase base2 = param.PropagModel.EffTxHeightCalcuMethod as EffectTxHeightBase; if (base2 != null) { m_TxEffHeight = base2.CalcPointEffTxHt(param, altitudes); } else { m_TxEffHeight = param.TxAntennaHeight; } }
private void MorethanDistance(SectionPathLossCalcParam param, short[] clutters, float distanceRT, ref float[] sourceClutterLos, float temp) { float numerator = 0f; float denominator = 0f; Dictionary<short, float> kClutters = base.InitialKClutters(param); for (int i = 1; i < sourceClutterLos.Length; i++) { float num3 = i * param.CalcResolution; float num4 = distanceRT; numerator += this.GetClutterLos(kClutters, clutters[i]) * ((float) Math.Log10((double) ((num3 / num4) + 1f))); denominator += (float) Math.Log10((double) ((num3 / num4) + 1f)); sourceClutterLos[i] = this.JudgementDenominator(denominator, numerator); } }
/// <summary> /// 计算backhaul链路的路径损耗 /// </summary> /// <param name="losData"></param> /// <param name="sectionParam"></param> /// <param name="isStopCalculator"></param> public void CalculateBackhaulPathLoss(ref SectorPathLossData losData, SectionPathLossCalcParam sectionParam, ref bool isStopCalculator) { GisPreLoadData clutterData; GisPreLoadData heightData; GisPreLoadData buildingHeightData; m_SectionPathLossCalcParam = sectionParam; DiffCalcPreProcess(sectionParam); Dictionary<DemDataType, GisPreLoadData> gisData = new Dictionary<DemDataType, GisPreLoadData>(); PreLoadGisData(out clutterData, out heightData, out buildingHeightData, sectionParam); gisData.Add(DemDataType.Clutter, clutterData); gisData.Add(DemDataType.Height, heightData); gisData.Add(DemDataType.Building, buildingHeightData); if (!(AntConfig.IS_ANTENNA_HEIGHT_INCLUDE_BUILDING || !GeoDataProvider.IGeoProvider.IsBuildingLoaded)) { GeoXYPoint pnt = new GeoXYPoint((double)sectionParam.X, (double)sectionParam.Y); sectionParam.TxAntennaHeight += GeoDataProvider.GisInfo.GetValueByGeoXYPoint(pnt, DemDataType.Building, false); } short rayNumber = sectionParam.GetMacroUERayNumber(); for (int i = 0; i < rayNumber; i++) { m_RayIndex = i; RayMethodParam rayParam = BuildCalcParam(sectionParam, i, gisData); float[] rayLos = CalculateRayPathLoss(rayParam, sectionParam.MacroToRelayPropModel, ref isStopCalculator); WriteSectionLos(ref losData, i, rayLos, sectionParam.SectionIndex); } }
/// <summary> /// 计算点到点的路径损耗 /// </summary> /// <param name="param"></param> /// <param name="xyLine"></param> /// <param name="modelDetail"></param> /// <returns></returns> public virtual float CalculatePointPathLoss(SectionPathLossCalcParam param, GeoXYLine xyLine, out Dictionary<string, object> modelDetail) { DiffCalcPreProcess(param); GetDataFromGis(xyLine, param.CalcResolution); m_SectionPathLossCalcParam = param; modelDetail = null; return 0f; }