Example #1
0
        private MSScan GetMSScan(int argScanNo)
        {
            MSScan msScan = new MSScan(argScanNo);
            // GlypID.Readers.clsRawData rawData = new GlypID.Readers.clsRawData() ; 
            GlypID.HornTransform.clsHornTransform massTransform = new GlypID.HornTransform.clsHornTransform();
            GlypID.Peaks.clsPeakProcessor peakProcessor = new GlypID.Peaks.clsPeakProcessor();

            GlypID.HornTransform.clsHornTransformParameters transform_parameters = new GlypID.HornTransform.clsHornTransformParameters();
            GlypID.Peaks.clsPeakProcessorParameters peak_parameters = new GlypID.Peaks.clsPeakProcessorParameters();


            // Declarations
            float[] _mzs = null;
            float[] _intensities = null;
            GlypID.Peaks.clsPeak[] peaks;
            GlypID.HornTransform.clsHornTransformResults[] _transformResults;

            // Settings
            peak_parameters.SignalToNoiseThreshold = 3.0;
            peak_parameters.PeakBackgroundRatio = 5.0;

            peakProcessor.SetOptions(peak_parameters);
            peakProcessor.ProfileType = GlypID.enmProfileType.PROFILE;
            transform_parameters.PeptideMinBackgroundRatio = 5.0;
            transform_parameters.MaxCharge = 10;
            massTransform.TransformParameters = transform_parameters;



            // Load
            Raw = new GlypID.Readers.clsRawData(_fullFilePath, GlypID.Readers.FileType.FINNIGAN);


            if (Raw.GetMSLevel(argScanNo) == 1)
            {
                // Get spectra
                Raw.GetSpectrum(argScanNo, ref _mzs, ref _intensities);

                // Get peaks
                peaks = new GlypID.Peaks.clsPeak[1];
                peakProcessor.DiscoverPeaks(ref _mzs, ref _intensities, ref peaks, Convert.ToSingle(transform_parameters.MinMZ), Convert.ToSingle(transform_parameters.MaxMZ), true);

                // Deisotope
                double min_background_intensity = peakProcessor.GetBackgroundIntensity(ref _intensities);
                double min_peptide_intensity = min_background_intensity * transform_parameters.PeptideMinBackgroundRatio;

                _transformResults = new GlypID.HornTransform.clsHornTransformResults[1];
                massTransform.PerformTransform(Convert.ToSingle(min_background_intensity), Convert.ToSingle(min_peptide_intensity), ref _mzs, ref _intensities, ref peaks, ref _transformResults);

                Array.Clear(_transformResults, 0, _transformResults.Length);
                Array.Clear(peaks, 0, peaks.Length);
            }


            return msScan;
        }
Example #2
0
        public XRawReader(string argFullFilePath)
        {
            _fullFilePath = argFullFilePath;
            Raw = new GlypID.Readers.clsRawData(_fullFilePath, GlypID.Readers.FileType.FINNIGAN);

               mobjTransform = new GlypID.HornTransform.clsHornTransform(); //12KB
            mobjTransformParameters = new GlypID.HornTransform.clsHornTransformParameters(); //4KB
            _transformResult = new GlypID.HornTransform.clsHornTransformResults[1];
            cidPeakProcessor = new GlypID.Peaks.clsPeakProcessor(); //68KB
            cidPeakParameters = new GlypID.Peaks.clsPeakProcessorParameters();
            parentPeakProcessor = new GlypID.Peaks.clsPeakProcessor();
            parentPeakParameters = new GlypID.Peaks.clsPeakProcessorParameters();
        }
Example #3
0
        public XRawReader(string argFullFilePath)
        {
            _fullFilePath = argFullFilePath;
            Raw           = new GlypID.Readers.clsRawData(_fullFilePath, GlypID.Readers.FileType.FINNIGAN);

            mobjTransform           = new GlypID.HornTransform.clsHornTransform();           //12KB
            mobjTransformParameters = new GlypID.HornTransform.clsHornTransformParameters(); //4KB
            _transformResult        = new GlypID.HornTransform.clsHornTransformResults[1];
            cidPeakProcessor        = new GlypID.Peaks.clsPeakProcessor();                   //68KB
            cidPeakParameters       = new GlypID.Peaks.clsPeakProcessorParameters();
            parentPeakProcessor     = new GlypID.Peaks.clsPeakProcessor();
            parentPeakParameters    = new GlypID.Peaks.clsPeakProcessorParameters();
        }
Example #4
0
        public MapCreator()
        {
            _GlycoMap = new Classes.MapRecord() ;
            _utils = new Utilities();
             _glycopeptides = new List<GlycopeptideRecord> ();

            _TransformParameters = new GlypID.HornTransform.clsHornTransformParameters() ;
            _ParentPeakProcessorParams = new GlypID.Peaks.clsPeakProcessorParameters() ;
            _MSMSPeakProcessorParams = new GlypID.Peaks.clsPeakProcessorParameters() ;
            _ScoringParameters = new GlypID.Scoring.clsScoringParameters();

            _HornTransform = new GlypID.HornTransform.clsHornTransform() ;
            _ParentPeakProcessor = new GlypID.Peaks.clsPeakProcessor() ;
            _MSMSPeakProcessor = new GlypID.Peaks.clsPeakProcessor() ;

            _ParentPeaks = new GlypID.Peaks.clsPeak[1] ;
            _MSMSPeaks = new GlypID.Peaks.clsPeak[1];
            _ParentTransformResults = new GlypID.HornTransform.clsHornTransformResults[1];
            _dGlycopeptides = new Dictionary<int, List<GlycopeptideRecord>>();

            _CIDScoring = new GlypID.CIDScoring.clsCIDScoring();
            _HCDScoring = new GlypID.HCDScoring.clsHCDScoring();
            _ETDScoring = new GlypID.ETDScoring.clsETDScoring();
        }
