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;
}
