private Comb.mzI[][] newScansRaw(BinStackOptions _options,
Comb.mzI[][] _scansRaw,
int _spectrumToQuantitate,
double _parentMass,
double[,] _specData)
{
double[,] data = _specData as double[, ];
double minMass = data[0, 0];
double maxMass = data[0, data.GetUpperBound(1)];
int minMassPos = 0;
int maxMassPos = data.GetUpperBound(1);
Comb.mzI[][] scansRaw = (Comb.mzI[][])_scansRaw.Clone();
//if (minMassPos == 0)
//{
// return scansRaw;
//}
if (_options.useParentalMass)
{
//Mass conversions (mz data in the raw file is expressed in Th)
switch (_options.parentalMassUnits)
{
case massUnits.Th:
minMass = _parentMass - _options.parentalMass / 2;
maxMass = _parentMass + _options.parentalMass / 2;
break;
case massUnits.mTh:
// Th = mTh * 1e3
minMass = _parentMass - _options.parentalMass * 1000 / 2;
maxMass = _parentMass + _options.parentalMass * 1000 / 2;
break;
case massUnits.ppm:
// Th = ppm * parentalMass * 1e-6
minMass = _parentMass - _options.parentalMass * _parentMass * 1e-6;
maxMass = _parentMass - _options.parentalMass * _parentMass * 1e-6;
break;
}
if (minMass < data[0, 0])
{
minMass = data[0, 0];
}
if (maxMass > data[0, data.GetUpperBound(1)])
{
maxMass = data[0, data.GetUpperBound(1)];
}
}
//determine index of minimum mass
for (int pos = 0; pos <= data.GetUpperBound(1); pos++)
{
if (data[0, pos] < minMass)
{
minMassPos = pos + 1;
}
else
{
break;
}
}
//determine index of maximum mass
for (int pos = data.GetUpperBound(1); pos >= 0; pos--)
{
if (data[0, pos] > maxMass)
{
maxMassPos = pos - 1;
}
else
{
break;
}
}
int diffPos = maxMassPos - minMassPos;
extData = new Comb.mzI[diffPos + 1];
int counter = 0;
for (int k = minMassPos; k <= maxMassPos; k++)
{
extData[counter].mz = data[0, k];
extData[counter].I = data[1, k];
counter++;
}
int i = 0;
try
{
if (scansRaw[_spectrumToQuantitate] == null)
{
scansRaw[_spectrumToQuantitate] = new Comb.mzI[1000];
}
switch (_options.mode)
{
case adquisitionMode.position:
scansRaw[_spectrumToQuantitate] = (Comb.mzI[])extData.Clone();
break;
case adquisitionMode.RetentionTime:
for (i = extData.GetLowerBound(0); i < extData.GetUpperBound(0); i++)
{
scansRaw[_spectrumToQuantitate][i].I = extData[i].I;
scansRaw[_spectrumToQuantitate][i].mz = extData[i].mz;
}
break;
}
}
catch
{
//blank spectrum
extData = new Comb.mzI[1];
//scansRaw[_spectrumToQuantitate] = (Comb.mzI[])extData.Clone();
scansRaw[_spectrumToQuantitate] = null;
//return null;
}
return(scansRaw);
}
/// <summary>
/// Reads a given set of selected scans of a given raw
/// </summary>
/// <param name="filePath">(string) directory path of the raws</param>
/// <param name="rawfile">(string) name of the raw to open</param>
/// <param name="scannumber">(int[]) set of MSMS id scans to read</param>
/// <param name="options">options selected to create the binStack</param>
/// <returns>(Comb.mzI[][]) spectrum of each selected scan</returns>
public Comb.mzI[][] ReadScanRaw(string filePath,
string rawfile,
int[] scannumber,
double[] parentMassList,
BinStackOptions options)
// string specType, string spectrumPosition)
{
int stepSearch;
switch (options.spectrumPos)
{
case spectrumPositions.previous:
stepSearch = -1;
break;
case spectrumPositions.next:
stepSearch = 1;
break;
default:
stepSearch = 0;
break;
}
if (filePath == null || filePath.Length == 0)
{
return(null);
}
if (rawfile == null || rawfile.Length == 0)
{
return(null);
}
Comb.mzI[][] scansRaw = new Comb.mzI[scannumber.GetUpperBound(0) + 1][];
//open the raw
try
{
int iMaxGeneration = GC.MaxGeneration;
long iTotalMem = GC.GetTotalMemory(true);
rawFilePath = filePath.ToString().Trim() + "\\" + rawfile.ToString().Trim();
}
catch
{
return(null);
}
QuiXoT.Forms.frmInvisible frmReader = new QuiXoT.Forms.frmInvisible();
//frmReader.Show();
frmReader.openRaw(rawFilePath);
int nSpec = frmReader.numSpectra();
//object a2 = frmReader.getSpectrum(1900);
#region mode: retention time
if (options.mode == adquisitionMode.RetentionTime)
{
double startTime = new double();
double endTime = new double();
double centralTime = new double();
//short actualIndex = new short();
//double actualRetentionTime = new double();
int firstScan = new int();
int lastScan = new int();
centralTime = frmReader.indexToRetentionTime(1900);
startTime = frmReader.indexToRetentionTime(1);
endTime = frmReader.indexToRetentionTime(frmReader.spectrumCount());
//_Spectra.IndexToRetentionTime(1, ref actualIndex, ref startTime);
//_Spectra.IndexToRetentionTime(_Spectra.Count, ref actualIndex, ref endTime);
for (int i = 0; i <= scannumber.GetUpperBound(0); i++)
{
double parentMass = 0;
if (options.useParentalMass)
{
parentMass = parentMassList[i];
}
centralTime = frmReader.indexToRetentionTime(scannumber[i]);
//_Spectra.IndexToRetentionTime((short)scannumber[i], ref actualIndex, ref centralTime);
float timeMargin = options.retentionTime / (2 * 60);
double startCheckingTime = centralTime - timeMargin;
double stopCheckingTime = centralTime + timeMargin;
if (startCheckingTime < startTime)
{
startCheckingTime = startTime;
}
if (stopCheckingTime > endTime)
{
stopCheckingTime = endTime;
}
firstScan = frmReader.retentionTimeToIndex(startCheckingTime);
lastScan = frmReader.retentionTimeToIndex(stopCheckingTime);
//_Spectra.RetentionTimeToIndex(startCheckingTime, ref actualRetentionTime, ref firstScan);
//_Spectra.RetentionTimeToIndex(stopCheckingTime, ref actualRetentionTime, ref lastScan);
try
{
for (int j = firstScan; j <= lastScan; j++)
{
int tentativeSpectrum = (int)j;
spectrumTypes ff = frmReader.spectrumTypeFromScanNumber(j);
//XCALIBURFILESLib.XFilter filt = (XCALIBURFILESLib.XFilter)_filter.ScanNumber(tentativeSpectrum);
//string ff = filt.Text;
//XCALIBURFILESLib.XSpectrumRead Xspec = new XCALIBURFILESLib.XSpectrumRead();
double[,] specData = new double[10, 0];
if (options.spectrumType == ff)
{
specData = (double[, ])frmReader.getSpectrum(tentativeSpectrum);
scansRaw = (Comb.mzI[][])newScansRaw(options, scansRaw, i, parentMass, specData).Clone();
}
//switch (options.spectrumType)
//{
// case spectrumTypes.Full:
// if (ff == spectrumTypes.Full)
// Xspec = (XCALIBURFILESLib.XSpectrumRead)frmReader.getSpectrum(tentativeSpectrum);
// //Xspec = _Spectra.Item(tentativeSpectrum) as XCALIBURFILESLib.XSpectrumRead;
// scansRaw = (Comb.mzI[][])newScansRaw(options, scansRaw, i, parentMass, Xspec).Clone();
// break;
// case spectrumTypes.MSMS:
// if (ff == spectrumTypes.MSMS)
// Xspec = (XCALIBURFILESLib.XSpectrumRead)frmReader.getSpectrum(tentativeSpectrum);
// //Xspec = _Spectra.Item(tentativeSpectrum) as XCALIBURFILESLib.XSpectrumRead;
// scansRaw = (Comb.mzI[][])newScansRaw(options, scansRaw, i, parentMass, Xspec).Clone();
// break;
// case spectrumTypes.ZoomScan:
// if (ff == spectrumTypes.ZoomScan)
// Xspec = (XCALIBURFILESLib.XSpectrumRead)frmReader.getSpectrum(tentativeSpectrum);
// //Xspec = _Spectra.Item(tentativeSpectrum) as XCALIBURFILESLib.XSpectrumRead;
// scansRaw = (Comb.mzI[][])newScansRaw(options, scansRaw, i, parentMass, Xspec).Clone();
// break;
//}
}
}
catch
{
//_Raw.Close();
//_Detector = null;
//_Spectra = null;
//GC.Collect();
//GC.WaitForPendingFinalizers();
////MessageBox.Show("Could not open selected raw file: " + e.Message);
////Application.DoEvents();
//return null;
}
}
}
#endregion
#region mode: position
if (options.mode == adquisitionMode.position)
{
//for each identified spectrum (~each row of the QuiXML)
for (int i = 0; i <= scannumber.GetUpperBound(0); i++)
{
bool spectrumFound = false;
double parentMass = 0;
if (options.useParentalMass)
{
parentMass = parentMassList[i];
}
try
{
int tentativeSpectrum = (int)(scannumber[i] + stepSearch);
int spectrumToQuantitate = 0;
if (options.spectrumPos == spectrumPositions.same)
{
spectrumFound = true;
spectrumToQuantitate = tentativeSpectrum;
}
while (!spectrumFound)
{
if (tentativeSpectrum < 0)
{
MessageBox.Show("Error: reached lower bound for scans.");
return(null);
}
if (tentativeSpectrum > frmReader.spectrumCount())
{
MessageBox.Show("Error: reached upper bound for scans.");
return(null);
}
try
{
//XCALIBURFILESLib.XFilter filt = (XCALIBURFILESLib.XFilter)_filter.ScanNumber(tentativeSpectrum); //(short)scannumber[i]
spectrumTypes st = frmReader.spectrumTypeFromScanNumber(tentativeSpectrum);
//string ff = "";// filt.Text;
if (options.spectrumType == st)
{
spectrumFound = true;
spectrumToQuantitate = tentativeSpectrum;
}
}
catch
{
GC.Collect();
GC.WaitForPendingFinalizers();
//MessageBox.Show("Could not open selected raw file: " + e.Message);
//Application.DoEvents();
return(null);
}
tentativeSpectrum = (int)(tentativeSpectrum + stepSearch);
}
if (spectrumFound)
{
double[,] specData = new double[10, 0];
try
{
specData = (double[, ])frmReader.getSpectrum(spectrumToQuantitate);
}
catch
{
//this catch prevents from non existing scans
}
try
{
scansRaw = (Comb.mzI[][])newScansRaw(options, scansRaw, i, parentMass, specData).Clone();
}
catch
{
//this catch prevents from empty scans
}
}
//XCALIBURFILESLib.XSpectrumRead Xspec = frmReader.getSpectrum(spectrumToQuantitate) as XCALIBURFILESLib.XSpectrumRead;
//XCALIBURFILESLib.XSpectrumRead Xspec = _Spectra.Item(spectrumToQuantitate) as XCALIBURFILESLib.XSpectrumRead;
#region not-useful
//try
//{
// XCALIBURFILESLib.XParentScans XparentScans = Xspec.ParentScans as XCALIBURFILESLib.XParentScans;
// short prScansCount = XparentScans.Count;
// short numOfSpectra = _Spectra.Count;
// string[] fll = new string[_filter.Count];
// for (int k=0; k<_filter.Count;k++)
// {
// XCALIBURFILESLib.XFilter fil= (XCALIBURFILESLib.XFilter)_filter.Item(1);
// fll[k] = fil.Text;
// //fil.Validate
// }
//}
//catch { }
//Get the instrument name
//XCALIBURFILESLib.XInstrument instrument = _Detector.Instrument as XCALIBURFILESLib.XInstrument;
//instrumentName = instrument.Name;
//instrument = null;
// spectrum data
#endregion
//***scansRaw = (Comb.mzI[][])newScansRaw(options, scansRaw, i, parentMass, Xspec);
}
catch
{
GC.Collect();
GC.WaitForPendingFinalizers();
//MessageBox.Show("Could not open selected raw file: " + e.Message);
//Application.DoEvents();
return(null);
}
}
}
#endregion
GC.Collect();
frmReader.Close();
return(scansRaw);
}
private Comb.mzI[][] newScansRaw(BinStackOptions _options,
Comb.mzI[][] _scansRaw,
int _spectrumToQuantitate,
double _parentMass,
double[,] _specData)
{
Comb.mzI[][] scansRaw = (Comb.mzI[][])_scansRaw.Clone();
double[,] data = _specData as double[, ];
double minMass = 0;
double maxMass = 0;
int minMassPos = 0;
int maxMassPos = data.GetUpperBound(1);
getMinAndMaxMass(_options, _parentMass, data, ref minMass, ref maxMass);
//determine index of minimum mass
for (int pos = 0; pos <= data.GetUpperBound(1); pos++)
{
if (data[0, pos] < minMass)
{
minMassPos = pos + 1;
}
else
{
break;
}
}
//determine index of maximum mass
for (int pos = data.GetUpperBound(1); pos >= 0; pos--)
{
if (data[0, pos] > maxMass)
{
maxMassPos = pos - 1;
}
else
{
break;
}
}
int diffPos = maxMassPos - minMassPos;
extData = new Comb.mzI[diffPos + 1];
int counter = 0;
for (int k = minMassPos; k <= maxMassPos; k++)
{
extData[counter].mz = data[0, k];
extData[counter].I = data[1, k];
counter++;
}
int i = 0;
try
{
if (scansRaw[_spectrumToQuantitate] == null)
{
scansRaw[_spectrumToQuantitate] = new Comb.mzI[1000];
}
switch (_options.mode)
{
case adquisitionMode.position:
scansRaw[_spectrumToQuantitate] = (Comb.mzI[])extData.Clone();
break;
case adquisitionMode.RetentionTime:
for (i = extData.GetLowerBound(0); i < extData.GetUpperBound(0); i++)
{
scansRaw[_spectrumToQuantitate][i].I = extData[i].I;
scansRaw[_spectrumToQuantitate][i].mz = extData[i].mz;
}
break;
}
}
catch
{
//blank spectrum
extData = new Comb.mzI[1];
//scansRaw[_spectrumToQuantitate] = (Comb.mzI[])extData.Clone();
scansRaw[_spectrumToQuantitate] = null;
//return null;
}
return(scansRaw);
}
/// <summary>
/// Reads a given set of selected scans of a given raw
/// </summary>
/// <param name="filePath">(string) directory path of the raws</param>
/// <param name="rawfile">(string) name of the raw to open</param>
/// <param name="scannumber">(int[]) set of MSMS id scans to read</param>
/// <param name="options">options selected to create the binStack</param>
/// <returns>(Comb.mzI[][]) spectrum of each selected scan</returns>
public Comb.mzI[][] ReadScanRaw(string filePath,
string rawfile,
int[] firstScan,
int[] peakStart,
int[] peakEnd,
double[] parentMassList,
BinStackOptions options,
Label _status,
ref object _parObject,
int _currNumFrame,
int _totNumFrames)
// string specType, string spectrumPosition)
{
int stepSearch;
quadraticEquation _par = new quadraticEquation();
switch (options.spectrumPos)
{
case spectrumPositions.previous:
stepSearch = -1;
break;
case spectrumPositions.next:
stepSearch = 1;
break;
default:
stepSearch = 0;
break;
}
if (filePath == null || filePath.Length == 0)
{
return(null);
}
if (rawfile == null || rawfile.Length == 0)
{
return(null);
}
Comb.mzI[][] scansRaw = new Comb.mzI[firstScan.GetUpperBound(0) + 1][];
//open the raw
try
{
int iMaxGeneration = GC.MaxGeneration;
long iTotalMem = GC.GetTotalMemory(true);
rawFilePath = filePath.ToString().Trim() + "\\" + rawfile.ToString().Trim();
}
catch
{
return(null);
}
rawStats frmReader = new rawStats();
//frmReader.Show();
frmReader.openRawFast(rawFilePath);
int nSpec = frmReader.lastSpectrumNumber();
frmReader.initialiseSpectrumTypes(nSpec);
//object a2 = frmReader.getSpectrum(1900);
#region mode: retention time (not used)
// if (options.mode == adquisitionMode.RetentionTime)
// {
// double startTime = new double();
// double endTime = new double();
// double centralTime = new double();
// //short actualIndex = new short();
// //double actualRetentionTime = new double();
// int firstScan = new int();
// int lastScan = new int();
// centralTime = frmReader.getRTfromScanNumber(1900);
// startTime = frmReader.getRTfromScanNumber(1);
// endTime = frmReader.getRTfromScanNumber(frmReader.numSpectra());
// //_Spectra.IndexToRetentionTime(1, ref actualIndex, ref startTime);
// //_Spectra.IndexToRetentionTime(_Spectra.Count, ref actualIndex, ref endTime);
// for (int i = 0; i <= scannumber.GetUpperBound(0); i++)
// {
// double parentMass = 0;
// if (options.useParentalMass)
// {
// parentMass = parentMassList[i];
// }
// centralTime = frmReader.getRTfromScanNumber(scannumber[i, 0]);
// //_Spectra.IndexToRetentionTime((short)scannumber[i], ref actualIndex, ref centralTime);
// float timeMargin = options.retentionTime / (2 * 60);
// double startCheckingTime = centralTime - timeMargin;
// double stopCheckingTime = centralTime + timeMargin;
// if (startCheckingTime < startTime) { startCheckingTime = startTime; }
// if (stopCheckingTime > endTime) { stopCheckingTime = endTime; }
// firstScan = frmReader.retentionTimeToIndex(startCheckingTime);
// lastScan = frmReader.retentionTimeToIndex(stopCheckingTime);
// //_Spectra.RetentionTimeToIndex(startCheckingTime, ref actualRetentionTime, ref firstScan);
// //_Spectra.RetentionTimeToIndex(stopCheckingTime, ref actualRetentionTime, ref lastScan);
// try
// {
// for (int j = firstScan; j <= lastScan; j++)
// {
// int tentativeSpectrum = (int)j;
// spectrumTypes ff = frmReader.spectrumTypeFromScanNumber(j);
// //XCALIBURFILESLib.XFilter filt = (XCALIBURFILESLib.XFilter)_filter.ScanNumber(tentativeSpectrum);
// //string ff = filt.Text;
// //XCALIBURFILESLib.XSpectrumRead Xspec = new XCALIBURFILESLib.XSpectrumRead();
// double[,] specData = new double[10, 0];
// if (options.spectrumType == ff)
// {
// specData = (double[,])frmReader.getSpectrum(tentativeSpectrum);
// scansRaw = (Comb.mzI[][])newScansRaw(options, scansRaw, i, parentMass, specData).Clone();
// }
// //switch (options.spectrumType)
// //{
// // case spectrumTypes.Full:
// // if (ff == spectrumTypes.Full)
// // Xspec = (XCALIBURFILESLib.XSpectrumRead)frmReader.getSpectrum(tentativeSpectrum);
// // //Xspec = _Spectra.Item(tentativeSpectrum) as XCALIBURFILESLib.XSpectrumRead;
// // scansRaw = (Comb.mzI[][])newScansRaw(options, scansRaw, i, parentMass, Xspec).Clone();
// // break;
// // case spectrumTypes.MSMS:
// // if (ff == spectrumTypes.MSMS)
// // Xspec = (XCALIBURFILESLib.XSpectrumRead)frmReader.getSpectrum(tentativeSpectrum);
// // //Xspec = _Spectra.Item(tentativeSpectrum) as XCALIBURFILESLib.XSpectrumRead;
// // scansRaw = (Comb.mzI[][])newScansRaw(options, scansRaw, i, parentMass, Xspec).Clone();
// // break;
// // case spectrumTypes.ZoomScan:
// // if (ff == spectrumTypes.ZoomScan)
// // Xspec = (XCALIBURFILESLib.XSpectrumRead)frmReader.getSpectrum(tentativeSpectrum);
// // //Xspec = _Spectra.Item(tentativeSpectrum) as XCALIBURFILESLib.XSpectrumRead;
// // scansRaw = (Comb.mzI[][])newScansRaw(options, scansRaw, i, parentMass, Xspec).Clone();
// // break;
// //}
// }
// }
// catch
// {
// //_Raw.Close();
// //_Detector = null;
// //_Spectra = null;
// //GC.Collect();
// //GC.WaitForPendingFinalizers();
// ////MessageBox.Show("Could not open selected raw file: " + e.Message);
// ////Application.DoEvents();
// //return null;
// }
// }
// }
#endregion
#region mode: position
if (!(options.averagingMethod == averagingMethod.mostIntense ||
options.averagingMethod == averagingMethod.none))
{
if (_parObject == "")
{
_par.rawFilePath = rawFilePath;
_par.hasBeenCalculated = false;
_parObject = (object)_par;
}
else
{
_par = (quadraticEquation)_parObject;
if (_par.rawFilePath != rawFilePath)
{
_par.rawFilePath = rawFilePath;
_par.hasBeenCalculated = false;
}
}
string filter = "FTMS + p NSI Full ms"; // filter for fulls
int totScans = firstScan.Length;
for (int i = 0; i < totScans; i++)
{
_status.Text = "Averaging scan " + (i + 1).ToString() + "/" + totScans.ToString() +
" (frame " + _currNumFrame.ToString() + "/" + _totNumFrames.ToString() + ")";
Application.DoEvents();
double[,] specData = new double[10, 0];
try
{
int maxNumberOfLateralZeros = 4;
double firstMz = 0;
double lastMz = 0;
if (!options.useParentalMass && !options.useWindow)
{
double[,] firstSpec = (double[, ])frmReader.getSpectrum(peakStart[i]);
getMinAndMaxMass(options, parentMassList[i], firstSpec, ref firstMz, ref lastMz);
}
if (options.useParentalMass)
{
getMinAndMaxMass(options, parentMassList[i], null, ref firstMz, ref lastMz);
}
if (options.useWindow)
{
firstMz = options.windowStart;
lastMz = options.windowEnd;
}
// fast but bad
switch (options.averagingMethod)
{
case averagingMethod.everything_ThermoMethod_noWidth:
{
// mostly fast but very bad
specData = (double[, ])frmReader.getAveragedSpectrumThermoFunction(peakStart[i],
peakEnd[i],
firstMz,
lastMz,
filter,
0);
break;
}
case averagingMethod.everything_ThermoMethod_Width0001:
{
// mostly fast but somewhat acceptable
double optimisedWidth = 0.0001;
specData = (double[, ])frmReader.getAveragedSpectrumThermoFunction(peakStart[i],
peakEnd[i],
firstMz,
lastMz,
filter,
optimisedWidth);
break;
}
case averagingMethod.everything_InlabMethod:
{
// slow but good
specData = (double[, ])frmReader.getAveragedSpectrum(peakStart[i],
peakEnd[i],
firstScan[i],
true, 0,
firstMz,
lastMz,
maxNumberOfLateralZeros,
ref _par,
_status);
_parObject = (object)_par;
break;
//msnPerFull.rawStats.saveIndividualSpectrum(specData, "jv");
}
case averagingMethod.mostIntenseAndInflections_InlabMethod:
{
specData = (double[, ])frmReader.getAveragedSpectrum(peakStart[i],
peakEnd[i],
firstScan[i],
true, 3,
firstMz,
lastMz,
maxNumberOfLateralZeros,
ref _par,
_status);
_parObject = (object)_par;
break;
}
case averagingMethod.fiveSpectra_InlabMethod:
{
specData = (double[, ])frmReader.getAveragedSpectrum(peakStart[i],
peakEnd[i],
firstScan[i],
false, 5,
firstMz,
lastMz,
maxNumberOfLateralZeros,
ref _par,
_status);
_parObject = (object)_par;
break;
}
}
//double[,] otherData = (double[,])frmReader.getSpectrum(firstScan[i]);
//msnPerFull.rawStats.saveIndividualSpectrum(specData, "thermo_width1-001");
}
catch
{
//this catch prevents from non existing scans
}
if (specData == null)
{
_status.Text = "Raw file error found.";
return(null);
}
try
{
double parentMass = 0;
if (options.useParentalMass)
{
parentMass = parentMassList[i];
}
scansRaw = (Comb.mzI[][])newScansRaw(options, scansRaw, i, parentMass, specData).Clone();
}
catch
{
//this catch prevents from empty scans
}
}
}
else
{
if (options.mode == adquisitionMode.position)
{
//for each identified spectrum (~each row of the QuiXML)
for (int i = 0; i <= firstScan.GetUpperBound(0); i++)
{
bool spectrumFound = false;
double parentMass = 0;
if (options.useParentalMass)
{
parentMass = parentMassList[i];
}
try
{
int tentativeSpectrum = (int)(firstScan[i] + stepSearch);
int spectrumToQuantitate = 0;
if (options.spectrumPos == spectrumPositions.same)
{
spectrumFound = true;
spectrumToQuantitate = tentativeSpectrum;
}
while (!spectrumFound)
{
if (tentativeSpectrum < 0)
{
MessageBox.Show("Error: reached lower bound for scans.");
return(null);
}
if (tentativeSpectrum > nSpec)
{
MessageBox.Show("Error: reached upper bound for scans.");
return(null);
}
try
{
//XCALIBURFILESLib.XFilter filt = (XCALIBURFILESLib.XFilter)_filter.ScanNumber(tentativeSpectrum); //(short)scannumber[i]
spectrumTypes st = frmReader.spectrumTypeFromScanNumber(tentativeSpectrum);
//string ff = "";// filt.Text;
if (options.spectrumType == st)
{
spectrumFound = true;
spectrumToQuantitate = tentativeSpectrum;
}
}
catch
{
GC.Collect();
GC.WaitForPendingFinalizers();
//MessageBox.Show("Could not open selected raw file: " + e.Message);
//Application.DoEvents();
return(null);
}
tentativeSpectrum = (int)(tentativeSpectrum + stepSearch);
}
if (spectrumFound)
{
double[,] specData = new double[10, 0];
try
{
specData = (double[, ])frmReader.getSpectrum(spectrumToQuantitate);
}
catch
{
//this catch prevents from non existing scans
}
try
{
scansRaw = (Comb.mzI[][])newScansRaw(options, scansRaw, i, parentMass, specData).Clone();
}
catch
{
//this catch prevents from empty scans
}
}
//XCALIBURFILESLib.XSpectrumRead Xspec = frmReader.getSpectrum(spectrumToQuantitate) as XCALIBURFILESLib.XSpectrumRead;
//XCALIBURFILESLib.XSpectrumRead Xspec = _Spectra.Item(spectrumToQuantitate) as XCALIBURFILESLib.XSpectrumRead;
#region not-useful
//try
//{
// XCALIBURFILESLib.XParentScans XparentScans = Xspec.ParentScans as XCALIBURFILESLib.XParentScans;
// short prScansCount = XparentScans.Count;
// short numOfSpectra = _Spectra.Count;
// string[] fll = new string[_filter.Count];
// for (int k=0; k<_filter.Count;k++)
// {
// XCALIBURFILESLib.XFilter fil= (XCALIBURFILESLib.XFilter)_filter.Item(1);
// fll[k] = fil.Text;
// //fil.Validate
// }
//}
//catch { }
//Get the instrument name
//XCALIBURFILESLib.XInstrument instrument = _Detector.Instrument as XCALIBURFILESLib.XInstrument;
//instrumentName = instrument.Name;
//instrument = null;
// spectrum data
#endregion
//***scansRaw = (Comb.mzI[][])newScansRaw(options, scansRaw, i, parentMass, Xspec);
}
catch
{
GC.Collect();
GC.WaitForPendingFinalizers();
//MessageBox.Show("Could not open selected raw file: " + e.Message);
//Application.DoEvents();
return(null);
}
}
}
}
#endregion
GC.Collect();
frmReader.closeRaw();
return(scansRaw);
}
//private XCALIBURFILESLib.XRaw _Raw = new XCALIBURFILESLib.XRaw();
//private XCALIBURFILESLib.XDetectorRead _Detector;
//private XCALIBURFILESLib.XSpectra _Spectra;
/// <summary>
/// Reads a given set of selected scans of a given raw
/// </summary>
/// <param name="filePath">(string) directory path of the mgfs</param>
/// <param name="mgffile">(string) name of the mgf to open</param>
/// <param name="scannumber">(int[]) set of MSMS id scans to read</param>
/// <param name="parentMassList">(ooptional)list of parental masses</param>
/// <param name="options">options selected to create the binStack</param>
/// <returns>(Comb.mzI[][]) spectrum of each selected scan</returns>
public Comb.mzI[][] ReadScanRaw(string filePath,
string mgffile,
int[] scannumber,
double[] parentMassList,
BinStackOptions options) // string specType, string spectrumPosition)
{
//int stepSearch;
string titleID = "TITLE";
string spectrumEndID = "END IONS";
int scanPos = 0;
char[] splitchar = new char[2];
splitchar[0] = '\t';
splitchar[1] = ' ';
//Variables for parental mass limits
double minMass = 0;
double maxMass = 10000;
ArrayList scannumber_al = new ArrayList(scannumber.GetLength(0));
for (int i = 0; i < scannumber.GetLength(0); i++)
{
scannumber_al.Add((int)scannumber[i]);
}
scannumber_al.Sort();
if (filePath == null || filePath.Length == 0)
{
return(null);
}
if (mgffile == null || mgffile.Length == 0)
{
return(null);
}
Comb.mzI[][] scansRaw = new Comb.mzI[scannumber.GetUpperBound(0) + 1][];
//open the file
FileInfo file = new FileInfo(filePath.ToString().Trim() + "\\" + mgffile.ToString().Trim());
StreamReader sr = new StreamReader(File.OpenRead(file.FullName));
string line = "";
//read the file
try
{
while (sr.Peek() != -1)
{
line = sr.ReadLine();
if (line.ToUpper().Contains(titleID))
{
//obtain the scannumber of the current spectrum
int tentativeScanNumber = Mgfutils.getScanNumber(line, options.split_chars, options.scanField);
//Check wether the current spectrum is on the list
int locScan = scannumber_al.BinarySearch(tentativeScanNumber);
//spectrum found! -->write the spectrum into the scansRaw array
if (locScan > -1)
{
//locate the position where the spectrum must be inserted at the scannumber array
for (int j = 0; j <= scannumber.GetLength(0); j++)
{
if (scannumber[j] == tentativeScanNumber)
{
scanPos = j;
break;
}
}
if (options.useParentalMass)
{
//Mass conversions (mz data in the raw file is expressed in amu)
switch (options.parentalMassUnits)
{
case massUnits.amu:
minMass = parentMassList[scanPos] - options.parentalMass / 2;
maxMass = parentMassList[scanPos] + options.parentalMass / 2;
break;
case massUnits.mmu:
// amu = mmu * 1e3
minMass = parentMassList[scanPos] - options.parentalMass * 1000 / 2;
maxMass = parentMassList[scanPos] + options.parentalMass * 1000 / 2;
break;
case massUnits.ppm:
// amu = ppm * parentalMass * 1e-6
minMass = parentMassList[scanPos] - options.parentalMass * parentMassList[scanPos] * 1e-6;
maxMass = parentMassList[scanPos] - options.parentalMass * parentMassList[scanPos] * 1e-6;
break;
}
}
//read the spectrum, and record it in a temporary ArrayList
ArrayList tempSpectrum = new ArrayList();
line = sr.ReadLine();
while (!line.Contains(spectrumEndID))
{
try
{
Comb.mzI ion = new Comb.mzI();
string[] iontmp = line.Split(splitchar);
if (options.useParentalMass)
{
if (ion.mz >= minMass && ion.mz <= maxMass)
{
ion.mz = double.Parse(iontmp[0], CultureInfo.InvariantCulture.NumberFormat);
ion.I = double.Parse(iontmp[1], CultureInfo.InvariantCulture.NumberFormat);
}
}
else
{
ion.mz = double.Parse(iontmp[0], CultureInfo.InvariantCulture.NumberFormat);
ion.I = double.Parse(iontmp[1], CultureInfo.InvariantCulture.NumberFormat);
}
tempSpectrum.Add(ion);
}
catch
{ }
line = sr.ReadLine();
}
//record the spectrum into the correct array (scansRaw)
tempSpectrum.Sort();
Comb.mzI[] spectrum = new Comb.mzI[tempSpectrum.Count + 1];
int counter = 1;
foreach (Comb.mzI ion in tempSpectrum)
{
spectrum[counter] = ion;
counter++;
}
scansRaw[scanPos] = (Comb.mzI[])spectrum.Clone();
}
}
}
}
catch { }
GC.Collect();
return(scansRaw);
}
protected void scale(int primChannel)
{
pixUsedwidth = this.Width * widthPercent;
pixUsedheight = this.Height * heightPercent;
//Positioning the channels.
for (int channel = 0; channel <= dataReal.GetUpperBound(0); channel++)
{
if (dataReal[channel] != null)
{
//initialize datapaint
dataPaint[channel] =
new Comb.mzI[dataReal[channel].GetUpperBound(0) + 1];
//Get bounds for the channel
if (originalMargins && (!horizontalZoom))
{
maxX = getMaxX(dataReal[channel]);
minX = getMinX(dataReal[channel]);
maxY = getMaxY(dataReal);
minY = getMinY(dataReal);
}
if (horizontalZoom)
{
maxY = getMaxY(dataReal[channel]);
minY = getMinY(dataReal);
}
for (int i = 0; i <= dataReal[channel].GetUpperBound(0); i++)
{
dataPaint[channel][i].I = -(dataReal[channel][i].I - maxY);
dataPaint[channel][i].mz = (dataReal[channel][i].mz - minX);
}
}
}
//Scaling the channels
if (originalMargins && (!horizontalZoom))
{
maxX = getMaxX(dataReal[primChannel]);
minX = getMinX(dataReal[primChannel]);
maxY = getMaxY(dataReal);
minY = getMinY(dataReal);
}
if (horizontalZoom)
{
maxY = getMaxY(dataReal);
minY = getMinY(dataReal);
}
scaleX = maxX - minX;
scaleY = maxY - minY;
if (scaleY == 0)
{
scaleY += 100;
}
if (scaleX == 0)
{
scaleX += 100;
}
for (int channel = 0; channel <= dataReal.GetUpperBound(0); channel++)
{
if (dataReal[channel] != null)
{
for (int i = 0; i <= dataReal[channel].GetUpperBound(0); i++)
{
dataPaint[channel][i].I =
(-(dataReal[channel][i].I - minY) * pixUsedheight / scaleY)
- Math.Abs(this.Height * MarginGraph);
dataPaint[channel][i].mz =
((dataReal[channel][i].mz - minX) * pixUsedwidth / scaleX)
+ Math.Abs(this.Width * MarginGraph);
}
}
}
}