Example #5
0
        private static MSScan GetScanFromFile(int argScanNo, double argSingleToNoise, double argPeakBackground, double argPeptideBackground, short argMaxCharge, GlypID.Readers.clsRawData Raw)
        {
            float[] _cidMzs = null;
            float[] _cidIntensities = null;
            GlypID.Peaks.clsPeak[] _cidPeaks = new GlypID.Peaks.clsPeak[1];
            GlypID.Peaks.clsPeak[] _parentPeaks = new GlypID.Peaks.clsPeak[1];

            GlypID.HornTransform.clsHornTransform mobjTransform = new GlypID.HornTransform.clsHornTransform();
            GlypID.HornTransform.clsHornTransformParameters mobjTransformParameters = new GlypID.HornTransform.clsHornTransformParameters() ;
            GlypID.HornTransform.clsHornTransformResults[] _transformResult;

            GlypID.Peaks.clsPeakProcessor cidPeakProcessor = new GlypID.Peaks.clsPeakProcessor();
            GlypID.Peaks.clsPeakProcessorParameters cidPeakParameters = new GlypID.Peaks.clsPeakProcessorParameters();

            GlypID.Peaks.clsPeakProcessor parentPeakProcessor = new GlypID.Peaks.clsPeakProcessor() ;
            GlypID.Peaks.clsPeakProcessorParameters parentPeakParameters = new GlypID.Peaks.clsPeakProcessorParameters();

            //Start Read Scan
            MSScan scan = new MSScan(argScanNo);

            Raw.GetSpectrum(argScanNo, ref _cidMzs, ref  _cidIntensities);
            scan.MsLevel = Raw.GetMSLevel(Convert.ToInt32(argScanNo));

            double min_peptide_intensity = 0;
            scan.Time = Raw.GetScanTime(scan.ScanNo);
            scan.ScanHeader = Raw.GetScanDescription(scan.ScanNo);
            if (scan.MsLevel != 1)
            {
                float[] _parentRawMzs = null;
                float[] _parentRawIntensitys = null;

                string Header = Raw.GetScanDescription(argScanNo);
                cidPeakProcessor.ProfileType = GlypID.enmProfileType.CENTROIDED;
                if (Header.Substring(Header.IndexOf("+") + 1).Trim().StartsWith("p"))
                {
                    cidPeakProcessor.ProfileType = GlypID.enmProfileType.PROFILE;
                }

                // cidPeakProcessor.DiscoverPeaks(ref _cidMzs, ref _cidIntensities, ref _cidPeaks,
                //         Convert.ToSingle(mobjTransformParameters.MinMZ), Convert.ToSingle(mobjTransformParameters.MaxMZ), false);

                for (int chNum = 0; chNum < _cidMzs.Length; chNum++)
                {
                    scan.MSPeaks.Add(new MSPeak(
                        Convert.ToSingle(_cidMzs[chNum]),
                        Convert.ToSingle(_cidIntensities[chNum])));
                }

                //for (int chNum = 0; chNum < _cidMzs.Length; chNum++)
                //{
                //    scan.MSPeaks.Add(new MSPeak(
                //        Convert.ToSingle(_cidMzs[chNum]),
                //        Convert.ToSingle(_cidIntensities[chNum])));
                //}

                // Get parent information
                scan.ParentScanNo = Raw.GetParentScan(scan.ScanNo);

                Raw.GetSpectrum(scan.ParentScanNo, ref _parentRawMzs, ref _parentRawIntensitys);
                parentPeakProcessor.ProfileType = GlypID.enmProfileType.PROFILE;
                parentPeakProcessor.DiscoverPeaks(ref _parentRawMzs, ref _parentRawIntensitys, ref _parentPeaks, Convert.ToSingle(mobjTransformParameters.MinMZ), Convert.ToSingle(mobjTransformParameters.MaxMZ), true);
                float _parentBackgroundIntensity = (float)parentPeakProcessor.GetBackgroundIntensity(ref _parentRawIntensitys);
                _transformResult = new GlypID.HornTransform.clsHornTransformResults[1];
                bool found = false;
                if (Raw.IsFTScan(scan.ParentScanNo))
                {
                    // High resolution data
                    found = mobjTransform.FindPrecursorTransform(Convert.ToSingle(_parentBackgroundIntensity), Convert.ToSingle(min_peptide_intensity), ref _parentRawMzs, ref _parentRawIntensitys, ref _parentPeaks, Convert.ToSingle(scan.ParentMZ), ref _transformResult);
                }
                if (!found)//de-isotope fail
                {
                    // Low resolution data or bad high res spectra
                    short cs = Raw.GetMonoChargeFromHeader(scan.ScanNo);
                    double monoMZ = Raw.GetMonoMzFromHeader(scan.ScanNo);
                    List<float> ParentMzs = new List<float>(_parentRawMzs);
                    int CloseIdx = MassUtility.GetClosestMassIdx(ParentMzs, Convert.ToSingle(monoMZ));

                    if (cs > 0)
                    {
                        short[] charges = new short[1];
                        charges[0] = cs;
                        mobjTransform.AllocateValuesToTransform(Convert.ToSingle(scan.ParentMZ), Convert.ToInt32(_parentRawIntensitys[CloseIdx]), ref charges, ref _transformResult);
                    }
                    else
                    {
                        // instrument has no charge just store 2 and 3.
                        short[] charges = new short[2];
                        charges[0] = 2;
                        charges[1] = 3;
                        mobjTransform.AllocateValuesToTransform(Convert.ToSingle(scan.ParentMZ), Convert.ToInt32(_parentRawIntensitys[CloseIdx]), ref charges, ref _transformResult);
                    }
                }

                if (_transformResult[0].mint_peak_index == -1) //De-isotope parent scan
                {
                    //Get parent info
                    MSScan _parentScan = GetScanFromFile(scan.ParentScanNo, argSingleToNoise, argPeakBackground, argPeptideBackground, argMaxCharge,Raw);
                    float[] _MSMzs = null;
                    float[] _MSIntensities = null;

                    Raw.GetSpectrum(scan.ParentScanNo, ref _MSMzs, ref  _MSIntensities);
                    // Now find peaks
                    parentPeakParameters.SignalToNoiseThreshold = 0;
                    parentPeakParameters.PeakBackgroundRatio = 0.01;
                    parentPeakProcessor.SetOptions(parentPeakParameters);
                    parentPeakProcessor.ProfileType = GlypID.enmProfileType.PROFILE;

                    parentPeakProcessor.DiscoverPeaks(ref _MSMzs, ref _MSIntensities, ref _cidPeaks,
                                            Convert.ToSingle(mobjTransformParameters.MinMZ), Convert.ToSingle(mobjTransformParameters.MaxMZ), true);

                    //Look for charge and mono.

                    float[] monoandcharge = FindChargeAndMono(_cidPeaks, Convert.ToSingle(Raw.GetParentMz(scan.ScanNo)), scan.ScanNo,Raw);
                    //scan.ParentMonoMW = _parentScan.MSPeaks[ClosedIdx].MonoMass;
                    //scan.ParentAVGMonoMW = _parentScan.MSPeaks[ClosedIdx].;
                    scan.ParentMZ = monoandcharge[0];
                    if (monoandcharge[1] == 0.0f)
                    {
                        scan.ParentCharge = Convert.ToInt32(Raw.GetMonoChargeFromHeader(scan.ParentScanNo));
                    }
                    else
                    {
                        scan.ParentCharge = Convert.ToInt32(monoandcharge[1]);
                    }

                    scan.ParentMonoMW = (monoandcharge[0] - Atoms.ProtonMass) * monoandcharge[1];

                }
                else
                {
                    scan.ParentMonoMW = (float)_transformResult[0].mdbl_mono_mw;
                    scan.ParentAVGMonoMW = (float)_transformResult[0].mdbl_average_mw;
                    scan.ParentMZ = (float)_transformResult[0].mdbl_mz;
                    scan.ParentCharge = (int)_transformResult[0].mshort_cs;
                }
                scan.IsCIDScan = Raw.IsCIDScan(argScanNo);
                scan.IsFTScan = Raw.IsFTScan(argScanNo);

                Array.Clear(_transformResult, 0, _transformResult.Length);
                Array.Clear(_cidPeaks, 0, _cidPeaks.Length);
                Array.Clear(_cidMzs, 0, _cidMzs.Length);
                Array.Clear(_cidIntensities, 0, _cidIntensities.Length);
                Array.Clear(_parentRawMzs, 0, _parentRawMzs.Length);
                Array.Clear(_parentRawIntensitys, 0, _parentRawIntensitys.Length);
            }
            else //MS Scan
            {
                scan.ParentMZ = 0.0f;
                double mdbl_current_background_intensity = 0;

                // Now find peaks
                parentPeakParameters.SignalToNoiseThreshold = argSingleToNoise;
                parentPeakParameters.PeakBackgroundRatio = argPeakBackground;
                parentPeakProcessor.SetOptions(parentPeakParameters);
                parentPeakProcessor.ProfileType = GlypID.enmProfileType.PROFILE;

                parentPeakProcessor.DiscoverPeaks(ref _cidMzs, ref _cidIntensities, ref _cidPeaks,
                                        Convert.ToSingle(mobjTransformParameters.MinMZ), Convert.ToSingle(mobjTransformParameters.MaxMZ), true);
                mdbl_current_background_intensity = parentPeakProcessor.GetBackgroundIntensity(ref _cidIntensities);

                // Settings
                min_peptide_intensity = mdbl_current_background_intensity * mobjTransformParameters.PeptideMinBackgroundRatio;
                if (mobjTransformParameters.UseAbsolutePeptideIntensity)
                {
                    if (min_peptide_intensity < mobjTransformParameters.AbsolutePeptideIntensity)
                        min_peptide_intensity = mobjTransformParameters.AbsolutePeptideIntensity;
                }
                mobjTransformParameters.PeptideMinBackgroundRatio = argPeptideBackground;
                mobjTransformParameters.MaxCharge = argMaxCharge;
                mobjTransform.TransformParameters = mobjTransformParameters;

                //  Now perform deisotoping
                _transformResult = new GlypID.HornTransform.clsHornTransformResults[1];
                mobjTransform.PerformTransform(Convert.ToSingle(mdbl_current_background_intensity), Convert.ToSingle(min_peptide_intensity), ref _cidMzs, ref _cidIntensities, ref _cidPeaks, ref _transformResult);
                // for getting results

                for (int chNum = 0; chNum < _transformResult.Length; chNum++)
                {
                    double sumintensity = 0.0;
                    double mostIntenseIntensity = 0.0;
                    for (int i = 0; i < _transformResult[chNum].marr_isotope_peak_indices.Length; i++)
                    {
                        sumintensity = sumintensity + _cidPeaks[_transformResult[chNum].marr_isotope_peak_indices[i]].mdbl_intensity;
                        if (Math.Abs(_transformResult[chNum].mdbl_most_intense_mw -
                            (_cidPeaks[_transformResult[chNum].marr_isotope_peak_indices[i]].mdbl_mz * _transformResult[chNum].mshort_cs - Atoms.ProtonMass * _transformResult[chNum].mshort_cs))
                            < 1.0 / _transformResult[chNum].mshort_cs)
                        {
                            mostIntenseIntensity = _cidPeaks[_transformResult[chNum].mint_peak_index].mdbl_intensity;
                        }
                    }
                    scan.MSPeaks.Add(new MSPeak(
                    Convert.ToSingle(_transformResult[chNum].mdbl_mono_mw),
                    _transformResult[chNum].mint_mono_intensity,
                    _transformResult[chNum].mshort_cs,
                    Convert.ToSingle(_transformResult[chNum].mdbl_mz),
                    Convert.ToSingle(_transformResult[chNum].mdbl_fit),
                    Convert.ToSingle(_transformResult[chNum].mdbl_most_intense_mw),
                    mostIntenseIntensity,
                    sumintensity
                    ));
                }
                Array.Clear(_transformResult, 0, _transformResult.Length);
                Array.Clear(_cidPeaks, 0, _cidPeaks.Length);
                Array.Clear(_cidMzs, 0, _cidMzs.Length);
                Array.Clear(_cidIntensities, 0, _cidIntensities.Length);
            }
            return scan;
        }
