Neutral Mass Spectrum

mzLib/MassSpectrometry/Deconvolution/Algorithms/ClassicDeconvolutionAlgorithm.cs

@@ -1,20 +1,17 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using Chemistry;
-using Easy.Common.Extensions;
 using MathNet.Numerics.Statistics;
 using MzLibUtil;
 
 namespace MassSpectrometry
 {
- public class ClassicDeconvolutionAlgorithm : DeconvolutionAlgorithm
+ internal class ClassicDeconvolutionAlgorithm : DeconvolutionAlgorithm
  {
  private MzSpectrum spectrum;
 
- public ClassicDeconvolutionAlgorithm(DeconvolutionParameters deconParameters) : base(deconParameters)
+ internal ClassicDeconvolutionAlgorithm(DeconvolutionParameters deconParameters) : base(deconParameters)
  {
 
  }
@@ -25,7 +22,7 @@ public ClassicDeconvolutionAlgorithm(DeconvolutionParameters deconParameters) :
  /// <param name="spectrumToDeconvolute">spectrum to deconvolute</param>
  /// <param name="range">Range of peaks to deconvolute</param>
  /// <returns></returns>
- public override IEnumerable<IsotopicEnvelope> Deconvolute(MzSpectrum spectrumToDeconvolute, MzRange range)
+ internal override IEnumerable<IsotopicEnvelope> Deconvolute(MzSpectrum spectrumToDeconvolute, MzRange range)
  {
  var deconParams = DeconvolutionParameters as ClassicDeconvolutionParameters ?? throw new MzLibException("Deconvolution params and algorithm do not match");
  spectrum = spectrumToDeconvolute;
@@ -205,7 +202,7 @@ private IsotopicEnvelope FindIsotopicEnvelope(int massIndex, double candidateFor
  }
  }
 
- return new IsotopicEnvelope(listOfObservedPeaks, monoisotopicMass, chargeState, totalIntensity, Statistics.StandardDeviation(listOfRatios), massIndex);
+ return new IsotopicEnvelope(listOfObservedPeaks, monoisotopicMass, chargeState, totalIntensity, listOfRatios.StandardDeviation());
  }
 
  private int ObserveAdjacentChargeStates(IsotopicEnvelope originalEnvelope, double mostIntensePeakMz, int massIndex, double deconvolutionTolerancePpm, double intensityRatioLimit, double minChargeToLookFor, double maxChargeToLookFor, List<double> monoisotopicMassPredictions)

mzLib/MassSpectrometry/Deconvolution/Algorithms/DeconvolutionAlgorithm.cs

@@ -8,6 +8,9 @@
 
 namespace MassSpectrometry
 {
+ /// <summary>
+ /// Parent class defining minimum requirement to be used <see cref="Deconvoluter"/> 
+ /// </summary>
  public abstract class DeconvolutionAlgorithm
  {
  // For ClassicDeconv. If not used elsewhere, move to that class
@@ -79,6 +82,6 @@ protected DeconvolutionAlgorithm(DeconvolutionParameters deconParameters)
  /// <param name="spectrum">spectrum to be deconvoluted</param>
  /// <param name="range">Range of peaks to deconvolute</param>
  /// <returns></returns>
- public abstract IEnumerable<IsotopicEnvelope> Deconvolute(MzSpectrum spectrum, MzRange range);
+ internal abstract IEnumerable<IsotopicEnvelope> Deconvolute(MzSpectrum spectrum, MzRange range);
  }
 }

mzLib/MassSpectrometry/Deconvolution/Algorithms/ExampleNewDeconvolutionAlgorithmTemplate.cs

@@ -1,22 +1,19 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using MzLibUtil;
 
 namespace MassSpectrometry
 {
  [ExcludeFromCodeCoverage]
- public class ExampleNewDeconvolutionAlgorithmTemplate : DeconvolutionAlgorithm
+ internal class ExampleNewDeconvolutionAlgorithmTemplate : DeconvolutionAlgorithm
  {
- public ExampleNewDeconvolutionAlgorithmTemplate(DeconvolutionParameters deconParameters) : base(deconParameters)
+ internal ExampleNewDeconvolutionAlgorithmTemplate(DeconvolutionParameters deconParameters) : base(deconParameters)
  {
 
  }
 
- public override IEnumerable<IsotopicEnvelope> Deconvolute(MzSpectrum spectrum, MzRange range = null)
+ internal override IEnumerable<IsotopicEnvelope> Deconvolute(MzSpectrum spectrum, MzRange range = null)
  {
  var deconParams = DeconvolutionParameters as ExampleNewDeconvolutionParametersTemplate ?? throw new MzLibException("Deconvolution params and algorithm do not match");
  range ??= spectrum.Range;

mzLib/MassSpectrometry/Deconvolution/Deconvoluter.cs

@@ -1,10 +1,5 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Easy.Common.Extensions;
-using Easy.Common.Interfaces;
+using System.Collections.Generic;
+using Chemistry;
 using MzLibUtil;
 
 namespace MassSpectrometry
@@ -30,27 +25,11 @@ public static class Deconvoluter
  public static IEnumerable<IsotopicEnvelope> Deconvolute(MsDataScan scan,
  DeconvolutionParameters deconvolutionParameters, MzRange rangeToGetPeaksFrom = null)
  {
- rangeToGetPeaksFrom ??= scan.MassSpectrum.Range;
+ // set any specific deconvolution parameters found only in the MsDataScan
 
- // set deconvolution algorithm and any specific deconvolution parameters found in the MsDataScan
- DeconvolutionAlgorithm deconAlgorithm;
- switch (deconvolutionParameters.DeconvolutionType)
- {
- case DeconvolutionType.ClassicDeconvolution:
- deconAlgorithm = new ClassicDeconvolutionAlgorithm(deconvolutionParameters);
- break;
-
- case DeconvolutionType.ExampleNewDeconvolutionTemplate:
- deconAlgorithm = new ExampleNewDeconvolutionAlgorithmTemplate(deconvolutionParameters);
- break;
-
- default: throw new MzLibException("DeconvolutionType not yet supported");
- }
-
- return deconAlgorithm.Deconvolute(scan.MassSpectrum, rangeToGetPeaksFrom);
+ foreach (var isotopicEnvelope in Deconvolute(scan.MassSpectrum, deconvolutionParameters, rangeToGetPeaksFrom)) 
+ yield return isotopicEnvelope;
  }
-
-
 
  /// <summary>
  /// Static deconvolution of an MzSpectrum that does not require Deconvoluter construction
@@ -79,7 +58,22 @@ public static IEnumerable<IsotopicEnvelope> Deconvolute(MzSpectrum spectrum,
  default: throw new MzLibException("DeconvolutionType not yet supported");
  }
 
- return deconAlgorithm.Deconvolute(spectrum, rangeToGetPeaksFrom);
+ // Short circuit deconvolution if it is called on a neutral mass spectrum
+ if (spectrum is NeutralMassSpectrum newt)
+ {
+ for (int i = 0; i < newt.XArray.Length; i++)
+ {
+ // skip this peak if it's outside the range of interest (e.g. if we're only interested in deconvoluting a small m/z range)
+ if (!rangeToGetPeaksFrom.Contains(newt.XArray[i].ToMz(newt.Charges[i])))
+ continue; 
+ yield return new IsotopicEnvelope(newt.XArray[i], newt.YArray[i], newt.Charges[i]);
+ }
+ }
+ else
+ {
+ foreach (var isotopicEnvelope in deconAlgorithm.Deconvolute(spectrum, rangeToGetPeaksFrom)) 
+ yield return isotopicEnvelope;
+ }
  }
  }
 }

mzLib/MassSpectrometry/MassSpectrometry.csproj

@@ -20,4 +20,8 @@
  <ProjectReference Include="..\MzLibUtil\MzLibUtil.csproj" />
  </ItemGroup>
 
+ <ItemGroup>
+ <InternalsVisibleTo Include="Development" />
+ <InternalsVisibleTo Include="Test" />
+ </ItemGroup>
 </Project>

mzLib/MassSpectrometry/MsDataFile.cs

@@ -23,9 +23,6 @@
 
 namespace MassSpectrometry
 {
- // TODO: Define scope of class 
- // Class scope is to provide to the data loaded from the DataFile. 
-
  /// <summary>
  /// A class for interacting with data collected from a Mass Spectrometer, and stored in a file
  /// </summary>

mzLib/MassSpectrometry/MzSpectra/IsotopicEnvelope.cs

@@ -14,40 +14,47 @@ public class IsotopicEnvelope : IHasMass
  /// <summary>
  /// Mass of most abundant observed isotopic peak, not accounting for addition or subtraction or protons due to ESI charge state induction
  /// </summary>
- public double MostAbundantObservedIsotopicMass { get; private set; }
+ internal double MostAbundantObservedIsotopicMass { get; private set; }
  public readonly int Charge;
  public readonly double TotalIntensity;
- public readonly double StDev;
- public readonly int MassIndex;
 
  public double Score { get; private set; }
 
- public IsotopicEnvelope(List<(double mz, double intensity)> bestListOfPeaks, double bestMonoisotopicMass, int bestChargeState, double bestTotalIntensity, double bestStDev, int bestMassIndex)
+ /// <summary>
+ /// Used for an isotopic envelope that mzLib deconvoluted (e.g., from a mass spectrum)
+ /// </summary>
+ public IsotopicEnvelope(List<(double mz, double intensity)> bestListOfPeaks, double bestMonoisotopicMass, int bestChargeState, double bestTotalIntensity, double bestStDev)
  {
  Peaks = bestListOfPeaks;
  MonoisotopicMass = bestMonoisotopicMass;
- MostAbundantObservedIsotopicMass = GetMostAbundantObservedIsotopicMass(bestListOfPeaks, bestChargeState);
+ MostAbundantObservedIsotopicMass = bestListOfPeaks.MaxBy(p => p.intensity).mz * Math.Abs(bestChargeState);
  Charge = bestChargeState;
  TotalIntensity = bestTotalIntensity;
- StDev = bestStDev;
- MassIndex = bestMassIndex;
- Score = ScoreIsotopeEnvelope();
+ Score = ScoreIsotopeEnvelope(bestStDev);
  }
 
- public double GetMostAbundantObservedIsotopicMass(List<(double mz, double intensity)> peaks, int charge)
+ /// <summary>
+ /// Used for a neutral mass read in from a deconvoluted file
+ /// Assumes the mass is correct: score is max value
+ /// </summary>
+ public IsotopicEnvelope(double monoisotopicMass, double intensity, int charge)
  {
- return peaks.MaxBy(p => p.intensity).mz * Math.Abs(charge);
+ MonoisotopicMass = monoisotopicMass;
+ Charge = charge;
+ TotalIntensity = intensity;
+ Score = double.MaxValue;
+ Peaks = [(monoisotopicMass.ToMz(charge), intensity)];
  }
 
  public override string ToString()
  {
  return Charge + "\t" + Peaks[0].mz.ToString("G8") + "\t" + Peaks.Count + "\t" + TotalIntensity;
  }
 
- private double ScoreIsotopeEnvelope() //likely created by Stefan Solntsev using peptide data
+ private double ScoreIsotopeEnvelope(double stDev) //likely created by Stefan Solntsev using peptide data
  {
  return Peaks.Count >= 2 ?
- TotalIntensity / Math.Pow(StDev, 0.13) * Math.Pow(Peaks.Count, 0.4) / Math.Pow(Math.Abs(Charge), 0.06) :
+ TotalIntensity / Math.Pow(stDev, 0.13) * Math.Pow(Peaks.Count, 0.4) / Math.Pow(Math.Abs(Charge), 0.06) :
  0;
  }
 
@@ -60,6 +67,5 @@ public void SetMedianMonoisotopicMass(List<double> monoisotopicMassPredictions)
  {
  MonoisotopicMass = monoisotopicMassPredictions.Median();
  }
-
  }
 }

