ScanTrailer as object

Author: caetera

ThermoRawFileParser.csproj

@@ -155,6 +155,7 @@
     <Compile Include="RawFileParser.cs" />
     <Compile Include="Util\LimitedSizeDictionary.cs" />
     <Compile Include="Util\Peptide.cs" />
+    <Compile Include="Writer\ScanTrailer.cs" />
     <Compile Include="XIC\JSONInputUnit.cs" />
     <Compile Include="XIC\JSONParser.cs" />
     <Compile Include="XIC\XicData.cs" />

Writer/MzMlSpectrumWriter.cs

@@ -31,7 +31,7 @@ public class MzMlSpectrumWriter : SpectrumWriter
 
         //tune version < 3 produces multiple trailer entry like "SPS Mass [number]"
         private readonly Regex SPSentry = new Regex(@"SPS Mass\s+\d+:");
-        //tune version == 3 produces trailer entry "SPS Masses/Continued"
+        //tune version == 3 produces trailer entry "SPS Masses (Continued)"
         private readonly Regex SPSentry3 = new Regex(@"SPS Masses(?:\s+Continued)?:");
 
         private IRawDataPlus _rawFile;
@@ -1142,7 +1142,46 @@ private SpectrumType ConstructMSSpectrum(int scanNumber)
             };
 
             // Trailer extra data list
-            var trailerData = _rawFile.GetTrailerExtraInformation(scanNumber);
+            var trailerData = new ScanTrailer(_rawFile.GetTrailerExtraInformation(scanNumber));
+            int? charge;
+            double? monoisotopicMz;
+            double? ionInjectionTime;
+            double? isolationWidth;
+            double? FAIMSCV = null;
+            List<double> SPSMasses = new List<double>();
+
+            charge = trailerData.AsPositiveInt("Charge State:");
+            monoisotopicMz = trailerData.AsDouble("Monoisotopic M/Z:");
+            ionInjectionTime = trailerData.AsDouble("Ion Injection Time (ms):");
+            isolationWidth = trailerData.AsDouble("MS" + (int)scanFilter.MSOrder + " Isolation Width:");
+            if (trailerData.AsBool("FAIMS Voltage On:").GetValueOrDefault(false))
+                FAIMSCV = trailerData.AsDouble("FAIMS CV:");
+
+            //tune version < 3
+            if (trailerData.Has("SPS Mass 1:"))
+            {
+                foreach (var label in trailerData.MatchKeys(SPSentry))
+                {
+                    var mass = trailerData.AsDouble(label).GetValueOrDefault(0);
+                    if (mass > 0) SPSMasses.Add((double)mass); //zero means mass does not exist
+                }
+            }
+
+            //tune version == 3
+            if (trailerData.Has("SPS Masses:"))
+            {
+                foreach (var label in trailerData.MatchKeys(SPSentry3))
+                {
+                    foreach (var mass in trailerData.Get(label).Trim().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
+                    {
+                        SPSMasses.Add(double.Parse(mass));
+                    }
+
+                }
+            }
+
+            //Older iterative version that works with trailer directly, can be removed if the new object version is better
+            /*var trailerData = _rawFile.GetTrailerExtraInformation(scanNumber);
             int? charge = null;
             double? monoisotopicMz = null;
             double? ionInjectionTime = null;
@@ -1200,7 +1239,7 @@ private SpectrumType ConstructMSSpectrum(int scanNumber)
                     }
                     
                 }
-            }
+            }*/
 
             // Construct and set the scan list element of the spectrum
             var scanListType = ConstructScanList(scanNumber, scan, scanFilter, scanEvent, monoisotopicMz,

Writer/ScanTrailer.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using ThermoFisher.CommonCore.Data.Business;
+
+namespace ThermoRawFileParser.Writer
+{
+    public class ScanTrailer
+    {
+        public int Length { get => data.Count; }
+
+        public string[] Labels { get => data.Keys.ToArray(); }
+
+        public string[] Values { get => data.Values.ToArray(); }
+
+        private Dictionary<string, string> data;
+
+        public ScanTrailer(LogEntry trailerData)
+        {
+            data = new Dictionary<string, string>();
+
+            for (int i = 0; i < trailerData.Length; i++)
+            {
+                data[trailerData.Labels[i]] = trailerData.Values[i].Trim();
+            }
+        }
+
+        public bool? AsBool(string key)
+        {
+            if(data.ContainsKey(key))
+            {
+                var stringValue = data[key].ToLower();
+
+                switch (stringValue)
+                {
+                    case "on":
+                    case "true":
+                    case "yes":
+                        return true;
+                    default:
+                        return false;
+                }
+            }
+
+            return null;
+        }
+
+        public double? AsDouble(string key)
+        {
+            if (data.ContainsKey(key))
+            {
+                if (double.TryParse(data[key], out var result)) return result;
+            }
+            return null;
+        }
+
+        public int? AsInt(string key)
+        {
+            if (data.ContainsKey(key))
+            {
+                if (int.TryParse(data[key], out var result)) return result;
+            }
+            return null;
+        }
+
+        public int? AsPositiveInt(string key)
+        {
+            int? value = AsInt(key);
+
+            if (value != null && value > 0) return value;
+            else return null;
+
+        }
+
+        public string AsString(string key)
+        {
+            return Get(key);
+        }
+
+        public string Get(string key)
+        {
+            if (data.ContainsKey(key))
+            {
+                return data[key];
+            }
+            return null;
+        }
+
+        public bool Has(string key)
+        {
+            return data.ContainsKey(key);
+        }
+
+        public IEnumerable<string> MatchKeys(Regex regex)
+        {
+            return data.Keys.Where(k => regex.IsMatch(k));
+        }
+
+        public IEnumerable<string> MatchValues(Regex regex)
+        {
+            return data.Where(item => regex.IsMatch(item.Key)).Select(item => item.Value);
+        }
+    }
+}