Example #6
0
        /// <summary>
        /// No HCD info the return will be null
        /// </summary>
        /// <param name="argReader"></param>
        /// <param name="argScanNo"></param>
        /// <returns></returns>
        private static HCDInfo GetHCDInfo(GlypID.Readers.clsRawData argReader, int argScanNo)
        {
            if(!argReader.IsHCDScan(argScanNo))
            {
                return null;
            }
            HCDInfo HCDinfo = null;
            double _hcd_score;
            GlypID.enmGlycanType _gType;
            int ParentScan = argReader.GetParentScan(argScanNo);
            // Scorers and transforms
            GlypID.HCDScoring.clsHCDScoring HCDScoring = new GlypID.HCDScoring.clsHCDScoring();
            GlypID.HornTransform.clsHornTransform Transform = new GlypID.HornTransform.clsHornTransform();

            // mzs , intensities
            float[] hcd_mzs = null;
            float[] hcd_intensities = null;
            float[] parent_mzs = null;
            float[] parent_intensities = null;

            // Peaks
            GlypID.Peaks.clsPeak[] parent_peaks;
            GlypID.Peaks.clsPeak[] hcd_peaks;

            // Peak Processors
            GlypID.Peaks.clsPeakProcessor hcdPeakProcessor = new GlypID.Peaks.clsPeakProcessor();
            GlypID.Peaks.clsPeakProcessor parentPeakProcessor = new GlypID.Peaks.clsPeakProcessor();

            // Results
            GlypID.HCDScoring.clsHCDScoringScanResults[] hcd_scoring_results;
            GlypID.HornTransform.clsHornTransformResults[] transform_results;

            // Params
            GlypID.Scoring.clsScoringParameters scoring_parameters = new GlypID.Scoring.clsScoringParameters();
            GlypID.HornTransform.clsHornTransformParameters transform_parameters = new GlypID.HornTransform.clsHornTransformParameters();
            scoring_parameters.MinNumPeaksToConsider = 2;
            scoring_parameters.PPMTolerance = 10;
            scoring_parameters.UsePPM = true;

            // Init
            Transform.TransformParameters = transform_parameters;

            // Loading parent
            int parent_scan = argReader.GetParentScan(argScanNo);
            double parent_mz = argReader.GetParentMz(argScanNo);
            int scan_level = argReader.GetMSLevel(argScanNo);
            int parent_level = argReader.GetMSLevel(parent_scan);
            argReader.GetSpectrum(parent_scan, ref parent_mzs, ref parent_intensities);

            // Parent processing
            parent_peaks = new GlypID.Peaks.clsPeak[1];
            parentPeakProcessor.ProfileType = GlypID.enmProfileType.PROFILE;
            parentPeakProcessor.DiscoverPeaks(ref parent_mzs, ref parent_intensities, ref parent_peaks,
                        Convert.ToSingle(transform_parameters.MinMZ), Convert.ToSingle(transform_parameters.MaxMZ), true);
            double bkg_intensity = parentPeakProcessor.GetBackgroundIntensity(ref parent_intensities);
            double min_peptide_intensity = bkg_intensity * transform_parameters.PeptideMinBackgroundRatio;

            transform_results = new GlypID.HornTransform.clsHornTransformResults[1];
            bool found = Transform.FindPrecursorTransform(Convert.ToSingle(bkg_intensity), Convert.ToSingle(min_peptide_intensity), ref parent_mzs, ref parent_intensities, ref parent_peaks, Convert.ToSingle(parent_mz), ref transform_results);
            if (!found && (argReader.GetMonoChargeFromHeader(ParentScan) > 0))
            {
                found = true;
                double mono_mz = argReader.GetMonoMzFromHeader(ParentScan);
                if (mono_mz == 0)
                    mono_mz = parent_mz;

                short[] charges = new short[1];
                charges[0] = argReader.GetMonoChargeFromHeader(ParentScan);
                Transform.AllocateValuesToTransform(Convert.ToSingle(mono_mz), 0, ref charges, ref transform_results); // Change abundance value from 0 to parent_intensity if you wish
            }
            if (found && transform_results.Length == 1)
            {
                // Score HCD scan first
                argReader.GetSpectrum(argScanNo, ref hcd_mzs, ref hcd_intensities);
                double hcd_background_intensity = GlypID.Utils.GetAverage(ref hcd_intensities, ref  hcd_mzs, Convert.ToSingle(scoring_parameters.MinHCDMz), Convert.ToSingle(scoring_parameters.MaxHCDMz));
                hcdPeakProcessor.SetPeakIntensityThreshold(hcd_background_intensity);
                hcd_peaks = new GlypID.Peaks.clsPeak[1];

                //Check Header
                string Header = argReader.GetScanDescription(argScanNo);
                hcdPeakProcessor.ProfileType = GlypID.enmProfileType.PROFILE;
                if (Header.Substring(Header.IndexOf("+") + 1).Trim().StartsWith("c"))
                {
                    hcdPeakProcessor.ProfileType = GlypID.enmProfileType.CENTROIDED;
                }

                hcdPeakProcessor.DiscoverPeaks(ref hcd_mzs, ref hcd_intensities, ref hcd_peaks, Convert.ToSingle
                    (scoring_parameters.MinHCDMz), Convert.ToSingle(scoring_parameters.MaxHCDMz), false);
                hcdPeakProcessor.InitializeUnprocessedData();

                hcd_scoring_results = new GlypID.HCDScoring.clsHCDScoringScanResults[1];

                HCDScoring.ScoringParameters = scoring_parameters;
                _hcd_score = HCDScoring.ScoreHCDSpectra(ref hcd_peaks, ref hcd_mzs, ref hcd_intensities, ref transform_results, ref hcd_scoring_results);
                _gType = (GlypID.enmGlycanType)hcd_scoring_results[0].menm_glycan_type;

                enumGlycanType GType; //Convert from GlypID.enumGlycanType to MassLib.enumGlycanType;
                if (_gType == GlypID.enmGlycanType.CA)
                {
                    GType = enumGlycanType.CA;
                }
                else if (_gType == GlypID.enmGlycanType.CS)
                {
                    GType = enumGlycanType.CS;
                }
                else if (_gType == GlypID.enmGlycanType.HM)
                {
                    GType = enumGlycanType.HM;
                }
                else if (_gType == GlypID.enmGlycanType.HY)
                {
                    GType = enumGlycanType.HY;
                }
                else
                {
                    GType = enumGlycanType.NA;
                }

                HCDinfo = new HCDInfo(argScanNo, GType, _hcd_score);

            }

            return HCDinfo;
        }