mzLib/MassSpectrometry/MzSpectra/MzSpectrum.cs

@@ -22,10 +22,8 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Linq;
-using System.Text.Json;
 
 namespace MassSpectrometry
 {
@@ -126,7 +124,7 @@
  }
  }
 
- public double? FirstX
+ public virtual double? FirstX
  {
  get
  {
@@ -138,7 +136,7 @@
  }
  }
 
- public double? LastX
+ public virtual double? LastX
  {
  get
  {
@@ -373,7 +371,7 @@
  }
  }
 
- return new IsotopicEnvelope(listOfObservedPeaks, monoisotopicMass, chargeState, totalIntensity, Statistics.StandardDeviation(listOfRatios), massIndex);
+ return new IsotopicEnvelope(listOfObservedPeaks, monoisotopicMass, chargeState, totalIntensity, listOfRatios.StandardDeviation());
  }
 
  [Obsolete("Deconvolution Has been moved to the Deconvoluter Object")]
@@ -764,14 +762,14 @@
  return numerator / denominator;
  }
 
  public bool Equals(MzSpectrum? other)
  {
  if (ReferenceEquals(null, other)) return false;
  if (ReferenceEquals(this, other)) return true;
  return (XArray.SequenceEqual(other.XArray) && YArray.SequenceEqual(other.YArray));
  }
 
  public override bool Equals(object? spectrumToCompare)
  {
  if (ReferenceEquals(null, spectrumToCompare)) return false;
  if (ReferenceEquals(this, spectrumToCompare)) return true;
@@ -796,7 +794,12 @@
  return peakList[index];
  }
 
