/// <summary>
/// Illustrate how to make calls to deisotope a spectrum.
/// </summary>
/// <param name="dataAccess"></param>
private void DeisotopeTest(IMsdrDataReader dataAccess)
{
IMsdrPeakFilter filter1 = new MsdrPeakFilter();
filter1.AbsoluteThreshold = 10;
filter1.RelativeThreshold = 0.1;
filter1.MaxNumPeaks = 0;//no limit on max number of peaks
IMsdrChargeStateAssignmentFilter csaFilter = new MsdrChargeStateAssignmentFilter();
IBDASpecFilter f = new BDASpecFilter();
f.SpectrumType = SpecType.MassSpectrum;
IBDAMSScanFileInformation msscanFileInfo = dataAccess.MSScanFileInformation;
int numSpectra = (int)msscanFileInfo.TotalScansPresent;
int nNonEmptyCount = 0; // just deisotope the first 10 non-empty spectra
for (int i = 0; i < numSpectra; i++)
{
IBDASpecData spec = dataAccess.GetSpectrum(i, filter1, filter1);//same peak filter used for both MS and MS2 spectra (you can pass in 2 different filters)
println("Original spectrum has " + spec.TotalDataPoints + " points");
if (spec.XArray.Length > 0)
{
++nNonEmptyCount;
}
if (nNonEmptyCount > 10)
{
break;
}
dataAccess.Deisotope(spec, csaFilter);
println(" Deisotoped spectrum has " + spec.TotalDataPoints + " points");
}
}
public override void Dispose()
{
if(_msdr != null)
{
_msdr.CloseDataFile();
_msdr = null;
}
base.Dispose();
}
/// <summary>
/// Get all scans in the data file using row index. The storage mode defaults to peakElseProfile.
/// Passing null for peak filter means do not filter any peaks.
/// </summary>
/// <param name="dataAccess"></param>
private void GetAllScansUsingRowIndex(IMsdrDataReader dataAccess)
{
long totalNumScans = dataAccess.MSScanFileInformation.TotalScansPresent;
for (int i = 0; i < totalNumScans; i++)
{
IBDASpecData spec = dataAccess.GetSpectrum(i, null, null);//no peak filtering
}
}
private void GetAllScanRecords(IMsdrDataReader dataAccess)
{
long totalNumScans = dataAccess.MSScanFileInformation.TotalScansPresent;
for (int i = 0; i < totalNumScans; i++)
{
IMSScanRecord scanRecord = dataAccess.GetScanRecord(i);
println("MSSCANRECORD - Scan ID : " + scanRecord.ScanID + " RT = " + scanRecord.RetentionTime.ToString() + " MSLevel = " + scanRecord.MSLevel.ToString());
}
}
public override void Open()
{
if (IsOpen)
{
return;
}
_msdr = new MassSpecDataReader();
_msdr.OpenDataFile(FilePath);
base.Open();
}
public static PeakList <Peak> GetPeakList(this IMsdrDataReader reader, double retentionTime, double minPeakIntensity, int maxNumPeaks)
{
IMsdrPeakFilter peakFilter = new MsdrPeakFilter();
peakFilter.AbsoluteThreshold = minPeakIntensity;
peakFilter.RelativeThreshold = 0;
peakFilter.MaxNumPeaks = maxNumPeaks;
return(GetPeakList(reader, retentionTime, peakFilter));
}
public static int GetMsLevel(this IMsdrDataReader reader, double retentionTime)
{
switch (reader.GetMSScanInformation(retentionTime).MSLevel)
{
case MSLevel.MS: return(1);
case MSLevel.MSMS: return(2);
default: return(0);
}
}
/// <summary>
/// Illustrate how to use
/// GetSpectrum(double retentionTime, MSScanType scanType, IonPolarity ionPolarity, IonizationMode ionMode, IMsdrPeakFilter peakFilter, bool peakFilterOnCentroid);
/// Get a TIC, and then use the retention time array to access each scan.
/// </summary>
/// <param name="dataAccess"></param>
private void DoSpectrumExtractionTest(IMsdrDataReader dataAccess)
{
IMsdrPeakFilter filter1 = new MsdrPeakFilter();
filter1.AbsoluteThreshold = 10;
filter1.RelativeThreshold = 0.1;
filter1.MaxNumPeaks = 0;
IBDAChromFilter chromFilter = new BDAChromFilter();
chromFilter.ChromatogramType = ChromType.TotalIon;
chromFilter.DesiredMSStorageType = DesiredMSStorageType.PeakElseProfile;
IBDAChromData[] chroms = dataAccess.GetChromatogram(chromFilter);
IBDAChromData chrom = chroms[0];
double[] retTime = chrom.XArray;
for (int i = 0; i < retTime.Length; i++)
{
println("Extract spectrum at RT=" + retTime[i]);
//Get a spectrum without doing peak filtering if the spectrum is centroid
//The peak filter passed in will be applied to profile spectrum, but not
//centroid spectrum, because the flag peakFilterOnCentroid=false
IBDASpecData spec = dataAccess.GetSpectrum(retTime[i], MSScanType.All, IonPolarity.Mixed, IonizationMode.Unspecified, filter1, false);//peakFilterOnCentroid=false
/*//uncomment this section if you want to print out spectrum points
* double[] mzVals = spec.XArray;
* float[] aboundanceVals = spec.YArray;
* for (int j = 0; j < mzVals.Length; j++)
* {
* println(mzVals[j] + ", " + aboundanceVals[j]);
* }
*/
//Get a spectrum and apply peak filtering to it regardless profile or centroid
IBDASpecData spec2 = dataAccess.GetSpectrum(retTime[i], MSScanType.All, IonPolarity.Mixed, IonizationMode.Unspecified, filter1, true);//peakFilterOnCentroid=true
/*
* mzVals = spec.XArray;
* aboundanceVals = spec.YArray;
* for (int j = 0; j < mzVals.Length; j++)
* {
* if (aboundanceVals[j] > 5000)
* {
* println(mzVals[j] + ", " + aboundanceVals[j]);
* }
* }
*/
if (spec2.TotalDataPoints > spec.TotalDataPoints)
{//since spec2 is always thresholded, it must have less than or equal # of points as spec
println(" Error: filtered spectrum contains more points than unfiltered spectrum!");
}
}
}
/// <summary>
/// Display the sample information
/// </summary>
/// <param name="dataAccess"></param>
private void GetSampleInfoData(IMsdrDataReader dataAccess)
{
IBDASampleData[] sampleData = dataAccess.GetSampleCollection();
string strPrint = string.Empty;
println("\nDISPLAYING SAMPLE INFORMATION DATA");
foreach (IBDASampleData smpData in sampleData)
{
strPrint = strPrint + smpData.DisplayName + " : " + smpData.DataValue.ToString() + Environment.NewLine;
}
println(strPrint);
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (_msdr != null)
{
_msdr.CloseDataFile();
_msdr = null;
}
}
base.Dispose(disposing);
}
public static IBDAChromData GetChromData(this IMsdrDataReader reader)
{
IBDAChromFilter chroFilter = new BDAChromFilter();
chroFilter.ChromatogramType = ChromType.TotalIon;
chroFilter.DoCycleSum = false;
chroFilter.DesiredMSStorageType = DesiredMSStorageType.PeakElseProfile;
IBDAChromData[] chro = reader.GetChromatogram(chroFilter);
return(chro[0]);
}
private void GetMSLevels(IMsdrDataReader dataAccess)
{
long totalNumScans = dataAccess.MSScanFileInformation.TotalScansPresent;
for (int i = 0; i < totalNumScans; i++)
{
IBDASpecData spec = dataAccess.GetSpectrum(i, null, null);//no peak filtering
IRange[] timeRange = spec.AcquiredTimeRange;
Console.WriteLine(timeRange[0].Start);
Console.WriteLine(i.ToString() + "\t" + spec.MSLevelInfo + "\t" + timeRange[0].Start);
}
}
public static List <PeakList <Peak> > GetAllPeakList(this IMsdrDataReader reader, double[] retentionTimes, IProgressCallback progress)
{
List <PeakList <Peak> > result = new List <PeakList <Peak> >(retentionTimes.Length);
progress.SetRange(1, retentionTimes.Length);
for (int i = 0; i < retentionTimes.Length; i++)
{
progress.SetPosition(i);
result.Add(GetPeakList(reader, retentionTimes[i], 1));
}
return(result);
}
private void PrintDeviceInfo(IMsdrDataReader dataAccess)
{
println("Device Table: ");
DataTable table = dataAccess.FileInformation.GetDeviceTable(StoredDataType.All);
StringBuilder buf = new StringBuilder();
foreach (DataRow r in table.Rows)
{
foreach (DataColumn c in table.Columns)
{
buf.AppendLine("\t" + c.ColumnName + ": " + r[c].ToString());
}
buf.AppendLine();
}
print(buf.ToString());
}
private void DoSpectrumExtractionTestWithStorage(IMsdrDataReader dataAccess)
{
IMsdrPeakFilter filter1 = new MsdrPeakFilter();
filter1.AbsoluteThreshold = 10;
filter1.RelativeThreshold = 0.1;
filter1.MaxNumPeaks = 0;
IBDAMSScanFileInformation msscanFileInfo = dataAccess.MSScanFileInformation;
int numSpectra = (int)msscanFileInfo.TotalScansPresent;
for (int i = 0; i < numSpectra; i++)
{
IBDASpecData spec = dataAccess.GetSpectrum(i, filter1, filter1, DesiredMSStorageType.PeakElseProfile);
println("Spectrum " + i.ToString() + "has " + spec.TotalDataPoints + " points");
}
}
public static PeakList <Peak> GetPeakList(this IMsdrDataReader reader, double retentionTime, IMsdrPeakFilter peakFilter)
{
PeakList <Peak> result = new PeakList <Peak>();
IBDASpecData s = reader.GetSpectrum(retentionTime, MSScanType.All, IonPolarity.Mixed, IonizationMode.Unspecified, peakFilter, true);
for (int i = 0; i < s.XArray.Length; i++)
{
result.Add(new Peak(s.XArray[i], s.YArray[i]));
}
if (s.MZOfInterest.Length > 0)
{
result.PrecursorMZ = s.MZOfInterest[0].Start;
}
result.ScanTimes.Add(new ScanTime(0, retentionTime));
return(result);
}
private void PrintFileInfo(IMsdrDataReader dataAccess)
{
IBDAFileInformation fileInfo = dataAccess.FileInformation;
println("Data File: " + fileInfo.DataFileName);
println("Acquisition Time: " + fileInfo.AcquisitionTime.ToShortDateString());
println("IRM Status: " + fileInfo.IRMStatus);
println("Measurement Type: " + fileInfo.MeasurementType);
println("Separation Technique: " + fileInfo.SeparationTechnique);
print("MS Data Present: ");
if (fileInfo.IsMSDataPresent())
{
println("yes");
}
else
{
println("no");
}
print("Non-MS data present: ");
if (fileInfo.IsNonMSDataPresent())
{
println("yes");
}
else
{
println("no");
}
print("UV spectra present: ");
if (fileInfo.IsUVSpectralDataPresent())
{
println("yes");
}
else
{
println("no");
}
}
private void GetAxisInformation(IMsdrDataReader dataAccess)
{
DataUnit chromunit;
DataValueType chromvalueType;
IBDAChromFilter filter = new BDAChromFilter();
filter.ChromatogramType = ChromType.TotalIon;
IBDAChromData[] chroms = dataAccess.GetChromatogram(filter);
if (chroms.Length > 0)
{
chroms[0].GetXAxisInfoChrom(out chromunit, out chromvalueType);
println("X Axis");
println("======");
println("Data Unit: " + BaseUtilities.GetEnumString(chromunit, true));
println("Data Value type: " + BaseUtilities.GetEnumString(chromvalueType, true));
chroms[0].GetYAxisInfoChrom(out chromunit, out chromvalueType);
println("Y Axis");
println("======");
println("Data Unit: " + BaseUtilities.GetEnumString(chromunit, true));
println("Data Value type: " + BaseUtilities.GetEnumString(chromvalueType, true));
println(string.Empty);
}
}
/// <summary>
/// EIC Extraction
/// </summary>
/// <param name="dataAccess"></param>
private void ExtractEIC(IMsdrDataReader dataAccess)
{
IBDAChromFilter filter = new BDAChromFilter();
filter.ChromatogramType = ChromType.ExtractedIon;
IRange[] ranges = new IRange[1];
ranges[0] = new CenterWidthRange(158, 1);//EC: center mass is 158 Da, with a 1 Da window
// ranges[0] = new MinMaxRange(157.5, 158.5);//EC: this is another way to do the same thing
filter.IncludeMassRanges = ranges;
IBDAChromData[] chroms = dataAccess.GetChromatogram(filter);
println("\n EIC EXTRACTION\n");
string chromDesc = string.Empty;
for (int i = 0; i < chroms.Length; i++)
{
chromDesc = "Chromatogram extracted with : Chromatogram type =" + chroms[i].ChromatogramType.ToString()
+ " and Total Datapoints = " + chroms[i].TotalDataPoints.ToString()
+ " for range = " + chroms[i].AcquiredTimeRange[0].Start.ToString()
+ "-" + chroms[i].AcquiredTimeRange[0].End.ToString()
+ Environment.NewLine;
println(chromDesc);
}
}
private void OpenDataset()
{
m_reader = new MassSpecDataReader();
m_reader.OpenDataFile(this.Filename);
}
public static PeakList <Peak> GetPeakList(this IMsdrDataReader reader, double retentionTime)
{
return(GetPeakList(reader, retentionTime, 1));
}
public override void Open()
{
if (IsOpen)
return;
_msdr = new MassSpecDataReader();
_msdr.OpenDataFile(FilePath);
base.Open();
}
private void OpenDataset()
{
m_reader = new MassSpecDataReader();
m_reader.OpenDataFile(DatasetFileOrDirectoryPath);
}
public static PeakList <Peak> GetPeakList(this IMsdrDataReader reader, double retentionTime, double minPeakIntensity)
{
return(GetPeakList(reader, retentionTime, minPeakIntensity, 0));
}
public override int LoadIndex(string FileName)
{
this.RawFileName = FileName;
RawFile = new MassSpecDataReader();
MSReader = RawFile;
MSReader.OpenDataFile(FileName);
Spectra = (int)(MSReader.MSScanFileInformation.TotalScansPresent);
bool PosMode = false, NegMode = false;
if (Spectra <= 0)
{
return(0);
}
int i, LastFull = 0, Total = 0;
//there will be fake [0] spectra with no data and fake last spectra with no data
//it is made to make any chromatogram start and end with zero
IndexDir = new int[Spectra + 2];
IndexRev = new int[Spectra + 2];
RawSpectra = new RawSpectrum[Spectra + 2];
for (int j = 0; j <= Spectra + 1; j++)
{
RawSpectra[j] = new RawSpectrum();
}
TimeStamps = new double[Spectra + 2];
TimeCoefs = new double[Spectra + 2];
LowRT = 0.0;
HighRT = 0.0;
int Progress = 0;
for (i = 1; i <= Spectra; i++)
{
if ((int)(100.0 * ((double)i / (double)Spectra)) > Progress)//report progress
{
Progress = (int)(100.0 * ((double)i / (double)Spectra));
RepProgress?.Invoke(Progress);
}
IMSScanRecord ScanRecord = MSReader.GetScanRecord(i - 1);
if (ScanRecord.MSScanType == MSScanType.Scan && ScanRecord.MSLevel == MSLevel.MS && ScanRecord.CollisionEnergy == 0.0) //if spectra is a FULL MS
{
PosMode |= ScanRecord.IonPolarity == IonPolarity.Positive;
NegMode |= ScanRecord.IonPolarity == IonPolarity.Negative;
RawSpectra[i].RT = ScanRecord.RetentionTime;
TimeStamps[i] = RawSpectra[i].RT - RawSpectra[LastFull].RT;
RawSpectra[i].Scan = i;
IndexDir[LastFull] = i;
IndexRev[i] = LastFull;
LastFull = i;
Total++;
}
}
IndexDir[LastFull] = Spectra + 1;
IndexDir[Spectra + 1] = -1;
IndexRev[Spectra + 1] = LastFull;
TotalRT = RawSpectra[LastFull].RT;
AverageTimeStamp = TotalRT / Total;
//time interval bias coefficients
for (i = IndexDir[0]; IndexDir[i] != -1; i = IndexDir[i])
{
TimeCoefs[i] = (TimeStamps[i] + TimeStamps[IndexDir[i]]) / (2.0 * AverageTimeStamp);
}
TimeCoefs[i] = 1.0;
//Fake spectra number 0 has to have reasonable RT
double FRT = RawSpectra[IndexDir[0]].RT;
double SRT = RawSpectra[IndexDir[IndexDir[0]]].RT;
RawSpectra[0].RT = Math.Max(0, FRT - (SRT - FRT));
//Last spectra also has to have reasonable RT
FRT = RawSpectra[LastFull].RT;
SRT = RawSpectra[IndexRev[LastFull]].RT;
RawSpectra[Spectra + 1].RT = FRT + (FRT - SRT);
RawSpectra[0].Data = new MZData[0];
RawSpectra[Spectra + 1].Data = new MZData[0];
PeakFilter = new MsdrPeakFilter();
PeakFilter.AbsoluteThreshold = 5.0;
if (PosMode && !NegMode)
{
Mode = 1;
}
if (!PosMode && NegMode)
{
Mode = -1;
}
return(Spectra);
}
public AgilentDirectoryImpl()
{
Reader = new MassSpecDataReader();
fileOpened = false;
retentionTimes = new double[0];
}
private static bool GetAccurateMZAndIntensity(IDictionary<int, IBDASpecData> ms1s, IMsdrDataReader agilentD, int parentScanId, ref double mz, out double intensity)
{
IBDASpecData ms1;
lock(ms1s)
{
if(!ms1s.TryGetValue(parentScanId, out ms1))
{
IBDASpecFilter spec_filter = new BDASpecFilter();
spec_filter.SpectrumType = SpecType.MassSpectrum;
spec_filter.ScanIds = new int[] { parentScanId };
lock(agilentD)
{
ms1 = agilentD.GetSpectrum(spec_filter)[0];
}
ms1s.Add(parentScanId, ms1);
}
}
int index = -1;
for(int i = 0; i < ms1.TotalDataPoints; i++)
{
if(index < 0 || Math.Abs(ms1.XArray[i] - mz) < Math.Abs(ms1.XArray[index] - mz))
{
index = i;
}
}
if(index >= 0)
{
mz = ms1.XArray[index];
intensity = ms1.YArray[index];
return true;
}
intensity = double.NaN;
return false;
}
private static bool GetAccurateMZAndIntensity(IDictionary <int, IBDASpecData> ms1s, IMsdrDataReader agilentD, int parentScanId, ref double mz, out double intensity)
{
IBDASpecData ms1;
lock (ms1s)
{
if (!ms1s.TryGetValue(parentScanId, out ms1))
{
IBDASpecFilter spec_filter = new BDASpecFilter();
spec_filter.SpectrumType = SpecType.MassSpectrum;
spec_filter.ScanIds = new int[] { parentScanId };
lock (agilentD)
{
ms1 = agilentD.GetSpectrum(spec_filter)[0];
}
ms1s.Add(parentScanId, ms1);
}
}
int index = -1;
for (int i = 0; i < ms1.TotalDataPoints; i++)
{
if (index < 0 || Math.Abs(ms1.XArray[i] - mz) < Math.Abs(ms1.XArray[index] - mz))
{
index = i;
}
}
if (index >= 0)
{
mz = ms1.XArray[index];
intensity = ms1.YArray[index];
return(true);
}
intensity = double.NaN;
return(false);
}
private void PrintMSScanInfo(IMsdrDataReader dataAccess)
{
//////////////////////////////////////
///MSScan.bin information
/////////////////////////////////////////
IBDAMSScanFileInformation msscan = dataAccess.FileInformation.MSScanFileInformation;
//TotalScansPresent
println("Total # of Scans: " + msscan.TotalScansPresent);
//SpectraFormat
println("Spectral Format: " + msscan.SpectraFormat);
//is fixed cycle length?
println("Is fixed cycle length data present? " + msscan.IsFixedCycleLengthDataPresent());
//is multiple spectra per scan present?
println("Is multiple spectra per scan present? " + msscan.IsMultipleSpectraPerScanPresent());
//IonPolarity
println("Ion Polarity: " + msscan.IonPolarity);
//MSLevel
println("MS Level: " + msscan.MSLevel);
//IonModes
println("Ionization Mode: " + msscan.IonModes);
//DeviceType
println("Device Type: " + msscan.DeviceType);
//CollisionEnergy
print("Collision Energies: ");
double[] collisionEnergy = msscan.CollisionEnergy;
if (collisionEnergy.Length == 0)
{
println("None");
}
else
{
for (int i = 0; i < collisionEnergy.Length; i++)
{
if (i == collisionEnergy.Length - 1)//last one
{
println(Convert.ToString(collisionEnergy[i]));
}
else
{
print(Convert.ToString(collisionEnergy[i]) + ", ");
}
}
}
//FragmentorVoltages
print("Fragmentor Voltages: ");
double[] fragVolt = msscan.FragmentorVoltage;
if (fragVolt.Length == 0)
{
println("None");
}
else
{
for (int i = 0; i < fragVolt.Length; i++)
{
if (i == fragVolt.Length - 1)//last one
{
println(Convert.ToString(fragVolt[i]));
}
else
{
print(Convert.ToString(fragVolt[i] + ", "));
}
}
}
//MRMTransitions
print("MRM transitions: ");
IRange[] mrmTrans = msscan.MRMTransitions;
if (mrmTrans.Length == 0)
{
println("None");
}
else
{
for (int i = 0; i < mrmTrans.Length; i++)
{
if (i == mrmTrans.Length - 1)//last one
{
println(Convert.ToString(mrmTrans[i].Start) + "->" + Convert.ToString(mrmTrans[i].End));
}
else
{
print(Convert.ToString(mrmTrans[i].Start) + "->" + Convert.ToString(mrmTrans[i].End) + ", ");
}
}
}
//SIMIons
double[] simIons = msscan.SIMIons;
print("SIM ions: ");
if (simIons.Length == 0)
{
println("None");
}
else
{
for (int i = 0; i < simIons.Length; i++)
{
if (i == simIons.Length - 1)
{
println(Convert.ToString(simIons[i]));
}
else
{
print(Convert.ToString(simIons[i]) + ", ");
}
}
}
//ScanMethodNumbers
print("Scan Method Numbers: ");
int[] scanMethodNums = msscan.ScanMethodNumbers;
if (scanMethodNums.Length == 0)
{
println("None");
}
else
{
for (int i = 0; i < scanMethodNums.Length; i++)
{
if (i == scanMethodNums.Length - 1)//last one
{
println(Convert.ToString(scanMethodNums[i]));
}
else
{
print(Convert.ToString(scanMethodNums[i]) + ", ");
}
}
}
//ScanTypesInformationCount
println("Scan Type Count: " + msscan.ScanTypesInformationCount);
//ScanTypes
println("Scan types: " + msscan.ScanTypes);
StringBuilder buf = new StringBuilder();
IBDAMSScanTypeInformation[] types = msscan.GetMSScanTypeInformation();
foreach (IBDAMSScanTypeInformation type in types)
{
double[] mz = type.MzOfInterest;
buf.Append("MS scan type: " + type.MSScanType + ", " + type.IonPolarities);
if (mz != null && mz.Length > 0)
{
buf.Append(", m/z of interest = ");
for (int i = 0; i < mz.Length; i++)
{
if (i == mz.Length - 1)//last one
{
buf.Append(mz[i]);
}
else
{
buf.Append(mz[i] + ", ");
}
}
}
buf.AppendLine();
}
print(buf.ToString());
}
/// <summary>
/// Get all Product Ion MS/MS scans and print out the precursor and collision energy.
/// </summary>
private void GetPrecursorInfo(IMsdrDataReader dataAccess)
{
//Create a chromatogram filter to let the scans that match
//the filter criteria to pass through
IBDAChromFilter chromFilter = new BDAChromFilter();
chromFilter.ChromatogramType = ChromType.TotalIon;
chromFilter.DesiredMSStorageType = DesiredMSStorageType.PeakElseProfile;//This means to use peak scans if available, otherwise use profile scans
chromFilter.MSLevelFilter = MSLevel.MSMS;
chromFilter.MSScanTypeFilter = MSScanType.ProductIon;
IBDAChromData[] chroms = dataAccess.GetChromatogram(chromFilter);//expect 1 chromatogram because we're not asking it to separate by scan segments, etc.
IBDAChromData chrom = chroms[0];
double[] retTime = chrom.XArray;
println("Get MS/MS spectra using retention time");
for (int i = 0; i < retTime.Length; i++)
{
//for each retention time, get the corresponding scan
//passing in null for peak filter means no peak threshold applied
IBDASpecData spec = dataAccess.GetSpectrum(retTime[i], MSScanType.ProductIon, IonPolarity.Mixed, IonizationMode.Unspecified, null);
print("RT=" + retTime[i] + ", ");
int precursorCount = 0;
double[] precursorIons = spec.GetPrecursorIon(out precursorCount);
if (precursorCount == 1)
{
print("Precursor Ions:");
for (int j = 0; j < precursorIons.Length; j++)
{
print(precursorIons[j] + " ");
}
println("");
int charge;
double intensity;
if (spec.GetPrecursorCharge(out charge))
{
println(" charge: " + charge);
}
else
{
println(" no charge avaialble");
}
if (spec.GetPrecursorIntensity(out intensity))
{
println(" intensity: " + intensity);
}
else
{
println(" no intensity available");
}
}
else
{
println("No precursor ions");
}
/*
* //Uncomment this if you want to print out x and y values of the spectrum.
* double[] mzVals = spec.XArray;
* float[] aboundanceVals = spec.YArray;
* println("RT=" + retTime[i]);
* for (int j = 0; j < mzVals.Length; j++)
* {
* println(mzVals[j] + ", " + aboundanceVals[j]);
* }
*/
}
}
public static double[] GetRetentionTimes(this IMsdrDataReader reader)
{
return(GetChromData(reader).XArray);
}