Example #7
0
        public HCDInfo(GlypID.Readers.clsRawData argReader, int argScanNo)
        {
            int ParentScan = argReader.GetParentScan(argScanNo);

            // Scorers and transforms
            GlypID.HCDScoring.clsHCDScoring       HCDScoring = new GlypID.HCDScoring.clsHCDScoring();
            GlypID.HornTransform.clsHornTransform Transform  = new GlypID.HornTransform.clsHornTransform();

            // mzs , intensities
            float[] hcd_mzs            = null;
            float[] hcd_intensities    = null;
            float[] parent_mzs         = null;
            float[] parent_intensities = null;

            // Peaks
            GlypID.Peaks.clsPeak[] parent_peaks;
            GlypID.Peaks.clsPeak[] hcd_peaks;

            // Peak Processors
            GlypID.Peaks.clsPeakProcessor hcdPeakProcessor    = new GlypID.Peaks.clsPeakProcessor();
            GlypID.Peaks.clsPeakProcessor parentPeakProcessor = new GlypID.Peaks.clsPeakProcessor();

            // Results
            GlypID.HCDScoring.clsHCDScoringScanResults[]   hcd_scoring_results;
            GlypID.HornTransform.clsHornTransformResults[] transform_results;

            // Params
            GlypID.Scoring.clsScoringParameters             scoring_parameters   = new GlypID.Scoring.clsScoringParameters();
            GlypID.HornTransform.clsHornTransformParameters transform_parameters = new GlypID.HornTransform.clsHornTransformParameters();
            scoring_parameters.MinNumPeaksToConsider = 2;
            scoring_parameters.PPMTolerance          = 10;
            scoring_parameters.UsePPM = true;

            // Init
            Transform.TransformParameters = transform_parameters;

            // Loading parent
            int    parent_scan  = argReader.GetParentScan(argScanNo);
            double parent_mz    = argReader.GetParentMz(argScanNo);
            int    scan_level   = argReader.GetMSLevel(argScanNo);
            int    parent_level = argReader.GetMSLevel(parent_scan);

            argReader.GetSpectrum(parent_scan, ref parent_mzs, ref parent_intensities);


            // Parent processing
            parent_peaks = new GlypID.Peaks.clsPeak[1];
            parentPeakProcessor.ProfileType = GlypID.enmProfileType.PROFILE;
            parentPeakProcessor.DiscoverPeaks(ref parent_mzs, ref parent_intensities, ref parent_peaks,
                                              Convert.ToSingle(transform_parameters.MinMZ), Convert.ToSingle(transform_parameters.MaxMZ), true);
            double bkg_intensity         = parentPeakProcessor.GetBackgroundIntensity(ref parent_intensities);
            double min_peptide_intensity = bkg_intensity * transform_parameters.PeptideMinBackgroundRatio;


            transform_results = new GlypID.HornTransform.clsHornTransformResults[1];
            bool found = Transform.FindPrecursorTransform(Convert.ToSingle(bkg_intensity), Convert.ToSingle(min_peptide_intensity), ref parent_mzs, ref parent_intensities, ref parent_peaks, Convert.ToSingle(parent_mz), ref transform_results);

            if (!found && (argReader.GetMonoChargeFromHeader(ParentScan) > 0))
            {
                found = true;
                double mono_mz = argReader.GetMonoMzFromHeader(ParentScan);
                if (mono_mz == 0)
                {
                    mono_mz = parent_mz;
                }

                short[] charges = new short[1];
                charges[0] = argReader.GetMonoChargeFromHeader(ParentScan);
                Transform.AllocateValuesToTransform(Convert.ToSingle(mono_mz), 0, ref charges, ref transform_results); // Change abundance value from 0 to parent_intensity if you wish
            }
            if (found && transform_results.Length == 1)
            {
                // Score HCD scan first
                argReader.GetSpectrum(argScanNo, ref hcd_mzs, ref hcd_intensities);
                double hcd_background_intensity = GlypID.Utils.GetAverage(ref hcd_intensities, ref hcd_mzs, Convert.ToSingle(scoring_parameters.MinHCDMz), Convert.ToSingle(scoring_parameters.MaxHCDMz));
                hcdPeakProcessor.SetPeakIntensityThreshold(hcd_background_intensity);
                hcd_peaks = new GlypID.Peaks.clsPeak[1];

                //Check Header
                string Header = argReader.GetScanDescription(argScanNo);
                hcdPeakProcessor.ProfileType = GlypID.enmProfileType.PROFILE;
                if (Header.Substring(Header.IndexOf("+") + 1).Trim().StartsWith("c"))
                {
                    hcdPeakProcessor.ProfileType = GlypID.enmProfileType.CENTROIDED;
                }

                hcdPeakProcessor.DiscoverPeaks(ref hcd_mzs, ref hcd_intensities, ref hcd_peaks, Convert.ToSingle
                                                   (scoring_parameters.MinHCDMz), Convert.ToSingle(scoring_parameters.MaxHCDMz), false);
                hcdPeakProcessor.InitializeUnprocessedData();

                hcd_scoring_results = new GlypID.HCDScoring.clsHCDScoringScanResults[1];

                HCDScoring.ScoringParameters = scoring_parameters;
                _hcd_score = HCDScoring.ScoreHCDSpectra(ref hcd_peaks, ref hcd_mzs, ref hcd_intensities, ref transform_results, ref hcd_scoring_results);
                _gType     = (GlypID.enmGlycanType)hcd_scoring_results[0].menm_glycan_type;
            }
        }
