Esempio n. 1
0
        /// <summary>
        /// Search all glycoeptide records for a particular mass
        /// </summary>
        /// <param name="mass">Mass to be searched for</param>
        /// <param name="matched_gps">List of GPs that matched</param>
        /// <param name="check_only_sialylated">Simple filtering rule</param>
        /// <returns>TRUE/FALSE found at least one match</returns>
        /* deperecated nov 2012 public bool SearchGlycopeptides(double mass, ref  List <GlycopeptideRecord> matched_gps, bool check_only_sialylated)
        {
            bool found_match = false;
            matched_gps = new List<GlycopeptideRecord>();
            double min_ppm = _PPM_Diff;
            foreach (GlycopeptideRecord g in _glycopeptides)
            {
                bool proceed = false;
                if (check_only_sialylated)
                {
                    string comp = g.Glycan.composition;
                    if (g.Glycan.GlycanCompositionHasNeuAC(comp))
                        proceed = true;
                }
                else
                    proceed = true;

                if (proceed)
                {
                    if (_utils.CalculateDelMassPPM(g.GP_Mass, mass) < min_ppm)
                    {
                        found_match = true;
                        matched_gps.Add(g);
                    }
                }
                if (g.GP_Mass > mass + 0.5)
                    break;

            }

            return found_match;
        }*/
        /// <summary>
        ///  Function to Load all fragmentation spectra for glycopeptide ions into the map.
        /// </summary>
        /// <param name="_glycoMap"> The Map where stuff gets loaded into</param>
        /// <param name="filterGlycoPeps">Select only glycopeptides, usually set to true</param>
        /// <param name="glycanListFile">The glycan file</param>
        /// <param name="fastaFile">The FASTA file</param>
        /// <param name="gpFile">A file for glycopeptides</param>
        public void LoadFragmentationSpectraIntoMap(ref Classes.MapRecord _glycoMap, ref Classes.Params _parameters, string glycanListFile, string fastaFile, string gpFile )
        {
            List<string> DatasetNames = _glycoMap._AssociatedDatasetNames;
            List <bool> isCID = _glycoMap._IsCID;
            List <bool> isHCD = _glycoMap._IsHCD;
            List <bool> isETD = _glycoMap._IsETD;

            bool filter_glycopeptides = _parameters.ProcessOnlyNGlycopeptides;
            double max_coverage = _parameters.MaxUMCCoverage;

            GlypID.Sequence.clsSequence[] sequences = new GlypID.Sequence.clsSequence[1];
            GlypID.Glycan.clsGlycan[] glycans = new GlypID.Glycan.clsGlycan[1];
            GlypID.Glycopeptide.clsGlycopeptide GlycoPeptide = new GlypID.Glycopeptide.clsGlycopeptide();
            Classes.MapRecord _tMap = new MapRecord();

            // -- Get Glycopeptide List --//
            if (_parameters.ProcessOnlyNGlycopeptides)
            {
                if (!_parameters.UseGlycoPeptideFile)
                {
                    Console.WriteLine("Reading Glycan List");
                    try
                    {
                        GlycoPeptide.LoadGlycansFromList(glycanListFile, ref glycans, _parameters.UseDecoyGlycan);
                    }
                    catch (Exception e)
                    {
                        System.Console.WriteLine(e.Message);
                        return;
                    }
                    Console.WriteLine("Reading Fasta File");
                    GlycoPeptide.LoadNGlycopeptidesFromFasta(fastaFile, ref sequences, _parameters.UseDecoyPeptide);
                    Console.WriteLine("Setting Glycopeptides");
                    SetGlycoPeptides(ref sequences, ref glycans);  //slightly inflated*/

                    if (_parameters.CreateGlycoPeptideFile)
                    {
                        int last_pos2 = fastaFile.LastIndexOf(".");
                        string outputgpfile = fastaFile.Substring(0, last_pos2) + "_GPInfo_v2.csv";
                        Console.WriteLine("Writing to GP File");
                        WriteOutGlycopeptidesToFile(outputgpfile);
                    }
                    Console.WriteLine("Creating Hash");
                    CreateHashTableGlycopeptides(_glycoMap.MapMinMass - 1, _glycoMap.MapMaxMass + 1, true);
                }
                else
                {
                    Console.WriteLine("Reading in from GP file");
                    LoadGlycopeptidesFromFile(gpFile , _glycoMap.MapMinMass - 1, _glycoMap.MapMaxMass + 1, true );
                    Console.WriteLine("Creating Hash") ;
                    //CreateHashTableGlycopeptides(_glycoMap.MapMinMass - 1, _glycoMap.MapMaxMass + 1, false);

                }
            }

            Console.WriteLine("Loading Frag events and scoring");
            _glycopeptides.Clear();

            _glycoMap._AllMLNRecords.ForEach(delegate(MultiAlignRecord m)
            {
                bool process_mrecord = false;
                Console.WriteLine("UMC = " + m.ID) ;

                // Only load in thosse ions that match the glycopeptides list

                if (filter_glycopeptides)
                {
                    List<GlycopeptideRecord> candidate_gps = new List<GlycopeptideRecord>();
                    process_mrecord =  SearchGlycoPeptidesDictionary(m.Mass, ref candidate_gps, false);

                    if (process_mrecord)
                    {
                        /*m._CandidatePeptideSeq = new string[candidate_gps.Count];
                        m._CandidateProteinName = new string[candidate_gps.Count];
                        m._CandidateGlycanComposition = new string[candidate_gps.Count];
                        m._CandidateGlycanMass = new double[candidate_gps.Count];
                        m._CandidatePeptideMass = new double[candidate_gps.Count];
                        m._CandidateNGlycoSite = new string[candidate_gps.Count];
                        for (int i = 0; i < candidate_gps.Count; i++)
                        {
                            m._CandidateGlycanComposition[i] = candidate_gps[i].Glycan.composition;
                            m._CandidatePeptideSeq[i] = candidate_gps[i].Sequence.sequence;
                            m._CandidateProteinName[i] = candidate_gps[i].Sequence.proteinName;
                            m._CandidateGlycanMass[i] = candidate_gps[i].GlycanMonoMass;
                            m._CandidatePeptideMass[i] = candidate_gps[i].SequenceMonoMass; ;
                            m._CandidateNGlycoSite[i] = candidate_gps[i].Sequence.nGlycoSite;

                        }*/
                        m._CandidateGlycopeptideRecords = new GlycopeptideRecord[candidate_gps.Count];
                        for (int i = 0; i < candidate_gps.Count; i++)
                        {
                            m._CandidateGlycopeptideRecords[i] = candidate_gps[i];
                        }
                    }

                }
                else
                {
                    process_mrecord = true;
                }

                if (process_mrecord)
                {
                    bool store_record = false ; // This determins if the record needs to be stored
                    for (int i = 0; i < m._AssociatedUMCRecords.Count; i++)
                    {
                        // -- Start processing each umc -- //
                        UMCRecord u = m._AssociatedUMCRecords[i];
                        if (u.ScanRep == 0)
                            continue;

                        int datasetid = u.DatasetID;
                       // _RawData = new GlypID.Readers.clsRawData(DatasetNames[datasetid], GlypID.Readers.FileType.FINNIGAN);

                        double scanrange = Convert.ToDouble(u.ScanEnd - u.ScanStart);
                        int numscans = _RawData.GetNumScans();
                        double coverage = scanrange / numscans;
                        if (coverage >= max_coverage)
                        {
                            //_RawData.
                            continue;
                        }

                        // umc has passed filtering conditions so start processing each scan in umc
                        double min_ppm = 50;

                        // Process each MSn scan from start to stop of UMC
                        List<double> parents_observed = new List<double>();
                        List<FragEvents>allobserved_frag_events = new List<FragEvents>() ;
                        Classes.FragEvents e = new FragEvents();

                        double most_recent_precursor = 0;
                        int frag_id = 0;
                        for (int scan = u.ScanStart ; scan <= u.ScanEnd ; scan++)
                        {
                            if (_RawData.IsMSScan(scan))
                                continue;

                            // Start processing MSn scan
                            bool process_scan = false;
                            bool record_scan = false ;

                            // get parent
                            double parent_mz = _RawData.GetParentMz(scan);
                            short header_cs = (short) _RawData.GetParentChargeFromHeader(scan);

                            if (header_cs > 0)
                            {
                                double mass = _utils.CalculateMass(parent_mz, header_cs);
                                if (_utils.CalculateDelMassDa(mass, m.Mass) < _DA_Diff)
                                    process_scan = true;
                            }
                            else
                            {
                                // try default charge states
                                double mass1 = _utils.CalculateMass(parent_mz, 2);
                                if (_utils.CalculateDelMassDa(mass1, m.Mass) < _DA_Diff)
                                    process_scan = true;
                                double mass2 = _utils.CalculateMass(parent_mz, 3);
                                if (_utils.CalculateDelMassDa(mass2, m.Mass) < _DA_Diff)
                                    process_scan = true;
                                double mass3 = _utils.CalculateMass(parent_mz, 4);
                                if (_utils.CalculateDelMassDa(mass1, m.Mass) < _DA_Diff)
                                    process_scan = true;
                                double mass4 = _utils.CalculateMass(parent_mz, 5);
                                if (_utils.CalculateDelMassDa(mass2, m.Mass) < _DA_Diff)
                                    process_scan = true;
                                double mass5 = _utils.CalculateMass(parent_mz, 6);
                                if (_utils.CalculateDelMassDa(mass1, m.Mass) < _DA_Diff)
                                    process_scan = true;
                                double mass6 = _utils.CalculateMass(parent_mz, 7);
                                if (_utils.CalculateDelMassDa(mass2, m.Mass) < _DA_Diff)
                                    process_scan = true;
                            }
                            if (!process_scan)
                                continue;

                            // Scan has passed ALL filters
                            float[] msms_mzs = new float[1];
                            float[] msms_intensities = new float[1];
                            _RawData.GetRawData(scan, ref msms_mzs, ref msms_intensities);
                            if (_RawData.IsProfileScan(scan))
                                _MSMSPeakProcessor.ProfileType = GlypID.enmProfileType.PROFILE;
                            else
                                _MSMSPeakProcessor.ProfileType = GlypID.enmProfileType.CENTROIDED;

                            if (most_recent_precursor != parent_mz)
                            {
                                // Only deisotope if parent has not been observed

                                // Store the previous Fragmentation event
                                if (e.HCDScore < 1)
                                {
                                    /*FragEvents tEvent = new FragEvents();
                                    tEvent = e;
                                    m._AssociatedUMCRecords[i]._AssociatedFragEvents.Add(tEvent);*/
                                    allobserved_frag_events.Add(e);
                                }

                                // Clear up everything
                               /* e.ClearTransformRecord();
                                e.ClearHCD();
                                e.ClearETD();
                                e.ClearCID();
                                e.ClearGPInfo();*/
                                e = new FragEvents();
                                e.ID = frag_id;
                                frag_id++;

                                // Start over
                                parents_observed.Add(parent_mz);
                                most_recent_precursor = parent_mz;
                                float[] parent_mzs = new float[1];
                                float[] parent_intensities = new float[1];
                                Reset();

                                // ** ---- deisotope the precursor -- ** //
                                int parent_scan = _RawData.GetParentScan(scan);
                                double parent_scan_time = _RawData.GetScanTime(parent_scan);  //TODO
                                _RawData.GetRawData(parent_scan, ref parent_mzs, ref parent_intensities);

                                // Do peak finding
                                if (_RawData.IsProfileScan(parent_scan))
                                    _ParentPeakProcessor.ProfileType = GlypID.enmProfileType.PROFILE;
                                else
                                    _ParentPeakProcessor.ProfileType = GlypID.enmProfileType.CENTROIDED;
                                double thresh = GlypID.Utils.GetAverage(ref parent_intensities, float.MaxValue);
                                double background_intensity = GlypID.Utils.GetAverage(ref parent_intensities, (float)(5 * thresh));
                                _ParentPeakProcessor.SetPeakIntensityThreshold(background_intensity * _ParentPeakProcessorParams.PeakBackgroundRatio);
                                _ParentPeakProcessor.DiscoverPeaks(ref parent_mzs, ref parent_intensities, ref _ParentPeaks,
                                    Convert.ToSingle(_TransformParameters.MinMZ), Convert.ToSingle(_TransformParameters.MaxMZ), true);

                                // Pick out precursor and transform
                                double pep_intensity;
                                if (_TransformParameters.UseAbsolutePeptideIntensity)
                                    pep_intensity = _TransformParameters.AbsolutePeptideIntensity;
                                else
                                    pep_intensity = background_intensity * _TransformParameters.PeptideMinBackgroundRatio;
                                bool found = false;
                                if (_RawData.IsFTScan(parent_scan))
                                {
                                    found = _HornTransform.FindPrecursorTransform(Convert.ToSingle(background_intensity), Convert.ToSingle(pep_intensity), ref parent_mzs, ref parent_intensities,
                                        ref _ParentPeaks, Convert.ToSingle(parent_mz), ref _ParentTransformResults);
                                }
                                if (!found)
                                {
                                    // Low resolution data or bad high res spectra
                                    if (header_cs > 0)
                                    {
                                        double mono_mz = _RawData.GetParentMonoMzFromHeader(scan);
                                        if (mono_mz == 0)
                                            mono_mz = parent_mz;
                                        /*   GlypID.Peaks.clsPeak monoPeak = new GlypID.Peaks.clsPeak();
                                           _ParentPeakProcessor.GetClosestPeakMz(monoPeak, Convert.ToSingle(mono_mz));*/

                                        short[] charges = new short[1];
                                        charges[0] = header_cs;
                                        _HornTransform.AllocateValuesToTransform(Convert.ToSingle(mono_mz), 0, ref charges, ref _ParentTransformResults);
                                        found = true;
                                        record_scan = true;
                                        e.TransformResult = _ParentTransformResults[0];
                                        e.ParentMz = parent_mz;
                                        e.ParentScan = parent_scan;
                                        e.ParentScanTime = parent_scan_time;
                                    }
                                    /*else Removind this for now
                                    {
                                        // instrument has no charge just store 2 and 3.
                                        short[] charges = new short[2];
                                        charges[0] = 2;
                                        charges[1] = 3;
                                        _HornTransform.AllocateValuesToTransform(Convert.ToSingle(parent_mz), 0, ref charges, ref _ParentTransformResults);
                                    }*/
                                }
                                else
                                {
                                    double ppm = _utils.CalculateDelMassPPM(m.Mass, _ParentTransformResults[0].mdbl_mono_mw);
                                    if ((ppm <= min_ppm) || (Math.Abs(ppm - min_ppm) < 1E-05))
                                    {
                                        record_scan = true;
                                        e.TransformResult = _ParentTransformResults[0];
                                        e.ParentMz = parent_mz;
                                        e.ParentScan = parent_scan;
                                        e.ParentScanTime = parent_scan_time;
                                    }
                                }
                            }
                            else
                            {
                                if (e.TransformResult.mdbl_mono_mw > 0)
                                {
                                    // Has been deisotoped successfulle
                                    record_scan = true ;
                                }
                            }

                            //  -------- Process scan according to type   -------- //
                            if (isCID[datasetid] && _RawData.IsCIDScan(scan) && record_scan)
                            {
                                // CID scan
                                _MSMSPeakProcessor.SetPeakIntensityThreshold(0); // Since yin takes top 20 on his own.
                                _MSMSPeakProcessor.DiscoverPeaks(ref msms_mzs, ref msms_intensities, ref _MSMSPeaks, Convert.ToSingle(_TransformParameters.MinMZ), Convert.ToSingle(_TransformParameters.MaxMZ), false);
                                if (_MSMSPeaks.Length > 0)
                                {
                                    //Scoring
                                    GlypID.CIDScoring.clsCIDScoringScanResults[] tCIDScoreResults = new GlypID.CIDScoring.clsCIDScoringScanResults[1];
                                    bool found_score = _CIDScoring.ScoreCIDSpectra(ref _MSMSPeaks, ref msms_mzs, ref msms_intensities, ref _ParentTransformResults, ref tCIDScoreResults);
                                    if (found_score & tCIDScoreResults[0].mdbl_cid_score > e.CIDScore)
                                    {

                                        e.CIDScan = scan;
                                        e.CIDMzs = msms_mzs;
                                        e.CIDIntensities = msms_intensities;
                                        e.CIDPeaks = new GlypID.Peaks.clsPeak[_MSMSPeaks.Length];
                                        e.CIDProfileType = _MSMSPeakProcessor.ProfileType;
                                        e.CIDScore = tCIDScoreResults[0].mdbl_cid_score;
                                        Array.Copy(_MSMSPeaks, e.CIDPeaks, _MSMSPeaks.Length);
                                    }
                                }
                            }

                            if (isHCD[datasetid] && _RawData.IsHCDScan(scan) && record_scan)
                            {
                                // HCD Scan
                                double hcd_background_intensity = GlypID.Utils.GetAverage(ref msms_intensities, ref msms_mzs, Convert.ToSingle(_ScoringParameters.MinHCDMz), Convert.ToSingle(_ScoringParameters.MaxHCDMz));
                                _MSMSPeakProcessor.SetPeakIntensityThreshold(hcd_background_intensity);
                                _MSMSPeakProcessor.DiscoverPeaks(ref msms_mzs, ref msms_intensities, ref _MSMSPeaks, Convert.ToSingle(_ScoringParameters.MinHCDMz), Convert.ToSingle(_ScoringParameters.MaxHCDMz), false);
                                if (_MSMSPeaks.Length > 0)
                                {
                                    // Score
                                    GlypID.HCDScoring.clsHCDScoringScanResults[] tHCDScoreResults = new GlypID.HCDScoring.clsHCDScoringScanResults[1];
                                    double score = _HCDScoring.ScoreHCDSpectra(ref _MSMSPeaks, ref msms_mzs, ref msms_intensities, ref _ParentTransformResults, ref tHCDScoreResults);
                                    if (score < e.HCDScore) // This makes sure that within frag events of the same parent, the lowest one is chosen
                                    {
                                        // Store
                                        store_record = true;

                                        e.HCDScan = scan;
                                        e.HCDMzs = msms_mzs;
                                        e.HCDIntensities = msms_intensities;
                                        e.HCDPeaks = new GlypID.Peaks.clsPeak[_MSMSPeaks.Length];
                                        /*m._AssociatedUMCRecords[i].HCDScanRep = scan;
                                        m._AssociatedUMCRecords[i].HCDScanRepET = _RawData.GetScanTime(scan);*/
                                        e.HCDProfileType = _MSMSPeakProcessor.ProfileType;
                                        Array.Copy(_MSMSPeaks, e.HCDPeaks, _MSMSPeaks.Length);
                                        e.HCDScore = tHCDScoreResults[0].mdbl_hcd_score;
                                        e.GlycanType = (GlypID.enmGlycanType) tHCDScoreResults[0].menm_glycan_type ;

                                    }
                                }
                            }

                            if (isETD[datasetid] && _RawData.IsETDScan(scan) && record_scan)
                            {

                                // ETD Scan
                                _MSMSPeakProcessor.SetPeakIntensityThreshold(0);
                                _MSMSPeakProcessor.ProfileType = GlypID.enmProfileType.CENTROIDED;
                                _MSMSPeakProcessor.DiscoverPeaks(ref msms_mzs, ref msms_intensities, ref _MSMSPeaks,
                                    0, Convert.ToSingle(parent_mz), false);

                                if ((_MSMSPeaks.Length > 1) && (e.HCDScore <1))
                                {
                                    // Score
                                    int best_scoring_index = -1;
                                    double max_score = 0;

                                    for (int k = 0; k < m._CandidateGlycopeptideRecords.Length; k++)
                                    {
                                        // Confirm glycan type matches with HCD prediction
                                        bool process_result = false;
                                        if ((e.GlycanType == GlypID.enmGlycanType.CS) || e.GlycanType == GlypID.enmGlycanType.HY)
                                        {
                                            if (m._CandidateGlycopeptideRecords[k].Glycan.numNeuAc >0)
                                                process_result = true;
                                            else
                                                process_result = false;
                                        }
                                        else
                                            process_result = true;

                                        // Stupidly planned type conversion ; Just doing the bare minimum
                                        GlypID.ETDScoring.clsETDScoringScanResults thisResult = new GlypID.ETDScoring.clsETDScoringScanResults();
                                        thisResult.mdbl_parent_mz = e.ParentMz;
                                        thisResult.mdbl_mono_mw = e.TransformResult.mdbl_mono_mw;
                                        thisResult.mshort_cs = e.TransformResult.mshort_cs;
                                        thisResult.mstr_glyco_site = m._CandidateGlycopeptideRecords[k].Sequence.nGlycoSite;
                                        thisResult.mstr_nglyco_site = m._CandidateGlycopeptideRecords[k].Sequence.nGlycoSite;
                                        thisResult.mstr_pep_seq = m._CandidateGlycopeptideRecords[k].Sequence.sequence;
                                        thisResult.mdbl_glycan_mass = m._CandidateGlycopeptideRecords[k].GlycanMonoMass;

                                        if (thisResult.mstr_pep_seq != "" && process_result)
                                        {
                                            double etd_score = _ETDScoring.ScoreETDSpectra(ref _MSMSPeaks, thisResult);
                                            if (etd_score >= max_score)
                                            {
                                                thisResult.mdbl_etd_score = etd_score;
                                                best_scoring_index = k;
                                                max_score = etd_score;
                                            }
                                        }
                                    }

                                    // Store
                                    if ((best_scoring_index != -1) && (max_score > e.ETDScore))
                                    {
                                        // Store
                                        e.ETDScan = scan;
                                        e.ETDMzs = msms_mzs;
                                        e.ETDIntensities = msms_intensities;
                                        e.ETDPeaks = new GlypID.Peaks.clsPeak[_MSMSPeaks.Length];
                                        Array.Copy(_MSMSPeaks, e.ETDPeaks, _MSMSPeaks.Length);

                                        e.ETDScore = max_score;
                                        e.GP_Record = m._CandidateGlycopeptideRecords[best_scoring_index];
                                        e.FalseHit = e.GP_Record.IsDecoy;

                                       /* if (e.FalseHit)
                                            _tMap._AllFalseHitsFDRScore.Add(e.ETDScore);
                                        else
                                            _tMap._AllTrueHitsFDRScore.Add(e.ETDScore) ; */

                                        // m._AssociatedUMCRecords[i].ETDScanRep = scan;

                                    }
                                }
                            }
                        }
                        // Store the most recent fragmentation event
                        if (e.HCDScore < 1)
                        {
                            /*FragEvents tEvent = new FragEvents(e);
                            m._AssociatedUMCRecords[i]._AssociatedFragEvents.Add(tEvent);*/
                            allobserved_frag_events.Add(e);
                        }
                       //  _RawData.Close();

                        m._AssociatedUMCRecords[i]._AssociatedFragEvents.Clear();
                        for (int kk = 0; kk < allobserved_frag_events.Count; kk++)
                        {
                            FragEvents tempE = allobserved_frag_events[kk] ; //as FragEvents;
                            m._AssociatedUMCRecords[i]._AssociatedFragEvents.Add(tempE);
                        }
                        m._AssociatedUMCRecords[i].SetRepScores();
                    }
                    if (store_record)
                        _tMap.AddRecord(m);

                }

            });

            if (_tMap._AllMLNRecords.Count != _glycoMap._AllMLNRecords.Count)
            {
                _glycoMap.ClearRecords();
                for (int k = 0; k < _tMap._AllMLNRecords.Count; k++)
                {
                    _glycoMap.AddRecord(_tMap._AllMLNRecords[k]);
                }
            }
               // _glycoMap._AllTrueHitsFDRScore = _tMap._AllTrueHitsFDRScore;
            //_glycoMap._AllFalseHitsFDRScore = _tMap._AllFalseHitsFDRScore;

            _tMap.ClearRecords();
        }