- private MzPeak GeneratePeak(int index)
+ /// <summary>
+ /// The source of all peaks which populate the peakList
+ /// </summary>
+ /// <param name="index"></param>
+ /// <returns></returns>
+ protected virtual MzPeak GeneratePeak(int index)
  {
  return new MzPeak(XArray[index], YArray[index]);
  }

mzLib/MassSpectrometry/MzSpectra/NeutralMassSpectrum.cs

@@ -0,0 +1,65 @@
+using System;
+using Chemistry;
+
+namespace MassSpectrometry
+{
+ public class NeutralMassSpectrum : MzSpectrum
+ {
+ public int[] Charges { get; init; }
+ public NeutralMassSpectrum(double[,] monoisotopicMassesIntensities, int[] charges) : base(monoisotopicMassesIntensities)
+ {
+ if (monoisotopicMassesIntensities.GetLength(0) != charges.Length)
+ throw new ArgumentException("The lengths of monoisotopicMasses, intensities, and charges must be the same.");
+
+ Charges = charges;
+
+ double minMz = double.MaxValue;
+ double maxMz = double.MinValue;
+ for (int i = 0; i < monoisotopicMassesIntensities.GetLength(0); i++)
+ {
+ var mz = monoisotopicMassesIntensities[i,0].ToMz(charges[i]);
+ if (mz < minMz)
+ minMz = mz;
+ if (mz > maxMz)
+ maxMz = mz;
+ }
+
+ FirstX = minMz;
+ LastX = maxMz;
+ }
+
+ public NeutralMassSpectrum(double[] monoisotopicMasses, double[] intensities, int[] charges, bool shouldCopy)
+ : base(monoisotopicMasses, intensities, shouldCopy)
+ {
+ if (monoisotopicMasses.GetLength(0) != intensities.Length || monoisotopicMasses.Length != charges.Length)
+ throw new ArgumentException("The lengths of monoisotopicMasses, intensities, and charges must be the same.");
+
+ Charges = charges;
+
+ double minMz = double.MaxValue;
+ double maxMz = double.MinValue;
+ for (int i = 0; i < monoisotopicMasses.Length; i++)
+ {
+ var mz = monoisotopicMasses[i].ToMz(charges[i]);
+ if (mz < minMz)
+ minMz = mz;
+ if (mz > maxMz)
+ maxMz = mz;
+ }
+
+ FirstX = minMz;
+ LastX = maxMz;
+ }
+
+ public override double? FirstX { get; } // in m/z
+ public override double? LastX { get; } // in m/z
+
+ /// <summary>
+ /// Converts to a charged spectrum
+ /// </summary>
+ protected override MzPeak GeneratePeak(int index)
+ {
+ return new MzPeak(XArray[index].ToMz(Charges[index]), YArray[index]);
+ }
+ }
+}