Example #8
0
        private static MSScan GetScanFromFile(int argScanNo, double argSingleToNoise, double argPeakBackground, double argPeptideBackground, short argMaxCharge, GlypID.Readers.clsRawData Raw)
        {
            float[] _cidMzs                     = null;
            float[] _cidIntensities             = null;
            GlypID.Peaks.clsPeak[] _cidPeaks    = new GlypID.Peaks.clsPeak[1];
            GlypID.Peaks.clsPeak[] _parentPeaks = new GlypID.Peaks.clsPeak[1];

            GlypID.HornTransform.clsHornTransform           mobjTransform           = new GlypID.HornTransform.clsHornTransform();
            GlypID.HornTransform.clsHornTransformParameters mobjTransformParameters = new GlypID.HornTransform.clsHornTransformParameters();
            GlypID.HornTransform.clsHornTransformResults[]  _transformResult;


            GlypID.Peaks.clsPeakProcessor           cidPeakProcessor  = new GlypID.Peaks.clsPeakProcessor();
            GlypID.Peaks.clsPeakProcessorParameters cidPeakParameters = new GlypID.Peaks.clsPeakProcessorParameters();

            GlypID.Peaks.clsPeakProcessor           parentPeakProcessor  = new GlypID.Peaks.clsPeakProcessor();
            GlypID.Peaks.clsPeakProcessorParameters parentPeakParameters = new GlypID.Peaks.clsPeakProcessorParameters();

            //Start Read Scan
            MSScan scan = new MSScan(argScanNo);


            Raw.GetSpectrum(argScanNo, ref _cidMzs, ref _cidIntensities);
            scan.MsLevel = Raw.GetMSLevel(Convert.ToInt32(argScanNo));

            double min_peptide_intensity = 0;

            scan.Time       = Raw.GetScanTime(scan.ScanNo);
            scan.ScanHeader = Raw.GetScanDescription(scan.ScanNo);
            if (scan.MsLevel != 1)
            {
                float[] _parentRawMzs        = null;
                float[] _parentRawIntensitys = null;

                string Header = Raw.GetScanDescription(argScanNo);
                cidPeakProcessor.ProfileType = GlypID.enmProfileType.CENTROIDED;
                if (Header.Substring(Header.IndexOf("+") + 1).Trim().StartsWith("p"))
                {
                    cidPeakProcessor.ProfileType = GlypID.enmProfileType.PROFILE;
                }

                // cidPeakProcessor.DiscoverPeaks(ref _cidMzs, ref _cidIntensities, ref _cidPeaks,
                //         Convert.ToSingle(mobjTransformParameters.MinMZ), Convert.ToSingle(mobjTransformParameters.MaxMZ), false);

                for (int chNum = 0; chNum < _cidMzs.Length; chNum++)
                {
                    scan.MSPeaks.Add(new MSPeak(
                                         Convert.ToSingle(_cidMzs[chNum]),
                                         Convert.ToSingle(_cidIntensities[chNum])));
                }

                //for (int chNum = 0; chNum < _cidMzs.Length; chNum++)
                //{
                //    scan.MSPeaks.Add(new MSPeak(
                //        Convert.ToSingle(_cidMzs[chNum]),
                //        Convert.ToSingle(_cidIntensities[chNum])));
                //}

                // Get parent information
                scan.ParentScanNo = Raw.GetParentScan(scan.ScanNo);

                Raw.GetSpectrum(scan.ParentScanNo, ref _parentRawMzs, ref _parentRawIntensitys);
                parentPeakProcessor.ProfileType = GlypID.enmProfileType.PROFILE;
                parentPeakProcessor.DiscoverPeaks(ref _parentRawMzs, ref _parentRawIntensitys, ref _parentPeaks, Convert.ToSingle(mobjTransformParameters.MinMZ), Convert.ToSingle(mobjTransformParameters.MaxMZ), true);
                float _parentBackgroundIntensity = (float)parentPeakProcessor.GetBackgroundIntensity(ref _parentRawIntensitys);
                _transformResult = new GlypID.HornTransform.clsHornTransformResults[1];
                bool found = false;
                if (Raw.IsFTScan(scan.ParentScanNo))
                {
                    // High resolution data
                    found = mobjTransform.FindPrecursorTransform(Convert.ToSingle(_parentBackgroundIntensity), Convert.ToSingle(min_peptide_intensity), ref _parentRawMzs, ref _parentRawIntensitys, ref _parentPeaks, Convert.ToSingle(scan.ParentMZ), ref _transformResult);
                }
                if (!found)//de-isotope fail
                {
                    // Low resolution data or bad high res spectra
                    short        cs        = Raw.GetMonoChargeFromHeader(scan.ScanNo);
                    double       monoMZ    = Raw.GetMonoMzFromHeader(scan.ScanNo);
                    List <float> ParentMzs = new List <float>(_parentRawMzs);
                    int          CloseIdx  = MassUtility.GetClosestMassIdx(ParentMzs, Convert.ToSingle(monoMZ));

                    if (cs > 0)
                    {
                        short[] charges = new short[1];
                        charges[0] = cs;
                        mobjTransform.AllocateValuesToTransform(Convert.ToSingle(scan.ParentMZ), Convert.ToInt32(_parentRawIntensitys[CloseIdx]), ref charges, ref _transformResult);
                    }
                    else
                    {
                        // instrument has no charge just store 2 and 3.
                        short[] charges = new short[2];
                        charges[0] = 2;
                        charges[1] = 3;
                        mobjTransform.AllocateValuesToTransform(Convert.ToSingle(scan.ParentMZ), Convert.ToInt32(_parentRawIntensitys[CloseIdx]), ref charges, ref _transformResult);
                    }
                }

                if (_transformResult[0].mint_peak_index == -1) //De-isotope parent scan
                {
                    //Get parent info
                    MSScan  _parentScan    = GetScanFromFile(scan.ParentScanNo, argSingleToNoise, argPeakBackground, argPeptideBackground, argMaxCharge, Raw);
                    float[] _MSMzs         = null;
                    float[] _MSIntensities = null;

                    Raw.GetSpectrum(scan.ParentScanNo, ref _MSMzs, ref _MSIntensities);
                    // Now find peaks
                    parentPeakParameters.SignalToNoiseThreshold = 0;
                    parentPeakParameters.PeakBackgroundRatio    = 0.01;
                    parentPeakProcessor.SetOptions(parentPeakParameters);
                    parentPeakProcessor.ProfileType = GlypID.enmProfileType.PROFILE;

                    parentPeakProcessor.DiscoverPeaks(ref _MSMzs, ref _MSIntensities, ref _cidPeaks,
                                                      Convert.ToSingle(mobjTransformParameters.MinMZ), Convert.ToSingle(mobjTransformParameters.MaxMZ), true);



                    //Look for charge and mono.


                    float[] monoandcharge = FindChargeAndMono(_cidPeaks, Convert.ToSingle(Raw.GetParentMz(scan.ScanNo)), scan.ScanNo, Raw);
                    //scan.ParentMonoMW = _parentScan.MSPeaks[ClosedIdx].MonoMass;
                    //scan.ParentAVGMonoMW = _parentScan.MSPeaks[ClosedIdx].;
                    scan.ParentMZ = monoandcharge[0];
                    if (monoandcharge[1] == 0.0f)
                    {
                        scan.ParentCharge = Convert.ToInt32(Raw.GetMonoChargeFromHeader(scan.ParentScanNo));
                    }
                    else
                    {
                        scan.ParentCharge = Convert.ToInt32(monoandcharge[1]);
                    }

                    scan.ParentMonoMW = (monoandcharge[0] - Atoms.ProtonMass) * monoandcharge[1];
                }
                else
                {
                    scan.ParentMonoMW    = (float)_transformResult[0].mdbl_mono_mw;
                    scan.ParentAVGMonoMW = (float)_transformResult[0].mdbl_average_mw;
                    scan.ParentMZ        = (float)_transformResult[0].mdbl_mz;
                    scan.ParentCharge    = (int)_transformResult[0].mshort_cs;
                }
                scan.IsCIDScan = Raw.IsCIDScan(argScanNo);
                scan.IsFTScan  = Raw.IsFTScan(argScanNo);

                Array.Clear(_transformResult, 0, _transformResult.Length);
                Array.Clear(_cidPeaks, 0, _cidPeaks.Length);
                Array.Clear(_cidMzs, 0, _cidMzs.Length);
                Array.Clear(_cidIntensities, 0, _cidIntensities.Length);
                Array.Clear(_parentRawMzs, 0, _parentRawMzs.Length);
                Array.Clear(_parentRawIntensitys, 0, _parentRawIntensitys.Length);
            }
            else //MS Scan
            {
                scan.ParentMZ = 0.0f;
                double mdbl_current_background_intensity = 0;

                // Now find peaks
                parentPeakParameters.SignalToNoiseThreshold = argSingleToNoise;
                parentPeakParameters.PeakBackgroundRatio    = argPeakBackground;
                parentPeakProcessor.SetOptions(parentPeakParameters);
                parentPeakProcessor.ProfileType = GlypID.enmProfileType.PROFILE;

                parentPeakProcessor.DiscoverPeaks(ref _cidMzs, ref _cidIntensities, ref _cidPeaks,
                                                  Convert.ToSingle(mobjTransformParameters.MinMZ), Convert.ToSingle(mobjTransformParameters.MaxMZ), true);
                mdbl_current_background_intensity = parentPeakProcessor.GetBackgroundIntensity(ref _cidIntensities);

                // Settings
                min_peptide_intensity = mdbl_current_background_intensity * mobjTransformParameters.PeptideMinBackgroundRatio;
                if (mobjTransformParameters.UseAbsolutePeptideIntensity)
                {
                    if (min_peptide_intensity < mobjTransformParameters.AbsolutePeptideIntensity)
                    {
                        min_peptide_intensity = mobjTransformParameters.AbsolutePeptideIntensity;
                    }
                }
                mobjTransformParameters.PeptideMinBackgroundRatio = argPeptideBackground;
                mobjTransformParameters.MaxCharge = argMaxCharge;
                mobjTransform.TransformParameters = mobjTransformParameters;


                //  Now perform deisotoping
                _transformResult = new GlypID.HornTransform.clsHornTransformResults[1];
                mobjTransform.PerformTransform(Convert.ToSingle(mdbl_current_background_intensity), Convert.ToSingle(min_peptide_intensity), ref _cidMzs, ref _cidIntensities, ref _cidPeaks, ref _transformResult);
                // for getting results

                for (int chNum = 0; chNum < _transformResult.Length; chNum++)
                {
                    double sumintensity         = 0.0;
                    double mostIntenseIntensity = 0.0;
                    for (int i = 0; i < _transformResult[chNum].marr_isotope_peak_indices.Length; i++)
                    {
                        sumintensity = sumintensity + _cidPeaks[_transformResult[chNum].marr_isotope_peak_indices[i]].mdbl_intensity;
                        if (Math.Abs(_transformResult[chNum].mdbl_most_intense_mw -
                                     (_cidPeaks[_transformResult[chNum].marr_isotope_peak_indices[i]].mdbl_mz * _transformResult[chNum].mshort_cs - Atoms.ProtonMass * _transformResult[chNum].mshort_cs))
                            < 1.0 / _transformResult[chNum].mshort_cs)
                        {
                            mostIntenseIntensity = _cidPeaks[_transformResult[chNum].mint_peak_index].mdbl_intensity;
                        }
                    }
                    scan.MSPeaks.Add(new MSPeak(
                                         Convert.ToSingle(_transformResult[chNum].mdbl_mono_mw),
                                         _transformResult[chNum].mint_mono_intensity,
                                         _transformResult[chNum].mshort_cs,
                                         Convert.ToSingle(_transformResult[chNum].mdbl_mz),
                                         Convert.ToSingle(_transformResult[chNum].mdbl_fit),
                                         Convert.ToSingle(_transformResult[chNum].mdbl_most_intense_mw),
                                         mostIntenseIntensity,
                                         sumintensity
                                         ));
                }
                Array.Clear(_transformResult, 0, _transformResult.Length);
                Array.Clear(_cidPeaks, 0, _cidPeaks.Length);
                Array.Clear(_cidMzs, 0, _cidMzs.Length);
                Array.Clear(_cidIntensities, 0, _cidIntensities.Length);
            }
            return(scan);
        }
