public Peak1DArray ReadSpectrumPeaks(string spectrumID)
{
RaiseDisposed();
try
{
int sampleIndex, experimentIndex, scanIndex;
Parse(spectrumID, out sampleIndex, out experimentIndex, out scanIndex);
using (MassSpectrometerSample sample = batch.GetSample(sampleIndex).MassSpectrometerSample)
using (MSExperiment msExp = sample.GetMSExperiment(experimentIndex))
{
Clearcore2.Data.MassSpectrum ms = msExp.GetMassSpectrum(scanIndex);
Peak1DArray pa = new Peak1DArray(
BinaryDataCompressionType.NoCompression,
BinaryDataType.Float32,
BinaryDataType.Float32);
//Peak1D[] peaks = new Peak1D[ms.NumDataPoints];
//for (int i = 0; i < ms.NumDataPoints; i++)
// peaks[i] = new Peak1D(ms.GetYValue(i), ms.GetXValue(i));
//pa.Peaks = MzLiteArray.ToMzLiteArray(peaks);
pa.Peaks = new WiffPeaksArray(ms);
return(pa);
}
}
catch (Exception ex)
{
throw new MzLiteIOException(ex.Message, ex);
}
}
private bool SqlTrySelect(string spectrumID, out Peak1DArray peaks)
{
SQLiteCommand cmd;
if (!currentScope.TryGetCommand("SELECT_SPECTRUM_PEAKS_CMD", out cmd))
{
cmd = currentScope.PrepareCommand("SELECT_SPECTRUM_PEAKS_CMD", "SELECT PeakArray, PeakData FROM Spectrum WHERE SpectrumID = @spectrumID");
}
else
{
cmd.Parameters.Clear();
}
cmd.Parameters.AddWithValue("@spectrumID", spectrumID);
using (SQLiteDataReader reader = cmd.ExecuteReader())
{
if (reader.Read())
{
peaks = MzLiteJson.FromJson <Peak1DArray>(reader.GetString(0));
decoder.Decode(reader.GetStream(1), peaks);
return(true);
}
else
{
peaks = null;
return(false);
}
}
}
private void WriteBinaryDataArrayList(Peak1DArray peaks)
{
writer.WriteStartElement("binaryDataArrayList");
WriteXmlAttribute("count", "2");
UserDescription mzParams = new UserDescription("mzParams");
mzParams
.SetMzArray()
.SetCompression(BinaryDataCompressionType.NoCompression)
.SetBinaryDataType(peaks.MzDataType);
double[] mzValues = peaks.Peaks.Select(x => x.Mz).ToArray();
WriteBinaryDataArray(mzValues, peaks.MzDataType, mzParams);
UserDescription intParams = new UserDescription("intParams");
intParams
.SetIntensityArray().NoUnit()
.SetCompression(BinaryDataCompressionType.NoCompression)
.SetBinaryDataType(peaks.IntensityDataType);
double[] intValues = peaks.Peaks.Select(x => x.Intensity).ToArray();
WriteBinaryDataArray(intValues, peaks.IntensityDataType, intParams);
writer.WriteEndElement();
}
public void Insert(string runID, MassSpectrum spectrum, Peak1DArray peaks)
{
RaiseDisposed();
RaiseNotInScope();
try
{
SqlInsert(runID, spectrum, peaks);
}
catch (Exception ex)
{
throw new MzLiteIOException(ex.Message, ex);
}
}
public Peak2D[] GetMS2(
IMzLiteDataReader dataReader,
SwathQuery query,
Func <IEnumerable <Peak1D>, RangeQuery, Peak1D> mzRangeSelector = null)
{
if (dataReader == null)
{
throw new ArgumentNullException("dataReader");
}
if (query == null)
{
throw new ArgumentNullException("query");
}
if (mzRangeSelector == null)
{
mzRangeSelector = GetClosestMz;
}
MSSwath swath = swathList.SearchClosestTargetMz(query);
if (swath == null)
{
return(new Peak2D[0]);
}
SwathSpectrumEntry swathSpec = swath.SearchClosestRt(query);
if (swathSpec == null)
{
return(new Peak2D[0]);
}
Peak1DArray spectrumPeaks = dataReader.ReadSpectrumPeaks(swathSpec.SpectrumID);
Peak2D[] ms2Peaks = new Peak2D[query.CountMS2Masses];
for (int i = 0; i < query.CountMS2Masses; i++)
{
RangeQuery mzRange = query[i];
IEnumerable <Peak1D> mzPeaks = BinarySearch.Search(spectrumPeaks.Peaks, mzRange, MzRangeCompare);
Peak1D p = mzRangeSelector(mzPeaks, mzRange);
ms2Peaks[i] = new Peak2D(p.Intensity, p.Mz, swathSpec.Rt);
}
return(ms2Peaks);
}
private void SqlInsert(string runID, MassSpectrum spectrum, Peak1DArray peaks)
{
SQLiteCommand cmd;
if (!currentScope.TryGetCommand("INSERT_SPECTRUM_CMD", out cmd))
{
cmd = currentScope.PrepareCommand("INSERT_SPECTRUM_CMD", "INSERT INTO Spectrum VALUES(@runID, @spectrumID, @description, @peakArray, @peakData);");
}
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@runID", runID);
cmd.Parameters.AddWithValue("@spectrumID", spectrum.ID);
cmd.Parameters.AddWithValue("@description", MzLiteJson.ToJson(spectrum));
cmd.Parameters.AddWithValue("@peakArray", MzLiteJson.ToJson(peaks));
cmd.Parameters.AddWithValue("@peakData", encoder.Encode(peaks));
cmd.ExecuteNonQuery();
}
public void WriteSpectrum(MassSpectrum ms, Peak1DArray peaks, int index)
{
try
{
if (ms == null)
{
throw new ArgumentNullException("ms");
}
if (peaks == null)
{
throw new ArgumentNullException("peaks");
}
if (index < 0)
{
throw new ArgumentOutOfRangeException("idx");
}
EnsureWriteState(MzMLWriteState.SPECTRUM_LIST);
writer.WriteStartElement("spectrum");
WriteXmlAttribute("id", ms.ID, true);
WriteXmlAttribute("index", index.ToString(formatProvider), true);
WriteXmlAttribute("dataProcessingRef", ms.DataProcessingReference, false);
WriteXmlAttribute("sourceFileRef", ms.SourceFileReference, false);
WriteXmlAttribute("defaultArrayLength", peaks.Peaks.Length.ToString(formatProvider), true);
WriteParamGroup(ms);
WriteList("scanList", ms.Scans, WriteScan);
WriteList("precursorList", ms.Precursors, WritePrecursor);
WriteList("productList", ms.Products, WriteProduct);
WriteBinaryDataArrayList(peaks);
writer.WriteEndElement();
}
catch (Exception ex)
{
currentWriteState = MzMLWriteState.ERROR;
throw new MzLiteIOException("Error writing mzml output file.", ex);
}
}
private Binary.Peak1DArray ReadSpectrumPeaks(int scanNo)
{
RaiseDisposed();
try
{
int peakArraySize = 0;
double controidPeakWith = 0;
object massList = null;
object peakFlags = null;
rawFile.GetMassListFromScanNum(
ref scanNo,
null, 1, 0, 0, 0,
ref controidPeakWith,
ref massList,
ref peakFlags,
ref peakArraySize);
double[,] peakData = massList as double[, ];
Peak1DArray pa = new Peak1DArray(
BinaryDataCompressionType.NoCompression,
BinaryDataType.Float32,
BinaryDataType.Float32);
//Peak1D[] peaks = new Peak1D[peakArraySize];
//for (int i = 0; i < peakArraySize; i++)
// peaks[i] = new Peak1D(peakData[1, i], peakData[0, i]);
//pa.Peaks = MzLiteArray.ToMzLiteArray(peaks);
pa.Peaks = new ThermoPeaksArray(peakData, peakArraySize);
return(pa);
}
catch (Exception ex)
{
throw new MzLiteIOException(ex.Message, ex);
}
}
public Peak1DArray ReadSpectrumPeaks(UInt64 spectrumId, bool getCentroids)
{
BafSqlSpectrum bafSpec = linq2BafSql.GetBafSqlSpectrum(this.linq2BafSql.Core, spectrumId);
if (bafSpec == null)
{
throw new MzLiteIOException("No spectrum found for id: " + spectrumId);
}
Peak1DArray pa = new Peak1DArray(
BinaryDataCompressionType.NoCompression,
BinaryDataType.Float32,
BinaryDataType.Float32);
double[] masses;
UInt32[] intensities;
// if profile data available we prefer to get profile data otherwise centroided data (line spectra)
if (getCentroids && bafSpec.LineMzId.HasValue && bafSpec.LineIntensityId.HasValue)
{
masses = Baf2SqlWrapper.GetBafDoubleArray(baf2SqlHandle, bafSpec.LineMzId.Value);
intensities = Baf2SqlWrapper.GetBafUInt32Array(baf2SqlHandle, bafSpec.LineIntensityId.Value);
}
else if (getCentroids == false && bafSpec.ProfileMzId.HasValue && bafSpec.ProfileIntensityId.HasValue)
{
masses = Baf2SqlWrapper.GetBafDoubleArray(baf2SqlHandle, bafSpec.ProfileMzId.Value);
intensities = Baf2SqlWrapper.GetBafUInt32Array(baf2SqlHandle, bafSpec.ProfileIntensityId.Value);
}
else
{
masses = new double[0];
intensities = new UInt32[0];
}
pa.Peaks = new BafPeaksArray(masses, intensities);
return(pa);
}
public Task InsertAsync(string runID, MassSpectrum spectrum, Peak1DArray peaks)
{
return(Task.Run(() => { Insert(runID, spectrum, peaks); }));
}
