public static IIdentifiedResult DoBuildGroupByPeptide(List <IIdentifiedSpectrum> spectra, Func <IIdentifiedPeptide, string> func)
        {
            IdentifiedResult result = new IdentifiedResult();

            var singlePeptides = (from s in spectra
                                  where s.Peptides.Count == 1
                                  select s).GroupBy(m => func(m.Peptide));

            var multiplePeptides = (from s in spectra
                                    where s.Peptides.Count > 1
                                    select s).ToList();

            Dictionary <string, List <IIdentifiedPeptide> > dic = new Dictionary <string, List <IIdentifiedPeptide> >();

            foreach (var g in singlePeptides)
            {
                dic[g.Key] = new List <IIdentifiedPeptide>(from s in g
                                                           select s.Peptide);
            }

            foreach (var o in multiplePeptides)
            {
                var pc = (from p in o.Peptides
                          let c = dic.ContainsKey(func(p)) ? dic[func(p)].Count : 0
                                  orderby c descending
                                  select p).First();
                if (!dic.ContainsKey(func(pc)))
                {
                    dic[func(pc)] = new List <IIdentifiedPeptide>();
                }
                dic[func(pc)].Add(pc);
            }

            var keys = new List <string>(dic.Keys);

            keys.Sort();

            foreach (var key in keys)
            {
                IdentifiedProtein protein = new IdentifiedProtein(key);
                protein.Peptides.AddRange(dic[key]);
                protein.UniquePeptideCount = 1;
                protein.Description        = dic[key][0].Proteins.Merge('/');

                IdentifiedProteinGroup group = new IdentifiedProteinGroup();
                group.Add(protein);

                result.Add(group);
            }

            result.BuildGroupIndex();
            //result.Sort();

            return(result);
        }
        public IIdentifiedResult Build(List <IIdentifiedProteinGroup> groups)
        {
            IdentifiedResult result = new IdentifiedResult();

            result.AddRange(groups);
            result.Sort();
            result.BuildGroupIndex();

            if (FillSequence(result))
            {
                AveragePeptideMassCalculator massCalc = new AveragePeptideMassCalculator(new Aminoacids(), Atom.H.AverageMass, Atom.H.AverageMass + Atom.O.AverageMass);

                Progress.SetMessage("Calculating coverage and mass weight ...");
                foreach (IIdentifiedProteinGroup group in result)
                {
                    foreach (IIdentifiedProtein protein in group)
                    {
                        if (!string.IsNullOrEmpty(protein.Sequence))
                        {
                            try
                            {
                                protein.CalculateCoverage();
                                protein.MolecularWeight = massCalc.GetMass(protein.Sequence);
                            }
                            catch (Exception ex)
                            {
                                var error = "Calculating coverage and mass weight error:" + ex.Message;
                                Progress.SetMessage(error);
                                Console.Error.WriteLine(error);
                            }
                        }
                    }
                }
            }

            return(result);
        }