IsoDec Deconvolution Algorithm

mzLib/Development/Deconvolution/TestCases/SinglePeakDeconvolutionTestCase.cs → mzLib/Development/DeconvolutionDevelopment/TestCases/SinglePeakDeconvolutionTestCase.cs

@@ -23,7 +23,7 @@ public class SinglePeakDeconvolutionTestCase
         public SinglePeakDeconvolutionTestCase(DeconvolutionParameters deconParameters, string sampleInformation, string spectrumPath, int scanNumber,
             double expectedMostAbundantObservedIsotopicMass, int expectedIonChargeState, double selectedIonMz, double precursorPpmMassTolerance)
         {
-
+            DeconvolutionParameters = deconParameters;
             SampleInformation = sampleInformation;
             ExpectedMostAbundantObservedIsotopicMass = expectedMostAbundantObservedIsotopicMass;
             ExpectedIonChargeState = expectedIonChargeState;

mzLib/Development/Development.csproj

@@ -23,13 +23,13 @@
   </ItemGroup>
 
   <ItemGroup>
-    <None Update="Deconvolution\TestData\Averaged_221110_CytoOnly.mzML">
+    <None Update="DeconvolutionDevelopment\TestData\Averaged_221110_CytoOnly.mzML">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
-    <None Update="Deconvolution\TestData\Averaged_221110_HGHOnly.mzML">
+    <None Update="DeconvolutionDevelopment\TestData\Averaged_221110_HGHOnly.mzML">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
-    <None Update="Deconvolution\TestData\Averaged_221110_UbiqOnly.mzML">
+    <None Update="DeconvolutionDevelopment\TestData\Averaged_221110_UbiqOnly.mzML">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
   </ItemGroup>

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

@@ -1,13 +1,14 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using Chemistry;
 using MzLibUtil;
 
 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 +80,8 @@ 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/Algorithms/IsoDecAlgorithm.cs

@@ -0,0 +1,129 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using MzLibUtil;
+
+namespace MassSpectrometry
+{
+    internal class IsoDecAlgorithm : DeconvolutionAlgorithm
+    {
+
+        internal IsoDecAlgorithm(DeconvolutionParameters deconParameters) : base(deconParameters)
+        {
+
+        }
+
+        [StructLayout(LayoutKind.Sequential, Pack =1)]
+        public struct MatchedPeak
+        {
+            public float mz;
+            public int z;
+            public float monoiso;
+            public float peakmass;
+            public float avgmass;
+            public float area;
+            public float peakint;
+            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
+            public float[] matchedindsiso;
+            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
+            public float[] matchedindsexp;
+            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
+            public float[] isomz;
+            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
+            public float[] isodist;
+            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)]
+            public float[] isomass;
+            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
+            public float[] monoisos;
+            int startindex;
+            int endindex;
+            public float score;
+            public int realisolength;
+        }
+
+        [DllImport("isodeclib.dll", EntryPoint = "process_spectrum", CallingConvention = CallingConvention.Cdecl)]
+        protected static extern int process_spectrum(double[] cmz, float[] cintensity, int c, string fname, IntPtr matchedpeaks, IsoDecDeconvolutionParameters.IsoSettings settings);
+
+        internal override IEnumerable<IsotopicEnvelope> Deconvolute(MzSpectrum spectrum, MzRange range)
+        {
+            var deconParams = DeconvolutionParameters as IsoDecDeconvolutionParameters ?? throw new MzLibException("Deconvolution params and algorithm do not match");
+
+            var firstIndex = spectrum.GetClosestPeakIndex(range.Minimum);
+            var lastIndex = spectrum.GetClosestPeakIndex(range.Maximum);
+
+            var mzs = spectrum.XArray[firstIndex..lastIndex]
+                .Select(p => p)
+                .ToArray();
+            var intensities = spectrum.YArray[firstIndex..lastIndex]
+                .Select(p => (float)p)
+                .ToArray();
+
+            var mpArray = new byte[intensities.Length * Marshal.SizeOf(typeof(MatchedPeak))];
+            GCHandle handle = GCHandle.Alloc(mpArray, GCHandleType.Pinned);
+            try
+            {
+                IntPtr matchedPeaksPtr = (IntPtr)handle.AddrOfPinnedObject();
+                IsoDecDeconvolutionParameters.IsoSettings settings = deconParams.ToIsoSettings();
+                int result = process_spectrum(mzs, intensities, intensities.Length, null, matchedPeaksPtr, settings);
+                if (result <= 0)
+                    return Enumerable.Empty<IsotopicEnvelope>();
+
+                // Handle results
+                MatchedPeak[] matchedpeaks = new MatchedPeak[result];
+                for (int i = 0; i < result; i++)
+                {
+                    matchedpeaks[i] = Marshal.PtrToStructure<MatchedPeak>(matchedPeaksPtr + i * Marshal.SizeOf(typeof(MatchedPeak)));
+                }
+
+                return ConvertToIsotopicEnvelopes(deconParams, matchedpeaks, spectrum);
+            }
+            finally
+            {
+                handle.Free();
+            }
+        }
+
+        private List<IsotopicEnvelope> ConvertToIsotopicEnvelopes(IsoDecDeconvolutionParameters parameters, MatchedPeak[] matchedpeaks, MzSpectrum spectrum)
+        {
+            List<IsotopicEnvelope> result = new List<IsotopicEnvelope>();
+            int currentId = 0;
+            foreach(MatchedPeak peak in matchedpeaks)
+            {
+                List<(double,double)> peaks = new List<(double,double)> ();
+                for (int i = 0; i < peak.realisolength; i++)
+                {
+
+                    List<int> indicesWithinTolerance = spectrum.GetPeakIndicesWithinTolerance(peak.isomz[i], new PpmTolerance(5));
+                    double maxIntensity = 0;
+                    int maxIndex = -1;
+                    foreach (int index in indicesWithinTolerance)
+                    {
+                        if (spectrum.YArray[index] > maxIntensity) { maxIntensity = spectrum.YArray[index]; maxIndex = index; }
+                    }
+                    if (maxIndex >= 0)
+                    {
+                        peaks.Add((spectrum.XArray[maxIndex], spectrum.YArray[maxIndex]));
+                    }
+                    else
+                    {
+                        peaks.Add((peak.isomz[i], 0));
+                    }
+
+                }
+                int charge = peak.z;
+                if(parameters.Polarity == Polarity.Negative) { charge = -peak.z; }
+                if(parameters.ReportMulitpleMonoisos)
+                {
+                    foreach (float monoiso in peak.monoisos)
+                    {
+                        if (monoiso > 0) { result.Add(new IsotopicEnvelope(currentId, peaks, (double)monoiso, charge, peak.peakint, peak.score)); }
+                    }
+                }
+                else { result.Add(new IsotopicEnvelope(currentId, peaks, (double)peak.monoiso, charge, peak.peakint, peak.score)); }
+                currentId++;
+            }
+            return result;
+        }
+    }
+}