Esempio n. 2
0
        /// <summary>
        /// Function to cluster CID spectra in each record.  
        /// </summary>
        /// <param name="_glycoMap"></param>
        /// <param name="_params"></param>
        public void ClusterRecordsOnCID(ref Classes.MapRecord _glycoMap, ref Classes.Params _params)
        {
            Classes.MapRecord _tempMap = new MapRecord();
            _tempMap._AssociatedDatasetNames = _glycoMap._AssociatedDatasetNames;
            _tempMap._IsCID = _glycoMap._IsCID;
            _tempMap._IsETD = _glycoMap._IsETD;
            _tempMap._IsHCD = _glycoMap._IsHCD;

            int Id = 0;

            FragEvents tempE = new FragEvents();

            for (int i = 0; i < _glycoMap._AllMLNRecords.Count; i++)
            {
                MultiAlignRecord m = new MultiAlignRecord();
                m = _glycoMap._AllMLNRecords[i];
                int num_records = m._AssociatedUMCRecords.Count;

                short mincs = m.MinChargeStateObserved();
                short maxcs = m.MaxChargeStateObserved();

                for (short thiscs = mincs; thiscs <= maxcs; thiscs++)
                {
                    int spectra_num = 0;
                    string cum_spectra_names = null;
                    List<string> cluster_names = new List<string>();
                    List<int> orphan_ids = new List<int>();
                    for (int j = 0; j < num_records; j++)
                    {
                        if (m._AssociatedUMCRecords[j]._AssociatedFragEvents.Count == 0)
                        {
                            // Not fragmented in this UMC but keep track of this  but

                            // // This happens which means there was no fragmentation event then (or) HCD score was bad
                            if (m._AssociatedUMCRecords[j].Abundance > 0)
                                orphan_ids.Add(m._AssociatedUMCRecords[j].DatasetID);
                        }
                        for (int k = 0; k < m._AssociatedUMCRecords[j]._AssociatedFragEvents.Count; k++)
                        {
                            if ((m._AssociatedUMCRecords[j]._AssociatedFragEvents[k].CIDPeaks[0] != null) &&
                                (m._AssociatedUMCRecords[j]._AssociatedFragEvents[k].TransformResult.mshort_cs == thiscs))
                            {
                                string spectra_name = "Spectra_" + m._AssociatedUMCRecords[j].DatasetID + "_" + m._AssociatedUMCRecords[j]._AssociatedFragEvents[k].ID + "_" +
                                    spectra_num + "_" + m._AssociatedUMCRecords[j]._AssociatedFragEvents[k].CIDScan;

                                GlypID.Peaks.clsPeak[] thisCIDPeaks = new GlypID.Peaks.clsPeak[m._AssociatedUMCRecords[j]._AssociatedFragEvents[k].CIDPeaks.Length];
                                Array.Copy(m._AssociatedUMCRecords[j]._AssociatedFragEvents[k].CIDPeaks, thisCIDPeaks, m._AssociatedUMCRecords[j]._AssociatedFragEvents[k].CIDPeaks.Length);
                                _CIDSpectralUtilities.AddPeaksToList(ref thisCIDPeaks, spectra_name);
                                spectra_num++;
                                if (cum_spectra_names != null)
                                    cum_spectra_names = cum_spectra_names + "-" + spectra_name;
                                else
                                    cum_spectra_names = spectra_name;
                            }
                        }
                    }

                    int num_clusters = _CIDSpectralUtilities.ClusterSpectraInList();
                    _CIDSpectralUtilities.GetClusterNames(ref cluster_names);

                    if (num_clusters > 1)
                    {
                        // Indicates glycoforms
                        bool debug = true;
                        debug = true;
                    }

                    for (int c = 0; c < num_clusters; c++)
                    {
                        m._ClusterNames.Add(cluster_names[c]);
                    }

                    _CIDSpectralUtilities.Clear();
                }
                _tempMap.AddRecord(m);
            }
                 // Restore them.
            _glycoMap.ClearRecords();
            for (int i = 0; i < _tempMap._AllMLNRecords.Count; i++)
            {
                _glycoMap.AddRecord(_tempMap._AllMLNRecords[i]);
            }

                    /*else
                    {
                        /* MultiAlignRecord _tempM = new MultiAlignRecord(m);
                         _tempM.ID = Id;
                         _tempMap.AddRecord(_tempM);
                         Id++; */

                    /* if (cum_spectra_names != null)
                     {
                         // Choose the spectra with the greatest SNR
                         num_clusters = 1;
                         cluster_names.Add(cum_spectra_names);
                         _CIDSpectralUtilities.AssignClusters(ref cluster_names);
                     }
                 }*/

                   /* for (int k = 0; k < num_clusters; k++)
                    {
                        // ----- Get a representative spectrum index for each cluster ---//
                        MultiAlignRecord _tempM = new MultiAlignRecord(m);
                        _tempM.ID = Id;
                        _tempM._AssociatedUMCRecords.Clear();

                        GlypID.Peaks.clsPeak[] repCIDPeaks = new GlypID.Peaks.clsPeak[0];
                        int repOrigIndex = _CIDSpectralUtilities.GetRepresentativePeaksFromCluster(k, ref repCIDPeaks, _params.ScoringParams.MinCIDMz, _params.ScoringParams.MaxCIDMz, true);
                        if (repCIDPeaks.Length > 1)
                        {
                            _tempM._RepresentativeCIDPeaks = repCIDPeaks;
                            _tempM._RepresentativeDatasetID_CID = repOrigIndex;
                        }
                        // Attach UMCs corresponding to that cluster.
                        List<int> allOrigIDs = new List<int>();
                        _CIDSpectralUtilities.GetOriginalIDFromCluster(k, ref allOrigIDs);
                        for (int j = 0; j < num_records; j++)
                        {
                            int id = m._AssociatedUMCRecords[j].DatasetID;
                            if (allOrigIDs.Exists(element => element == id))
                            {
                                UMCRecord _tempUMC = new UMCRecord();
                                _tempUMC = m._AssociatedUMCRecords[j];
                                _tempM._AssociatedUMCRecords.Add(_tempUMC);
                            }
                            else if (orphan_ids.Exists(element => element == id)) // This takes care of non fragmentation but still has stuff present
                            {
                                UMCRecord _tempUMC = new UMCRecord();
                                _tempUMC = m._AssociatedUMCRecords[j];
                                _tempM._AssociatedUMCRecords.Add(_tempUMC);
                            }

                        }

                        _tempMap.AddRecord(_tempM);
                        Id++;
                    }*/
        }