public static Link Clone(Link link)
{
Link newLink = new Link();
newLink.LinkID = link.LinkID;
Channel newChannel;
foreach (Channel channel in link.Channels)
{
newChannel = Channel.Clone(channel);
newLink.Channels.Add(newChannel);
}
return newLink;
}
private void GetAllLinks(Link parentLink, int[] availableChannelIndexs, int linkID, int frequencyCountIndex)
{
List<int[]> remainIndexsList;
List<Link> linkList = GetLinks(linkID, availableChannelIndexs, mFrequencyCounts[frequencyCountIndex], out remainIndexsList);
parentLink.NextLinks = linkList;
if (remainIndexsList.Count == 0)
return;
linkID++;
frequencyCountIndex++;
if (frequencyCountIndex == mFrequencyCounts.Count)
return;
Link link;
for (int i = 0; i < linkList.Count; i++)
{
link = linkList[i];
GetAllLinks(link, remainIndexsList[i], linkID, frequencyCountIndex);
}
}
private List<Link> GetLinks(int linkID, int[] channelIndexs, int num, out List<int[]> remainIndexsList)
{
remainIndexsList = new List<int[]>();
int[] remainIndexs;
List<Link> links = new List<Link>();
List<int[]> combinations = Algorithms.PermutationAndCombination<int>.GetCombination(channelIndexs, num);
Link link;
Link.Channel channel;
ChannelSetting channelSetting;
int remainIndexsCount;
foreach (int[] combination in combinations)
{
link = new Link();
link.LinkID = "Link " + linkID;
foreach (int index in combination)
{
channelSetting = mAvailableChannels[index];
channel = new Link.Channel();
channel.ChannelID = channelSetting.ChannelName;
channel.SubBand = channelSetting.ODUSubBand;
channel.TX = channelSetting.CenterFreq;
channel.RX = channelSetting.Pair.CenterFreq;
link.Channels.Add(channel);
}
link.Sort();
links.Add(link);
remainIndexsCount = channelIndexs.Length - combination.Length;
if (remainIndexsCount == 0)
continue;
remainIndexs = new int[remainIndexsCount];
int i = 0;
foreach (int index in channelIndexs)
{
if (!FindInArray(combination, index))
remainIndexs[i++] = index;
}
remainIndexsList.Add(remainIndexs);
}
return links;
}
private List<LinkCombination> GetAllLinkCombinations(Link parentLink)
{
int combinationNo = 1;
List<LinkCombination> linkCombinations = new List<LinkCombination>();
List<Link> midLinks = new List<Link>();
CombinateLinks(linkCombinations, midLinks, parentLink);
List<LinkCombination> allLinkCombinations = new List<LinkCombination>();
bool isValidCombination;
foreach (LinkCombination combination in linkCombinations)
{
isValidCombination = true;
foreach (Link link in combination.Links)
{
if (!IsLinkAllChannelsMatched(link))
{
isValidCombination = false;
break;
}
}
if (!isValidCombination)
continue;
List<LinkCombination> newLinkCombinations = GetResultCombinations(combination);
foreach (LinkCombination newCombination in newLinkCombinations)
{
newCombination.CombinationNo = combinationNo;
allLinkCombinations.Add(newCombination);
combinationNo++;
}
}
return allLinkCombinations;
}
private void CombinateLinks(List<LinkCombination> combinations, List<Link> midLinks, Link curLink)
{
if (curLink.NextLinks == null || curLink.NextLinks.Count == 0)
{
LinkCombination combination = new LinkCombination();
foreach (Link link in midLinks)
combination.Links.Add(link);
combination.Links.Add(curLink);
combinations.Add(combination);
}
else
{
foreach (Link link in curLink.NextLinks)
{
if (link.NextLinks != null && link.NextLinks.Count > 0)
midLinks.Add(link);
CombinateLinks(combinations, midLinks, link);
if (link.NextLinks != null && link.NextLinks.Count > 0)
midLinks.Remove(link);
}
}
}
private void PairReportForm_Load(object sender, EventArgs e)
{
SiteAIDLabel.Text = mEmiA.Site_ID;
LongtitudeALabel.Text = Utility.ConvertLongtitude(mEmiA.Site_Longitude);
LatitudeALabel.Text = Utility.ConvertLatitude(mEmiA.Site_Longitude);
DateALabel.Text = mEmiA.PA_TestTime;
EngineerALabel.Text = mEmiA.PA_UserName;
SiteBIDLabel.Text = mEmiB.Site_ID;
LongtitudeBLabel.Text = Utility.ConvertLongtitude(mEmiB.Site_Longitude);
LatitudeBLabel.Text = Utility.ConvertLatitude(mEmiB.Site_Longitude);
DateBLabel.Text = mEmiB.PA_TestTime;
EngineerBLabel.Text = mEmiB.PA_UserName;
ChannelMatcher.Instance.Channels = mAvailableChannels;
ChannelMatcher.Instance.EquipmentParameters = mEquipmentParameters;
mFrequencyCounts = new List<int>();
if (mIsManualConfig)
{
mLinkConfigurations = new List<LinkConfiguration>();
if ((mManualConfig & ManualConfigConstants.MC_1_PLUS_0) != 0)
{
mFrequencyCounts.Add(LinkFrequencyCountMap.Instance.GetCount(ManualConfigConstants.MC_1_PLUS_0));
AddManualConfiguration(ManualConfigConstants.MC_1_PLUS_0);
}
if ((mManualConfig & ManualConfigConstants.MC_2_PLUS_0) != 0)
{
mFrequencyCounts.Add(LinkFrequencyCountMap.Instance.GetCount(ManualConfigConstants.MC_2_PLUS_0));
AddManualConfiguration(ManualConfigConstants.MC_2_PLUS_0);
}
if ((mManualConfig & ManualConfigConstants.MC_3_PLUS_0) != 0)
{
mFrequencyCounts.Add(LinkFrequencyCountMap.Instance.GetCount(ManualConfigConstants.MC_3_PLUS_0));
AddManualConfiguration(ManualConfigConstants.MC_3_PLUS_0);
}
if ((mManualConfig & ManualConfigConstants.MC_4_PLUS_0) != 0)
{
mFrequencyCounts.Add(LinkFrequencyCountMap.Instance.GetCount(ManualConfigConstants.MC_4_PLUS_0));
AddManualConfiguration(ManualConfigConstants.MC_4_PLUS_0);
}
if ((mManualConfig & ManualConfigConstants.MC_1_PLUS_1FD) != 0)
{
mFrequencyCounts.Add(LinkFrequencyCountMap.Instance.GetCount(ManualConfigConstants.MC_1_PLUS_1FD));
AddManualConfiguration(ManualConfigConstants.MC_1_PLUS_1FD);
}
if ((mManualConfig & ManualConfigConstants.MC_2_PLUS_1FD) != 0)
{
mFrequencyCounts.Add(LinkFrequencyCountMap.Instance.GetCount(ManualConfigConstants.MC_2_PLUS_1FD));
AddManualConfiguration(ManualConfigConstants.MC_2_PLUS_1FD);
}
if ((mManualConfig & ManualConfigConstants.MC_3_PLUS_1FD) != 0)
{
mFrequencyCounts.Add(LinkFrequencyCountMap.Instance.GetCount(ManualConfigConstants.MC_3_PLUS_1FD));
AddManualConfiguration(ManualConfigConstants.MC_3_PLUS_1FD);
}
if ((mManualConfig & ManualConfigConstants.MC_1_PLUS_1HSB) != 0)
{
mFrequencyCounts.Add(LinkFrequencyCountMap.Instance.GetCount(ManualConfigConstants.MC_1_PLUS_1HSB));
AddManualConfiguration(ManualConfigConstants.MC_1_PLUS_1HSB);
}
if ((mManualConfig & ManualConfigConstants.MC_1_PLUS_1SD) != 0)
{
mFrequencyCounts.Add(LinkFrequencyCountMap.Instance.GetCount(ManualConfigConstants.MC_1_PLUS_1SD));
AddManualConfiguration(ManualConfigConstants.MC_1_PLUS_1SD);
}
if ((mManualConfig & ManualConfigConstants.MC_DOUBLE_1_PLUS_1SD) != 0)
{
mFrequencyCounts.Add(LinkFrequencyCountMap.Instance.GetCount(ManualConfigConstants.MC_DOUBLE_1_PLUS_1SD));
AddManualConfiguration(ManualConfigConstants.MC_DOUBLE_1_PLUS_1SD);
}
if ((mManualConfig & ManualConfigConstants.MC_TRIPLE_1_PLUS_1SD) != 0)
{
mFrequencyCounts.Add(LinkFrequencyCountMap.Instance.GetCount(ManualConfigConstants.MC_TRIPLE_1_PLUS_1SD));
AddManualConfiguration(ManualConfigConstants.MC_TRIPLE_1_PLUS_1SD);
}
if ((mManualConfig & ManualConfigConstants.MC_FOURTIMES_1_PLUS_1SD) != 0)
{
mFrequencyCounts.Add(LinkFrequencyCountMap.Instance.GetCount(ManualConfigConstants.MC_FOURTIMES_1_PLUS_1SD));
AddManualConfiguration(ManualConfigConstants.MC_FOURTIMES_1_PLUS_1SD);
}
}
else
{
foreach (LinkConfiguration linkConfiguration in mLinkConfigurations)
mFrequencyCounts.Add(LinkFrequencyCountMap.Instance.GetCount(linkConfiguration.RequiredConfiguration));
}
Link parentLink = new Link();
int[] availableChannelIndexs = new int[mAvailableChannels.Count];
for (int i = 0; i < mAvailableChannels.Count; i++)
availableChannelIndexs[i] = i;
if (AnalysisChannelCombination)
GetAllLinks(parentLink, availableChannelIndexs, 0, 0);
mDataManagerA = Utility.GetEmiDataManager(mEmiA, mChannelSettings);
mDataManagerB = Utility.GetEmiDataManager(mEmiB, mChannelSettings);
GenerateGraphs();
ShowGraph(true);
ShowGraph(false);
if (AnalysisChannelCombination)
{
mAllCombinationDirectionMasks = DirectionMasker.Instance().GetAllCombinateDirectionMasks(mFrequencyCounts);
mLinkcombinations = GetAllLinkCombinations(parentLink);
ShowLinkCombinations();
}
}
private bool IsLinkAllDirectionMatched(Link link)
{
if (link.Channels.Count == 1)
return true;
for(int i = 0; i < link.Channels.Count - 1; i++)
{
if (Utility.IsChannelClosed(link.Channels[i].ChannelID, link.Channels[i + 1].ChannelID)
&& link.Channels[i].Result.Equals(link.Channels[i + 1].Result))
return false;
}
return true;
}
private bool IsLinkAllChannelsMatched(Link link)
{
if (link.Channels.Count == 1)
return true;
foreach (Link.Channel channel1 in link.Channels)
{
foreach (Link.Channel channel2 in link.Channels)
{
if (channel1 == channel2)
continue;
if (!ChannelMatcher.Instance.IsMatch(channel1.ChannelID, channel2.ChannelID))
return false;
}
}
return true;
}
