protected void ProduceResult(IDataPoints data, ISpectrum spectrum, List <IGlycoPeptide> precursor)
{
List <IGlycoPeptideScore> glycoPeptideScores = new List <IGlycoPeptideScore>();
List <NGlycoPeptideNode> nodes = GetMaxNodes(data);
//score precursor
foreach (IGlycoPeptide glycoPeptide in precursor)
{
string seq = glycoPeptide.GetPeptide().GetSequence();
ITableNGlycan glycan = glycoPeptide.GetGlycan() as ITableNGlycan;
PeakScore score = new PeakScore();
foreach (NGlycoPeptideNode node in nodes)
{
if (node.GetPeptide().GetSequence() == seq &&
IsGlycanMatch(node.GetNGlycan(), glycan))
{
score.Merge(node);
}
}
if (score.GetScore() > 0)
{
glycoPeptideScores.Add(new GeneralGlycoPeptideScore(glycoPeptide, score.GetScore()));
}
}
result = new GeneralGlycoPeptideScoreResultProduct(spectrum, glycoPeptideScores);
}
public void ProduceResult(IDataPoints data, ISpectrum spectrum, IGlycoPeptide glycoPeptide)
{
ITableNGlycan glycan = glycoPeptide.GetGlycan() as ITableNGlycan;
Dictionary <string, IPeak> peaks = new Dictionary <string, IPeak>();
List <IAnnotatedPeak> annotatedPeaks = new List <IAnnotatedPeak>();
foreach (PeakPoint pt in data.GetPoints())
{
if (!peaks.ContainsKey(pt.GetID()))
{
double mass = Double.Parse(pt.GetID());
peaks[pt.GetID()] = new GeneralPeak(mass, pt.GetIntensity());
}
List <IGlycoPeptide> glycoPeptides = new List <IGlycoPeptide>();
foreach (NGlycoPeptideNode node in pt.GetMaxNode())
{
if (IsGlycanMatch(node.GetNGlycan(), glycan))
{
glycoPeptides.Add(new GeneralGlycoPeptide(node.GetPeptide(), node.GetNGlycan(), -1));
}
}
if (glycoPeptides.Count > 0)
{
IAnnotatedPeak p = new GeneralAnnotatedSpectrumPeak(peaks[pt.GetID()], glycoPeptides);
annotatedPeaks.Add(p);
}
}
result = new GeneralAnnotatedSpectrumPeakResultProduct(spectrum,
annotatedPeaks.OrderBy(x => x.GetMZ()).ToList());
}
protected void UpdateNeighborsByNode(INode root, IDataPoints data, DynamicProgrammingParameter parameter)
{
Queue <INode> queue = new Queue <INode>();
Queue <int> steps = new Queue <int>();
queue.Enqueue(root);
steps.Enqueue(parameter.GetMaxDistance());
while (queue.Count > 0)
{
INode node = queue.Dequeue();
int avail = steps.Dequeue();
if (avail == 0)
{
continue;
}
foreach (INode n in node.CreateNodes())
{
if (!MatchAndUpdate(n, data, parameter))
{
queue.Enqueue(n);
steps.Enqueue(avail - 1);
}
}
}
}
public void Search(ISpectrum spectrum, List <IGlycoPeptide> precursor)
{
List <INode> roots = InitRoot(precursor);
IDataPoints data = InitSpectrum(spectrum);
dp.Search(roots, data, parameter as DPSpectrumCIDParameter);
ProduceResult(data, spectrum, precursor);
}
public void Annotate(ISpectrum spectrum, IGlycoPeptide glycoPeptide)
{
List <INode> roots = InitRoot(glycoPeptide);
IDataPoints data = InitSpectrum(spectrum);
dp.Search(roots, data, parameter as DPSpectrumCIDParameter);
ProduceResult(data, spectrum, glycoPeptide);
}
protected void UpdateNeighbors(IPoint current, IDataPoints data, DynamicProgrammingParameter parameter)
{
List <INode> bestNodes = current.GetMaxNode();
foreach (INode root in bestNodes)
{
UpdateNeighborsByNode(root, data, parameter);
}
}
protected bool MatchAndUpdate(INode node, IDataPoints points, DynamicProgrammingParameter parameter)
{
bool updated = false;
foreach (IPoint pt in points.Match(node, parameter))
{
pt.Update(node);
updated = true;
}
return(updated);
}
public void Search(List <INode> rootList, IDataPoints data, DynamicProgrammingParameter parameter)
{
// initialization
foreach (INode root in rootList)
{
MatchAndUpdate(root, data, parameter);
}
// dynamic programming on points
foreach (IPoint point in data.GetPoints())
{
if (point.HasNodes())
{
point.MaxNodes(); // max for dp
UpdateNeighbors(point, data, parameter); // transfer point[n] <- point[i]
}
}
}
protected List <NGlycoPeptideNode> GetMaxNodes(IDataPoints data)
{
List <NGlycoPeptideNode> nodes = new List <NGlycoPeptideNode>();
double maxScore = 0;
foreach (PeakPoint point in data.GetPoints())
{
foreach (NGlycoPeptideNode node in point.GetMaxNode())
{
double score = node.GetScore();
if (score > maxScore)
{
nodes.Clear();
nodes.Add(node);
score = maxScore;
}
else if (score == maxScore)
{
nodes.Add(node);
}
}
}
return(nodes);
}
