public List<ProteinSpectrumMatchSet> GroupingByPrsm(int dataid, IEnumerable<ProteinSpectrumMatch> matches, INodeComparer<ProteinSpectrumMatch> prsmComparer)
{
var prsmSet = new NodeSet<ProteinSpectrumMatch>(){};
prsmSet.AddRange(matches);
var groupList = prsmSet.ConnnectedComponents(prsmComparer);
return groupList.Select(@group => new ProteinSpectrumMatchSet(dataid, @group)).ToList();
}
public ProteinSpectrumMatchSet[][] GroupAcrossRuns(List<ProteinSpectrumMatchSet>[] prsmGroup, INodeComparer<ProteinSpectrumMatchSet> prsmGroupComparer)
{
var nDataset = prsmGroup.Length;
var prsmSet = new NodeSet<ProteinSpectrumMatchSet>() { };
for (var i = 0; i < nDataset; i++)
{
var groupedPrsms = prsmGroup[i];
if (groupedPrsms == null) continue;
prsmSet.AddRange(groupedPrsms);
}
var alignedPrsms = prsmSet.ConnnectedComponents(prsmGroupComparer);
var alignedResult = new ProteinSpectrumMatchSet[alignedPrsms.Count][];
for (var i = 0; i < alignedResult.Length; i++) alignedResult[i] = new ProteinSpectrumMatchSet[nDataset];
for(var i = 0; i < alignedPrsms.Count; i++)
{
foreach (var set in alignedPrsms[i])
{
if (alignedResult[i][set.DataId] != null)
{
alignedResult[i][set.DataId].Merge(set);
//Console.WriteLine("[{4}] {0}-{1}...{2}-{3}", set.MinScanNum, set.MaxScanNum, alignedResult[i][set.DataId].MinScanNum, alignedResult[i][set.DataId].MaxScanNum, set.DataId);
}
else
{
alignedResult[i][set.DataId] = set;
}
}
}
return alignedResult;
}
public LcMsFeatureContainer(List <Ms1Spectrum> ms1Spectra, LcMsFeatureLikelihood scorer, INodeComparer <LcMsPeakCluster> mergeComparer)
{
_featureList = new List <LcMsPeakCluster>();
_spectra = ms1Spectra;
_scorer = scorer;
_mergeComparer = mergeComparer;
}
public LcMsFeatureAlignment(INodeComparer <LcMsFeature> featureCompare)
{
_featureSetList = new Dictionary <int, List <LcMsFeature> >();
_featureList = new List <LcMsFeature>();
_runList = new List <LcMsRun>();
_featureCompare = featureCompare;
}
internal HeuristicSearchBase(string algorithmName, TStep from, TStep to, IEqualityComparer <TStep> ec, INodeComparer <TFactor, TStep> nc,
Func <TStep, int, IEnumerable <TFactor> > converter, Func <TStep, int, IEnumerable <TStep> > expander)
{
From = from;
To = to;
_algorithmName = algorithmName;
_ec = ec ?? EqualityComparer <TStep> .Default;
_nc = nc ?? DefaultComparer <TFactor, TStep> .Default;
_converter = converter;
_expander = expander ?? throw new ArgumentNullException(nameof(expander));
}
internal HeuristicSearchOrderBy <TFactor, TStep> CreateOrderedEnumerable(Func <TFactor, double> keySelector, bool descending)
{
if (keySelector == null)
{
throw new ArgumentNullException(nameof(keySelector));
}
var comparer1 = _nodeComparer;
var comparer2 = new HeuristicComparer <TFactor, TStep>(keySelector, descending);
_nodeComparer = new CombinedComparer <TFactor, TStep>(comparer1, comparer2);
return(this);
}
public HeuristicSearchOrderBy <TResult, TStep> CreateOrderedEnumerable <TKey>(Func <TResult, TKey> keySelector, IComparer <TKey> comparer, bool descending)
{
if (keySelector == null)
{
throw new ArgumentNullException(nameof(keySelector));
}
var comparer1 = _nodeComparer;
var comparer2 = HeuristicSearch.CreateComparer <TResult, TKey, TStep>(keySelector, comparer, descending);
_nodeComparer = new CombinedComparer <TResult, TStep>(comparer1, comparer2);
return(this);
}
public List <List <T> > ConnnectedComponents(INodeComparer <T> comparer)
{
SetAdjacentList(comparer);
var componentSet = new List <List <T> >();
var visited = new BitArray(Count);
for (var i = 0; i < Count; i++)
{
if (visited[i])
{
continue;
}
var component = new NodeSet <T>();
var neighbors = new Queue <int>();
neighbors.Enqueue(i);
while (true)
{
if (neighbors.Count < 1)
{
break;
}
var j = neighbors.Dequeue();
if (visited[j])
{
continue;
}
visited[j] = true;
component.Add(this[j]);
foreach (var nd in _adjList[j])
{
if (visited[nd])
{
continue;
}
neighbors.Enqueue(nd);
}
}
componentSet.Add(component);
}
return(componentSet);
}
private void SetAdjacentList(INodeComparer <T> comparer)
{
_adjList = new LinkedList <int> [Count];
for (var i = 0; i < Count; i++)
{
_adjList[i] = new LinkedList <int>();
}
for (var i = 0; i < Count; i++)
{
for (var j = i + 1; j < Count; j++)
{
if (comparer.SameCluster(this[i], this[j]))
{
_adjList[i].AddLast(j);
_adjList[j].AddLast(i);
}
}
}
}
public CombinedComparer(INodeComparer <TFactor, TStep> comparer1, INodeComparer <TFactor, TStep> comparer2)
{
_comparer1 = comparer1;
_comparer2 = comparer2;
_factorOnlyComparer = Comparer <Node <TFactor, TStep> > .Create(CompareFactorOnly);
}
public ProteinSpectrumMatchSet[][] GroupAcrossRuns(List <ProteinSpectrumMatchSet>[] prsmGroup, INodeComparer <ProteinSpectrumMatchSet> prsmGroupComparer)
{
var nDataset = prsmGroup.Length;
var prsmSet = new NodeSet <ProteinSpectrumMatchSet>()
{
};
for (var i = 0; i < nDataset; i++)
{
var groupedPrsms = prsmGroup[i];
if (groupedPrsms == null)
{
continue;
}
prsmSet.AddRange(groupedPrsms);
}
var alignedPrsms = prsmSet.ConnnectedComponents(prsmGroupComparer);
var alignedResult = new ProteinSpectrumMatchSet[alignedPrsms.Count][];
for (var i = 0; i < alignedResult.Length; i++)
{
alignedResult[i] = new ProteinSpectrumMatchSet[nDataset];
}
for (var i = 0; i < alignedPrsms.Count; i++)
{
foreach (var set in alignedPrsms[i])
{
if (alignedResult[i][set.DataId] != null)
{
alignedResult[i][set.DataId].Merge(set);
//Console.WriteLine("[{4}] {0}-{1}...{2}-{3}", set.MinScanNum, set.MaxScanNum, alignedResult[i][set.DataId].MinScanNum, alignedResult[i][set.DataId].MaxScanNum, set.DataId);
}
else
{
alignedResult[i][set.DataId] = set;
}
}
}
return(alignedResult);
}
public LcMsFeatureAlignment(IList <string> featureFileList, IEnumerable <LcMsRun> runList, INodeComparer <LcMsFeature> featureCompare)
: this(featureCompare)
{
_runList.AddRange(runList);
for (var i = 0; i < featureFileList.Count; i++)
{
var features = LoadProMexResult(i, featureFileList[i], _runList[i]);
features.Sort(new FeatureMassComparer());
_featureSetList.Add(i, features);
_featureList.AddRange(features);
}
_featureList.Sort(new FeatureMassComparer());
}
public static List <ProteinSpectrumMatchSet> GroupingByPrsm(int dataid, IEnumerable <ProteinSpectrumMatch> matches, INodeComparer <ProteinSpectrumMatch> prsmComparer)
{
var prsmSet = new NodeSet <ProteinSpectrumMatch>()
{
};
prsmSet.AddRange(matches);
var groupList = prsmSet.ConnnectedComponents(prsmComparer);
return(groupList.Select(@group => new ProteinSpectrumMatchSet(dataid, @group)).ToList());
}
public CombinedComparer(INodeComparer <TResult, TStep> comparer1, INodeComparer <TResult, TStep> comparer2)
{
_comparer1 = comparer1;
_comparer2 = comparer2;
_resultOnlyComparer = Comparer <Node <TResult, TStep> > .Create(CompareResultOnly);
}
public DiffGenerator(INodeTraverser nodeTraverser, INodeFinder nodeFinder, INodeComparer nodeComparer)
{
NodeTraverser = nodeTraverser;
NodeFinder = nodeFinder;
NodeComparer = nodeComparer;
}
internal HeuristicSearchOrderBy(HeuristicSearchBase <TFactor, TStep> source, INodeComparer <TFactor, TStep> nodeComparer)
: base(source)
{
_nodeComparer = nodeComparer;
}
internal HeuristicSearchOrderBy(HeuristicSearchBase <TFactor, TStep> source, INodeComparer <TFactor, TStep> nodeComparer)
: base(source.AlgorithmName, source.From, source.To, source.StepComparer, nodeComparer, source.Converter, source.Expander)
{
IsReversed = source.IsReversed;
AlgorithmObserverFactory = source.AlgorithmObserverFactory;
}