Example #9
0
        public Class1(string argFileName, int argScanNo)
        {
            _scanNum  = argScanNo;
            _filename = argFileName;
            GlypID.HornTransform.clsHornTransform           Transform            = new GlypID.HornTransform.clsHornTransform();
            GlypID.Peaks.clsPeakProcessor                   cidPeakProcessor     = new GlypID.Peaks.clsPeakProcessor();
            GlypID.Peaks.clsPeakProcessor                   parentPeakProcessor  = new GlypID.Peaks.clsPeakProcessor();
            GlypID.HornTransform.clsHornTransformParameters transform_parameters = new GlypID.HornTransform.clsHornTransformParameters();
            GlypID.Peaks.clsPeakProcessorParameters         peak_parameters      = new GlypID.Peaks.clsPeakProcessorParameters();
            Raw = new GlypID.Readers.clsRawData(_filename, GlypID.Readers.FileType.FINNIGAN);

            Raw.GetSpectrum(_scanNum, ref _cidMzs, ref _cidIntensities);

            Transform.TransformParameters = transform_parameters;

            _msLevel = Raw.GetMSLevel(_scanNum);

            if (_msLevel > 1)
            {
                _parentScanNum = Raw.GetParentScan(_scanNum);
                _parentMz      = (float)Raw.GetParentMz(_scanNum);
            }
            else
            {
                return; //MS scan
            }
            Raw.GetSpectrum(_parentScanNum, ref _parentRawMzs, ref _parentRawIntensitys);

            _cidPeaks = new GlypID.Peaks.clsPeak[1];
            cidPeakProcessor.ProfileType = GlypID.enmProfileType.CENTROIDED;
            cidPeakProcessor.DiscoverPeaks(ref _cidMzs, ref _cidIntensities, ref _cidPeaks,
                                           Convert.ToSingle(transform_parameters.MinMZ), Convert.ToSingle(transform_parameters.MaxMZ), false);
            _parentPeaks = new GlypID.Peaks.clsPeak[1];
            parentPeakProcessor.ProfileType = GlypID.enmProfileType.PROFILE;
            parentPeakProcessor.DiscoverPeaks(ref _parentRawMzs, ref _parentRawIntensitys, ref _parentPeaks,
                                              Convert.ToSingle(transform_parameters.MinMZ), Convert.ToSingle(transform_parameters.MaxMZ), true);
            _parentBackgroundIntensity = (float)parentPeakProcessor.GetBackgroundIntensity(ref _parentRawIntensitys);
            double min_peptide_intensity = _parentBackgroundIntensity * transform_parameters.PeptideMinBackgroundRatio;

            if (transform_parameters.UseAbsolutePeptideIntensity)
            {
                if (min_peptide_intensity < transform_parameters.AbsolutePeptideIntensity)
                {
                    min_peptide_intensity = transform_parameters.AbsolutePeptideIntensity;
                }
            }
            _transformResult = new GlypID.HornTransform.clsHornTransformResults[1];
            bool found = Transform.FindPrecursorTransform(Convert.ToSingle(_parentBackgroundIntensity), Convert.ToSingle(min_peptide_intensity), ref _parentRawMzs, ref _parentRawIntensitys, ref _parentPeaks, Convert.ToSingle(_parentMz), ref _transformResult);

            if (Raw.IsFTScan(_parentScanNum))
            {
                // High resolution data
                found = Transform.FindPrecursorTransform(Convert.ToSingle(_parentBackgroundIntensity), Convert.ToSingle(min_peptide_intensity), ref _parentRawMzs, ref _parentRawIntensitys, ref _parentPeaks, Convert.ToSingle(_parentMz), ref _transformResult);
            }
            if (!found)
            {
                // Low resolution data or bad high res spectra
                short cs = Raw.GetMonoChargeFromHeader(_scanNum);
                if (cs > 0)
                {
                    short[] charges = new short[1];
                    charges[0] = cs;
                    Transform.AllocateValuesToTransform(Convert.ToSingle(_parentMz), 500, ref charges, ref _transformResult);
                }
                else
                {
                    // instrument has no charge just store 2 and 3.
                    short[] charges = new short[2];
                    charges[0] = 2;
                    charges[1] = 3;
                    Transform.AllocateValuesToTransform(Convert.ToSingle(_parentMz), 500, ref charges, ref _transformResult);
                }
            }

            _parentMonoMW = (float)_transformResult[0].mdbl_mono_mw;
            _parentCharge = (int)_transformResult[0].mshort_cs;
            MaxIntensityPeak();

            Raw.Close();
        }
