/// <summary>
/// 清理重复干扰结果
/// </summary>
public void CleanRepeatDisturbResult()
{
for (int i = 0; i < this.imList.Count; i++)
{
if (imList[i] != null && imList[i].DisturbedFreqs.Length == 1)
{
IMOrder order = this.imList[i].Order;
ComparableFreq[] freqs = this.GetCalcFreqs(imList[i]);
Array.Sort(freqs);
for (int j = i + 1; j < this.imList.Count; j++)
{
if (this.imList[j] != null && this.imList[j].Order == order &&
this.imList[j].DisturbedFreqs.Length == 1)
{
ComparableFreq[] refFreqs = this.GetCalcFreqs(imList[j]);
Array.Sort(refFreqs);
if (CompareFreqsArray(freqs, refFreqs))
{
this.imList[j] = null;
}
}
}
}
}
List <IMItemBase> list = new List <IMItemBase>(imList.Count);
foreach (IMItemBase item in imList)
{
if (item != null)
{
list.Add(item);
}
}
imList = list;
}
/// <summary>
///
/// </summary>
/// <param name="equs">设备集合</param>
/// <param name="aroundstation">周围台站集合</param>
/// <param name="analysisType">非法信息</param>
/// <returns></returns>
public static InterferenceAnalysisResult Calculator(List <ActivityEquipment> equs, List <ActivitySurroundStation> aroundstation,
AnalysisType analysisType)
{
ConvertToCalcCondition(equs, aroundstation);
InterferenceAnalysisResult Interfresult = new InterferenceAnalysisResult();
if ((analysisType & AnalysisType.SameFreq) == AnalysisType.SameFreq)
{
//同频干扰计算
SameFreqCalculator samefreqCalc = new SameFreqCalculator(EquFreqs, StationFreqs);
SameFreqCompareResult[] sameInterfResult = samefreqCalc.CalcSameFreqInterference();
if (sameInterfResult != null && sameInterfResult.Length > 0)
{
Interfresult.SameFreqInterfResult = sameInterfResult;
Interfresult.SameFreqInterfResultCount = sameInterfResult.Length;
}
}
if ((analysisType & AnalysisType.ADJFreq) == AnalysisType.ADJFreq)
{
//邻频干扰计算
AdjFreqCalculator adjfreqCalc = new AdjFreqCalculator(EquFreqs, StationFreqs);
AdjFreqCompareResult[] adjInterfResult = adjfreqCalc.CalcAdjFreqInterference();
if (adjInterfResult != null && adjInterfResult.Length > 0)
{
Interfresult.ADJFreqInterfResult = adjInterfResult;
Interfresult.ADJFreqInterfResultCount = adjInterfResult.Length;
}
}
if ((analysisType & AnalysisType.IM) == AnalysisType.IM)
{
//互调干扰计算
IMOrder order = IMOrder.Second | IMOrder.Third | IMOrder.Fifth;
IMAnalysisResult imresult = new IMAnalysisResult();
IMCalculator calculator = new IMCalculator(EquTransmitters, EquReceivers, StationTransmitters, StationReceivers);
imresult.SetReceiverImResult(calculator.CalcReceiverIMInterference(order));
//imresult.SetTransmitterImResult(calculator.CalcTransmitterIMInterference());
if (imresult != null)
{
Interfresult.IMInterfResult = imresult;
int transcount = 0;
int receivcount = 0;
if (imresult.GetReceiverImResult() != null && imresult.GetReceiverImResult().Values.Length > 0)
{
receivcount = imresult.GetReceiverImResult().Values.Length;
}
//if (imresult.GetTransmitterImResult() != null && imresult.GetTransmitterImResult().Values.Length > 0)
//{
// transcount = imresult.GetTransmitterImResult().Values.Length;
//}
Interfresult.IMInterfResultCount = transcount + receivcount;
}
}
return(Interfresult);
}
/// <summary>
/// 获取互调干扰阶数
/// </summary>
/// <param name="order"></param>
/// <returns></returns>
private InterfereOrderEnum GetIMInterfOrder(IMOrder order)
{
switch (order)
{
case IMOrder.Second:
return(InterfereOrderEnum.二阶互调);
case IMOrder.Third:
return(InterfereOrderEnum.阶互调);
case IMOrder.Fifth:
return(InterfereOrderEnum.五阶互调);
}
return(InterfereOrderEnum.干扰);
}
private string GetIMOrder(IMOrder order)
{
switch (order)
{
case IMOrder.Second:
return("二阶干扰");
case IMOrder.Third:
return("二阶干扰");
case IMOrder.Fifth:
return("二阶干扰");
default: return(null);
}
return(null);
}
/// <summary>
/// 测试接收机互调
/// </summary>
/// <param name="receiver">被干扰接收机</param>
/// <param name="order">互调阶数</param>
/// <returns>互调结果</returns>
public IMCompareResult TestReceiverIM(Receiver receiver, IMOrder order)
{
this.imResult = new IMCompareResult();
this.InitializeImOrder(order);
this.currentReceiver = receiver;
int start = BiSearchTransmitter(receiver.TuningFreqFrom, 0, stationreceivers.Length - 1);
int end = BiSearchTransmitter(receiver.TuningRangeTo, start, stationreceivers.Length - 1);
this.endPosition = end;
for (int i = start; i < end; i++)
{
for (int j = i + 1; j <= end; j++)
{
CalculateReceiverIM(this.stationtransmitters[i], j);
}
}
return(imResult);
}
/// <summary>
/// 测试接收机互调
/// </summary>
/// <param name="transmitter">参与计算的发射机</param>
/// <param name="order">互调阶数</param>
/// <returns>接收机互调结果</returns>
public IMCompareResult TestReceiverIM(Transmitter transmitter, IMOrder order)
{
this.imResult = new IMCompareResult();
this.InitializeImOrder(order);
foreach (Receiver receiver in this.stationreceivers)
{
if (receiver.ReceivableFreq(transmitter.Freq))
{
this.currentReceiver = receiver;
int start = BiSearchTransmitter(receiver.TuningFreqFrom, 0, stationreceivers.Length - 1);
int end = BiSearchTransmitter(receiver.TuningRangeTo, start, stationreceivers.Length - 1);
this.endPosition = end;
for (int i = start; i <= end; i++)
{
CalculateReceiverIM(transmitter, i);
}
}
}
return(this.imResult);
}
/// <summary>
/// 初始化互调阶数
/// </summary>
/// <param name="order">互调阶数</param>
private void InitializeImOrder(IMOrder order)
{
if (order != this.imOrder)
{
this.CalculateReceiverIM -= CalcSecondOrderIM;
this.CalculateReceiverIM -= this.CalcThirdOrderIM;
this.CalculateReceiverIM -= CalcFifthOrderIM;
if ((order & IMOrder.Second) == IMOrder.Second)
{
//this.CalculateReceiverIM += CalcSecondOrderIM;
}
if ((order & IMOrder.Third) == IMOrder.Third)
{
this.CalculateReceiverIM += this.CalcThirdOrderIM;
}
if ((order & IMOrder.Fifth) == IMOrder.Fifth)
{
this.CalculateReceiverIM += CalcFifthOrderIM;
}
this.imOrder = order;
}
}
/// <summary>
/// 计算接收机互调
/// </summary>
internal IMCompareResult ReceiverIM(IMOrder order)
{
this.imResult = new IMCompareResult();
this.InitializeImOrder(order);
foreach (Receiver receiver in this.stationreceivers)
{
this.currentReceiver = receiver;
int start = BiSearchTransmitter(receiver.TuningFreqFrom, 0, stationtransmitters.Length - 1);
int end = BiSearchTransmitter(receiver.TuningRangeTo, start, stationtransmitters.Length - 1);
this.endPosition = end;
for (int i = start; i < end; i++)
{
for (int j = i + 1; j <= end; j++)
{
if (this.currentReceiver.EquipID != this.stationtransmitters[i].EquipID &&
this.currentReceiver.EquipID != this.stationtransmitters[j].EquipID)
{
CalculateReceiverIM(stationtransmitters[i], j);
}
}
}
}
return(imResult);
}
/// <summary>
/// 计算的实现
/// </summary>
/// <param name="p_calculateAllFreqs"></param>
/// <param name="p_calculateAllRCFreqs"></param>
/// <param name="p_unKnowSignalFreqs"></param>
private void CalculateRealize(List <ComparableFreq> p_calculateAllFreqs, List <ComparableFreq> p_calculateAllRCFreqs, List <ComparableFreq> p_unKnowSignalFreqs)
{
#region
//if(p_unKnowSignalFreqs.Count > 15)
//{
// //发 106.5 ，96.8 收 106 ， 96.8
// p_unKnowSignalFreqs[0] = new ComparableFreq(106.4, 0, 0, 0.5, ""); //同频
// p_unKnowSignalFreqs[1] = new ComparableFreq(96.8, 0, 0, 0.200, ""); //同频
// p_unKnowSignalFreqs[2] = new ComparableFreq(105.5, 0, 0, 0.400, ""); //邻频
// p_unKnowSignalFreqs[3] = new ComparableFreq(107.5, 0, 0, 0.400, ""); //邻频
// p_unKnowSignalFreqs[4] = new ComparableFreq(95.8, 0, 0, 0.400, ""); //邻频
// p_unKnowSignalFreqs[5] = new ComparableFreq(97.8, 0, 0, 0.400, ""); //邻频
// p_unKnowSignalFreqs[6] = new ComparableFreq(206, 0, 0, 0.400, ""); //二阶互调
// p_unKnowSignalFreqs[7] = new ComparableFreq(100, 0, 0, 0.400, ""); //二阶互调
// p_unKnowSignalFreqs[8] = new ComparableFreq(50, 0, 0, 0.400, ""); //二阶互调
// p_unKnowSignalFreqs[9] = new ComparableFreq(56, 0, 0, 0.400, ""); //二阶互调
// p_unKnowSignalFreqs[10] = new ComparableFreq(90, 0, 0, 0.400, ""); //三阶互调
// p_unKnowSignalFreqs[11] = new ComparableFreq(106.8, 0, 0, 0.400, ""); //三阶互调
// p_unKnowSignalFreqs[12] = new ComparableFreq(100, 0, 0, 0.400, ""); //三阶互调
// p_unKnowSignalFreqs[13] = new ComparableFreq(95, 0, 0, 0.400, ""); //五阶互调
// p_unKnowSignalFreqs[14] = new ComparableFreq(94.1, 0, 0, 0.400, ""); //五阶互调
//}
#endregion
CompareResultToBindingData bindingData = new CompareResultToBindingData(GetEquipment, GetSurroundStation);
//同频干扰
List <InterferedBindingData> gridSource = new List <InterferedBindingData>();
SameFreqCalculator samefreqCalc = new SameFreqCalculator(p_calculateAllFreqs.ToArray(), p_unKnowSignalFreqs.ToArray());
SameFreqCompareResult[] sameResults = samefreqCalc.CalcSameFreqInterference();
if (sameResults != null && sameResults.Length > 0)
{
foreach (var sameResult in sameResults)
{
List <InterferedBindingData> sameFreqlist = bindingData.GetBindingData(sameResult);
gridSource.AddRange(sameFreqlist);
}
}
//邻频干扰
AdjFreqCalculator adjfreqCalc = new AdjFreqCalculator(p_calculateAllFreqs.ToArray(), p_unKnowSignalFreqs.ToArray());
AdjFreqCompareResult[] adjInterfResult = adjfreqCalc.CalcAdjFreqInterference();
if (adjInterfResult != null && adjInterfResult.Length > 0)
{
List <InterferedBindingData> adjFreqlist = bindingData.GetBindingData(adjInterfResult);
gridSource.AddRange(adjFreqlist);
}
//互调干扰
IMCalculator calculator = new IMCalculator(GetTransmitter(p_unKnowSignalFreqs), new Receiver[0], GetTransmitter(p_calculateAllFreqs), GetReceivers(p_calculateAllRCFreqs));
IMOrder order = IMOrder.Second | IMOrder.Third | IMOrder.Fifth;
IMCompareResult imInterfResult = calculator.CalcReceiverIMInterference(order);
if (imInterfResult != null)
{
List <InterferedBindingData> imFreqlist = bindingData.GetBindingData(imInterfResult);
gridSource.AddRange(imFreqlist);
}
ItemsSourceBinding(gridSource);
}
/// <summary>
/// 互调干扰
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void BtnIM_Click(object sender, RoutedEventArgs e)
{
imresult.Text = null;
IMOrder order = IMOrder.Second | IMOrder.Third | IMOrder.Fifth;
IMAnalysisResult result = new IMAnalysisResult();
IMCalculator calculator = new IMCalculator(transmitters, receivers, transmitters, receivers);
result.SetReceiverImResult(calculator.ReceiverIM(order));
result.SetTransmitterImResult(calculator.TransmitterIM());
StringBuilder strmsg = new StringBuilder();
int index = 0;
//接收互调
IMCompareResult receiverResult = result.GetReceiverImResult();
if (receiverResult != null)
{
strmsg.Append("接收机互调干扰: \r");
IMItemBase imBase = null;
for (int i = 0; i < receiverResult.Values.Length; i++)
{
imBase = receiverResult.Values[i];
for (int j = 0; j < imBase.DisturbedFreqs.Length; j++)
{
index++;
ComparableFreq disfreq = imBase.DisturbedFreqs[j];
strmsg.AppendFormat("{0}:受干扰接收机: 频率ID:{1},频率:{2},带宽:{3} \r", index, disfreq.FreqID, disfreq.Freq, disfreq.Band);
strmsg.AppendFormat("干扰阶数:{0},干扰公式:{1} \r", GetIMOrder(imBase.Order), imBase.Formula);
for (int k = 0; k < imBase.IMFreqs.Length; k++)
{
strmsg.AppendFormat("干扰频率{0}:频率:{1},带宽:{2} \r", k + 1, imBase.IMFreqs[k].Freq, imBase.IMFreqs[k].Band);
}
strmsg.Append("\r");
}
}
}
//发射机互调
IMCompareResult transResult = result.GetTransmitterImResult();
if (transResult != null && transResult.Values.Length > 0)
{
strmsg.Append("发射机互调干扰: \r");
IMItemBase imBase = null;
index = 0;
for (int i = 0; i < transResult.Values.Length; i++)
{
imBase = transResult.Values[i];
for (int j = 0; j < imBase.DisturbedFreqs.Length; j++)
{
index++;
ComparableFreq disfreq = imBase.DisturbedFreqs[j];
strmsg.AppendFormat("{0}:受干扰发射机: 频率ID:{1},频率:{2},带宽:{3} \r", index, disfreq.FreqID, disfreq.Freq, disfreq.Band);
strmsg.AppendFormat("干扰阶数:{0},干扰公式:{1} \r", GetIMOrder(imBase.Order), imBase.Formula);
for (int k = 0; k < imBase.IMFreqs.Length; k++)
{
strmsg.AppendFormat("干扰频率{0}:频率:{1},带宽:{2} \r", k + 1, imBase.IMFreqs[k].Freq, imBase.IMFreqs[k].Band);
}
strmsg.Append("\r");
}
}
}
imresult.Text = strmsg.ToString();
}
/// <summary>
/// 计算接收机互调
/// </summary>
/// <param name="order"></param>
/// <returns></returns>
public IMCompareResult CalcReceiverIMInterference(IMOrder order)
{
this.imResult = new IMCompareResult();
//this.InitializeImOrder(order);
//遍历设备接收参数
foreach (Receiver receiver in this.equreceivers)
{
this.currentReceiver = receiver;
int equstart = 0;
int equend = equtransmitters.Length - 1;
this.endPosition = equend;
for (int e = equstart; e < equend; e++)
{
for (int f = e + 1; f <= equend; f++)
{
if (this.currentReceiver.EquipID != this.equtransmitters[e].EquipID &&
this.currentReceiver.EquipID != this.equtransmitters[f].EquipID)
{
//CalculateReceiverIM(equtransmitters[e], f);
if ((order & IMOrder.Second) == IMOrder.Second)
{
CalcEquSecondOrderIM(equtransmitters[e], f);
}
if ((order & IMOrder.Third) == IMOrder.Third)
{
CalcEquThirdOrderIM(equtransmitters[e], f);
}
if ((order & IMOrder.Fifth) == IMOrder.Fifth)
{
CalcEquFifthOrderIM(equtransmitters[e], f);
}
}
}
}
int stationstart = 0;
int stationend = stationtransmitters.Length - 1;
this.endPosition = stationend;
for (int s = stationstart; s < stationend; s++)
{
for (int k = s + 1; k <= stationend; k++)
{
if (this.currentReceiver.EquipID != this.stationtransmitters[s].EquipID &&
this.currentReceiver.EquipID != this.stationtransmitters[k].EquipID)
{
//CalculateReceiverIM(equtransmitters[s], k);
if ((order & IMOrder.Second) == IMOrder.Second)
{
CalcStationSecondOrderIM(stationtransmitters[s], k);
}
if ((order & IMOrder.Third) == IMOrder.Third)
{
CalcStationThirdOrderIM(stationtransmitters[s], k);
}
if ((order & IMOrder.Fifth) == IMOrder.Fifth)
{
CalcStationFifthOrderIM(stationtransmitters[s], k);
}
}
}
}
}
return(imResult);
}