mzLib/MassSpectrometry/Deconvolution/Deconvoluter.cs

@@ -1,19 +1,11 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Easy.Common.Extensions;
-using Easy.Common.Interfaces;
+using Chemistry;
 using MzLibUtil;
 
 namespace MassSpectrometry
 {
-    public enum DeconvolutionType
-    {
-        ClassicDeconvolution,
-        ExampleNewDeconvolutionTemplate,
-    }
+
 
     /// <summary>
     /// Context class for all deconvolution
@@ -30,27 +22,10 @@ public static class Deconvoluter
         public static IEnumerable<IsotopicEnvelope> Deconvolute(MsDataScan scan,
             DeconvolutionParameters deconvolutionParameters, MzRange rangeToGetPeaksFrom = null)
         {
-            rangeToGetPeaksFrom ??= scan.MassSpectrum.Range;
-
-            // 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);
+            // set any specific deconvolution parameters found only in the MsDataScan
+            foreach (var isotopicEnvelope in Deconvolute(scan.MassSpectrum, deconvolutionParameters, rangeToGetPeaksFrom)) 
+                yield return isotopicEnvelope;
         }
-
-
 
         /// <summary>
         /// Static deconvolution of an MzSpectrum that does not require Deconvoluter construction
@@ -63,23 +38,31 @@ public static IEnumerable<IsotopicEnvelope> Deconvolute(MzSpectrum spectrum,
             DeconvolutionParameters deconvolutionParameters, MzRange rangeToGetPeaksFrom = null)
         {
             rangeToGetPeaksFrom ??= spectrum.Range;
-
             // set deconvolution algorithm 
-            DeconvolutionAlgorithm deconAlgorithm;
-            switch (deconvolutionParameters.DeconvolutionType)
+            DeconvolutionAlgorithm deconAlgorithm = deconvolutionParameters.DeconvolutionType switch
             {
-                case DeconvolutionType.ClassicDeconvolution:
-                    deconAlgorithm = new ClassicDeconvolutionAlgorithm(deconvolutionParameters);
-                    break;
+                DeconvolutionType.ClassicDeconvolution => new ClassicDeconvolutionAlgorithm(deconvolutionParameters),
+                DeconvolutionType.ExampleNewDeconvolutionTemplate => new ExampleNewDeconvolutionAlgorithmTemplate(deconvolutionParameters),
+                DeconvolutionType.IsoDecDeconvolution => new IsoDecAlgorithm(deconvolutionParameters),
+                _ => throw new MzLibException("DeconvolutionType not yet supported")
+            };
 
-                case DeconvolutionType.ExampleNewDeconvolutionTemplate:
-                    deconAlgorithm = new ExampleNewDeconvolutionAlgorithmTemplate(deconvolutionParameters);
-                    break;
-
-                default: throw new MzLibException("DeconvolutionType not yet supported");
+            // 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).ToList()) 
+                    yield return isotopicEnvelope;
             }
-
-            return deconAlgorithm.Deconvolute(spectrum, rangeToGetPeaksFrom);
         }
     }
 }

mzLib/MassSpectrometry/Deconvolution/DeconvolutionType.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MassSpectrometry
+{
+    public enum DeconvolutionType
+    {
+        ClassicDeconvolution,
+        ExampleNewDeconvolutionTemplate,
+        IsoDecDeconvolution,
+    }
+}