Example #10
0
        private MSScan GetMSScan(int argScanNo)
        {
            MSScan msScan = new MSScan(argScanNo);
            // GlypID.Readers.clsRawData rawData = new GlypID.Readers.clsRawData() ;
            GlypID.HornTransform.clsHornTransform massTransform = new GlypID.HornTransform.clsHornTransform();
            GlypID.Peaks.clsPeakProcessor peakProcessor = new GlypID.Peaks.clsPeakProcessor();

            GlypID.HornTransform.clsHornTransformParameters transform_parameters = new GlypID.HornTransform.clsHornTransformParameters();
            GlypID.Peaks.clsPeakProcessorParameters peak_parameters = new GlypID.Peaks.clsPeakProcessorParameters();

            // Declarations
            float[] _mzs = null;
            float[] _intensities = null;
            GlypID.Peaks.clsPeak[] peaks;
            GlypID.HornTransform.clsHornTransformResults[] _transformResults;

            // Settings
            peak_parameters.SignalToNoiseThreshold = 3.0;
            peak_parameters.PeakBackgroundRatio = 5.0;

            peakProcessor.SetOptions(peak_parameters);
            peakProcessor.ProfileType = GlypID.enmProfileType.PROFILE;
            transform_parameters.PeptideMinBackgroundRatio = 5.0;
            transform_parameters.MaxCharge = 10;
            massTransform.TransformParameters = transform_parameters;

            // Load
            Raw = new GlypID.Readers.clsRawData(_fullFilePath, GlypID.Readers.FileType.FINNIGAN);

            if (Raw.GetMSLevel(argScanNo) == 1)
            {
                // Get spectra
                Raw.GetSpectrum(argScanNo, ref _mzs, ref _intensities);

                // Get peaks
                peaks = new GlypID.Peaks.clsPeak[1];
                peakProcessor.DiscoverPeaks(ref _mzs, ref _intensities, ref peaks, Convert.ToSingle(transform_parameters.MinMZ), Convert.ToSingle(transform_parameters.MaxMZ), true);

                // Deisotope
                double min_background_intensity = peakProcessor.GetBackgroundIntensity(ref _intensities);
                double min_peptide_intensity = min_background_intensity * transform_parameters.PeptideMinBackgroundRatio;

                _transformResults = new GlypID.HornTransform.clsHornTransformResults[1];
                massTransform.PerformTransform(Convert.ToSingle(min_background_intensity), Convert.ToSingle(min_peptide_intensity), ref _mzs, ref _intensities, ref peaks, ref _transformResults);

                Array.Clear(_transformResults, 0, _transformResults.Length);
                Array.Clear(peaks, 0, peaks.Length);
            }

            return msScan;
        }
