public void AddToPeaks(ref GlypID.Peaks.clsPeak[] peak, ref GlypID.Peaks.clsPeak[] peaksToAdd) { if (peak.Length != peaksToAdd.Length) throw new Exception("Peaks to sum must be equal length"); for (int i = 0; i < peaksToAdd.Length; i++) { peak[i].mdbl_intensity = peak[i].mdbl_intensity + peaksToAdd[i].mdbl_intensity; } }
public MultiNGlycanESIMultiThreads(string argGlycanCompound, string argRawFile, int argStartScan, int argEndScan, int argNoThreads, float argMassPPM , float argGlycanMass, float argMergeDurationMin, bool argPermenthylated, bool argReducedReducingEnd, GlypID.Peaks.clsPeakProcessorParameters argPeakProcessorPara, GlypID.HornTransform.clsHornTransformParameters argTransformPara) { glycanFile = argGlycanCompound; rawFiles = new Stack<string>(); rawFiles.Push(argRawFile); StartScan = argStartScan; EndScan = argEndScan; _noOfThreads = argNoThreads; _MassPPM = argMassPPM; _GlycanPPM = argGlycanMass; _MergeDurationMin = argMergeDurationMin; _Permenthylated = argPermenthylated; _ReducedReducingEnd = argReducedReducingEnd; _peakParameter = argPeakProcessorPara; _transformParameter = argTransformPara; _pool = new Semaphore(0, _noOfThreads); //doneEvents = new ManualResetEvent[_noOfThreads]; _multiESIThreads = new MultiNGlycanESI[_noOfThreads]; //Copy Dataset for (int i = 1; i < _noOfThreads; i++) // only need n-1 copies { string newFilename = Path.GetDirectoryName(argRawFile) + "\\" + Path.GetFileNameWithoutExtension(argRawFile) + "-" + i.ToString() + Path.GetExtension(argRawFile); File.Copy(argRawFile, newFilename); rawFiles.Push(newFilename); } //Split Dataset SplitDataset(); }
/// <summary> /// Function to normalize peaks into bins of set width /// </summary> /// <param name="?"></param> public void BinNormalize(ref GlypID.Peaks.clsPeak[] peaks, float min_mz, float max_mz, double bin_size) { int num_bins = (int)((max_mz - min_mz) / bin_size)+1; GlypID.Peaks.clsPeak[] baseSpectrumPeaks = new GlypID.Peaks.clsPeak[num_bins]; for (int i = 0; i < baseSpectrumPeaks.Length; i++) { baseSpectrumPeaks[i] = new GlypID.Peaks.clsPeak(); baseSpectrumPeaks[i].mdbl_mz = min_mz + i * bin_size; baseSpectrumPeaks[i].mdbl_intensity = 0; } for (int i = 0; i < peaks.Length; i++) { int bin = (int) ((peaks[i].mdbl_mz - min_mz) / bin_size); baseSpectrumPeaks[i].mdbl_intensity += peaks[i].mdbl_intensity; } Array.Clear(peaks, 0, peaks.Length); peaks = baseSpectrumPeaks; }
/// <summary> /// Add a bunch of peaks to a list of spectra, bin them and add the binned spectra to another list /// </summary> /// <param name="peaks"></param> /// <param name="spectraName"></param> public void AddPeaksToList(ref GlypID.Peaks.clsPeak[] peaks, string spectraName) { // add original spectrum List<GlypID.Peaks.clsPeak> thisOrigSpectra = new List<GlypID.Peaks.clsPeak>(); for (int i = 0; i < peaks.Length; i++) { thisOrigSpectra.Add(peaks[i]); } _AllOriginalSpectra.Add(thisOrigSpectra); // Bin spectrum List<double> thisBinnedSpectra = new List<double>() ; BinNormalize(ref peaks, ref thisBinnedSpectra, _minMz, _maxMz, _binsize) ; // Add binned spectrum to another list and to Cluster object _AllBinnedSpectra.Add(thisBinnedSpectra); _Clusters.Add(thisBinnedSpectra); // Store names to keep track _ClusterNames.Add(spectraName); _SpectraNames.Add(spectraName); }
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; }
private static float[] FindChargeAndMono(GlypID.Peaks.clsPeak[] argPeaks, float argTargetMZ, int argParentScanNo, GlypID.Readers.clsRawData Raw) { float[] MonoAndMz = new float[2]; double interval = 9999.9; int ClosedIdx = 0; for (int i = 0; i < argPeaks.Length; i++) { if (Math.Abs(argPeaks[i].mdbl_mz - argTargetMZ) < interval) { interval = Math.Abs(argPeaks[i].mdbl_mz - argTargetMZ); ClosedIdx = i; } } //Charge float testMz = 0.0f; int MaxMatchedPeak = 2; for (int i = 1; i <= 6; i++) { double FirstMonoMz = 0.0; int ForwardPeak = 0; int BackardPeak = 0; //Forward Check testMz = argTargetMZ - 1.0f / (float)i; int CheckIdx = ClosedIdx - 1; for (int j = 1; j <= 10; j++) { if (CheckIdx < 0) { break; } if (Math.Abs(argPeaks[CheckIdx].mdbl_mz - testMz) <= 0.03) { ForwardPeak++; testMz = Convert.ToSingle(argPeaks[CheckIdx].mdbl_mz) - 1.0f / (float)i; FirstMonoMz = argPeaks[CheckIdx].mdbl_mz; } CheckIdx = CheckIdx - 1; } //Backward testMz = argTargetMZ + 1.0f / (float)i; CheckIdx = ClosedIdx + 1; for (int j = 1; j <= 10; j++) { if (CheckIdx >= argPeaks.Length) { break; } if (Math.Abs(argPeaks[CheckIdx].mdbl_mz - testMz) <= 0.03) { BackardPeak++; testMz = Convert.ToSingle(argPeaks[CheckIdx].mdbl_mz) + 1.0f / (float)i; } CheckIdx = CheckIdx + 1; } if (ForwardPeak == 0) { FirstMonoMz = argTargetMZ; } if (ForwardPeak + BackardPeak >= MaxMatchedPeak) { MaxMatchedPeak = ForwardPeak + BackardPeak; MonoAndMz[0] = Convert.ToSingle(FirstMonoMz); MonoAndMz[1] = i; } } if (MonoAndMz[1] == 0) { if (interval < 0.01) { MonoAndMz[0] = argTargetMZ; } MonoAndMz[1] = Raw.GetMonoChargeFromHeader(argParentScanNo); } return MonoAndMz; }
/// <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; }
/// <summary> /// Function to normalize peaks into bins of set width within mz range /// </summary> /// <param name="?"></param> /// Return values in binnedIntensities public void BinNormalize(ref GlypID.Peaks.clsPeak[] peaks, ref List<double> binnedIntensities, float min_mz, float max_mz, double bin_size) { int num_bins = (int)((max_mz - min_mz) / bin_size)+1; binnedIntensities = new List<double>(); for (int i =0; i < num_bins;i++) { binnedIntensities.Add(0) ; } for (int i = 0; i < peaks.Length; i++) { int bin = (int) Math.Round ((peaks[i].mdbl_mz - min_mz) / bin_size); binnedIntensities[bin]+= peaks[i].mdbl_intensity; } }
/// <summary> /// Given a cluster index, return the representative of that cluster. Currently, the spectrum with maximum SNR in a given range is returned /// </summary> /// <param name="clusterIndex"></param> /// <param name="repPeaks"></param> /// <param name="minmz"></param> /// <param name="maxmz"></param> /// <param name="return_original_id">true or false. If true, return the original index(among all spectra), else returns the index within the cluster</param> /// <returns></returns> public int GetRepresentativePeaksFromCluster(int clusterIndex, ref GlypID.Peaks.clsPeak[] repPeaks, double minmz, double maxmz, bool return_original_id) { double max_snr = 0; int spectra_with_max_snr = -1; int orig_index = -1; string clustername = _ClusterNames[clusterIndex]; string[] spectra = new string[1]; if (clustername.Contains('-')) spectra = clustername.Split('-'); else spectra[0] = clustername; if (spectra.Length > 0) { foreach (string s in spectra) { List<GlypID.Peaks.clsPeak> this_peaks = new List<GlypID.Peaks.clsPeak>(); string[] parts = s.Split('_'); int spectra_index = Convert.ToInt32(parts[2]); this_peaks = _AllOriginalSpectra[spectra_index]; double noise_level = CalculateAverage(ref this_peaks, 0, minmz, maxmz); double signal_level = CalculateAverage(ref this_peaks, noise_level, minmz, maxmz); double snr = signal_level / noise_level; if (snr > max_snr) { max_snr = snr; spectra_with_max_snr = spectra_index; orig_index = Convert.ToInt32(parts[1]); } } if (spectra_with_max_snr >= 0) { repPeaks = new GlypID.Peaks.clsPeak[_AllOriginalSpectra[spectra_with_max_snr].Count]; for (int i = 0; i < _AllOriginalSpectra[spectra_with_max_snr].Count; i++) { repPeaks[i] = _AllOriginalSpectra[spectra_with_max_snr][i]; } } } if (return_original_id) return orig_index; else return spectra_with_max_snr; }
public string EncodePeaks(ref GlypID.Peaks.clsPeak[] peaks) { string spectrum = ""; if (peaks != null) { float[] mzs = new float[peaks.Length]; float[] intensities = new float[peaks.Length]; for (int i = 0; i < peaks.Length; i++) { mzs[i] = (float)peaks[i].mdbl_mz; intensities[i] = (float)peaks[i].mdbl_intensity; } spectrum = GlypID.Utils.EncodeData(ref mzs, ref intensities); } else { spectrum = ""; } return spectrum; }
public MapParserOld(MapRecord mrecord, GlypID.Scoring.clsScoringParameters score_params, GlypID.HornTransform.clsHornTransformParameters transform_params) { _GlycoMap = new MapRecord(); _GlycoMap = mrecord; }
public void SetTransformParameter(GlypID.HornTransform.clsHornTransformParameters argTransformParameter) { _peptideMinBackgroundRatio = argTransformParameter.PeptideMinBackgroundRatio; _maxCharge = argTransformParameter.MaxCharge; }
public void SetPeakProcessorParameter(GlypID.Peaks.clsPeakProcessorParameters argPeakProcessorParameter) { _singleToNoiseRatio = argPeakProcessorParameter.SignalToNoiseThreshold; _peakBackgroundRatio = argPeakProcessorParameter.PeakBackgroundRatio; }
/// <summary> /// Function to store glycopeptides /// </summary> /// <param name="sequences"> Peptide sequences</param> /// <param name="glycans"> Glycans</param> /// <param name="min_mass">Min Mass of the map</param> /// <param name="max_mass">Max mass of the map</param> public void SetGlycoPeptides(ref GlypID.Sequence.clsSequence[] sequences, ref GlypID.Glycan.clsGlycan[] glycans) { int num_gps = sequences.Length * glycans.Length; _glycopeptides = new List<GlycopeptideRecord>(); for (int i = 0; i < sequences.Length; i++) { for (int j=0 ; j < glycans.Length; j++) { GlycopeptideRecord gp = new GlycopeptideRecord(); gp.Sequence = sequences[i]; gp.SequenceAverageMass = sequences[i].CalculateSequenceMass(false) ; gp.SequenceMonoMass = sequences[i].CalculateSequenceMass(true) ; gp.Glycan = glycans[j]; gp.GlycanAverageMass = glycans[j].CalculateGlycanMass(false) ; gp.GlycanMonoMass = glycans[j].CalculateGlycanMass(true) ; gp.GP_Average_Mass = _utils.CalculateGPMass(gp.SequenceAverageMass, gp.GlycanAverageMass) ; gp.GP_Mono_Mass = _utils.CalculateGPMass(gp.SequenceMonoMass, gp.GlycanMonoMass) ; gp.IsDecoy = gp.Glycan.is_decoy | gp.Sequence.is_decoy; _glycopeptides.Add(gp); } } //-- Sort by mono mass and create a hash table -- // _glycopeptides.Sort(delegate(GlycopeptideRecord g1, GlycopeptideRecord g2) { return g1.GP_Mono_Mass.CompareTo(g2.GP_Mono_Mass); }); }