Example #11
0
        public Class1(string argFileName,int argScanNo)
        {
            _scanNum = argScanNo;
            _filename = argFileName;
            GlypID.HornTransform.clsHornTransform Transform = new GlypID.HornTransform.clsHornTransform();
            GlypID.Peaks.clsPeakProcessor cidPeakProcessor = new GlypID.Peaks.clsPeakProcessor();
            GlypID.Peaks.clsPeakProcessor parentPeakProcessor = new GlypID.Peaks.clsPeakProcessor();
            GlypID.HornTransform.clsHornTransformParameters transform_parameters = new GlypID.HornTransform.clsHornTransformParameters();
            GlypID.Peaks.clsPeakProcessorParameters peak_parameters = new GlypID.Peaks.clsPeakProcessorParameters();
            Raw = new GlypID.Readers.clsRawData(_filename, GlypID.Readers.FileType.FINNIGAN);

            Raw.GetSpectrum(_scanNum, ref _cidMzs, ref _cidIntensities);

            Transform.TransformParameters = transform_parameters;

            _msLevel = Raw.GetMSLevel(_scanNum);

            if (_msLevel > 1)
            {
                _parentScanNum = Raw.GetParentScan(_scanNum);
                _parentMz = (float)Raw.GetParentMz(_scanNum);
            }
            else
            {
                return; //MS scan
            }
            Raw.GetSpectrum(_parentScanNum, ref _parentRawMzs, ref _parentRawIntensitys);

            _cidPeaks = new GlypID.Peaks.clsPeak[1];
            cidPeakProcessor.ProfileType = GlypID.enmProfileType.CENTROIDED;
            cidPeakProcessor.DiscoverPeaks(ref _cidMzs, ref _cidIntensities, ref _cidPeaks,
                        Convert.ToSingle(transform_parameters.MinMZ), Convert.ToSingle(transform_parameters.MaxMZ), false);
            _parentPeaks = new GlypID.Peaks.clsPeak[1];
            parentPeakProcessor.ProfileType = GlypID.enmProfileType.PROFILE;
            parentPeakProcessor.DiscoverPeaks(ref _parentRawMzs, ref _parentRawIntensitys, ref _parentPeaks,
                        Convert.ToSingle(transform_parameters.MinMZ), Convert.ToSingle(transform_parameters.MaxMZ), true);
            _parentBackgroundIntensity = (float)parentPeakProcessor.GetBackgroundIntensity(ref _parentRawIntensitys);
            double min_peptide_intensity = _parentBackgroundIntensity * transform_parameters.PeptideMinBackgroundRatio;

            if (transform_parameters.UseAbsolutePeptideIntensity)
            {
                if (min_peptide_intensity < transform_parameters.AbsolutePeptideIntensity)
                    min_peptide_intensity = transform_parameters.AbsolutePeptideIntensity;
            }
            _transformResult = new GlypID.HornTransform.clsHornTransformResults[1];
            bool found = Transform.FindPrecursorTransform(Convert.ToSingle(_parentBackgroundIntensity), Convert.ToSingle(min_peptide_intensity), ref _parentRawMzs, ref _parentRawIntensitys, ref _parentPeaks, Convert.ToSingle(_parentMz), ref _transformResult);
            if (Raw.IsFTScan(_parentScanNum))
            {
                // High resolution data
                found = Transform.FindPrecursorTransform(Convert.ToSingle(_parentBackgroundIntensity), Convert.ToSingle(min_peptide_intensity), ref _parentRawMzs, ref _parentRawIntensitys, ref _parentPeaks, Convert.ToSingle(_parentMz), ref _transformResult);
            }
            if (!found)
            {
                // Low resolution data or bad high res spectra
                short cs = Raw.GetMonoChargeFromHeader(_scanNum);
                if (cs > 0)
                {
                    short[] charges = new short[1];
                    charges[0] = cs;
                    Transform.AllocateValuesToTransform(Convert.ToSingle(_parentMz),500, ref charges, ref _transformResult);

                }
                else
                {
                    // instrument has no charge just store 2 and 3.
                    short[] charges = new short[2];
                    charges[0] = 2;
                    charges[1] = 3;
                    Transform.AllocateValuesToTransform(Convert.ToSingle(_parentMz), 500,ref charges, ref _transformResult);
                }
            }

            _parentMonoMW = (float)_transformResult[0].mdbl_mono_mw;
            _parentCharge = (int)_transformResult[0].mshort_cs;
            MaxIntensityPeak();

            Raw.Close();
        }