// private const string DebugFileName = @"C:\Users\wilk011\Documents\DataFiles\TestFolder\debug_HCD_QCShew_Precursor.txt";
private IEnumerable <SpectrumMatch> InitTest()
{
var ionTypeFactory = new IonTypeFactory(_baseIons, _neutralLosses, MaxCharge);
_ionTypes = ionTypeFactory.GetAllKnownIonTypes().ToList();
var lcms = new LazyLcMsRun(RawFile, NoiseFiltration, NoiseFiltration);
var spectrumMatches = (new SpectrumMatchList(lcms, TsvFile, DataFileFormat.IcBottomUp));
return(spectrumMatches);
}
public void RankProbability()
{
var methodName = MethodBase.GetCurrentMethod().Name;
Utils.ShowStarting(methodName);
const string configurationFile = @"\\protoapps\UserData\Wilkins\BottomUp\RankProbabilityConfig.ini";
if (!File.Exists(configurationFile))
{
Assert.Ignore(@"Skipping test {0} since file not found: {1}", methodName, configurationFile);
}
var config = new TrainerConfiguration(configurationFile);
var trainingParameters = new TrainingParameters(config);
foreach (var dataSet in config.DataSets)
{
var tsvName = config.TsvPath.Replace("@", dataSet);
var rawName = config.DataPath.Replace("@", dataSet);
var txtFiles = new List <string>();
var dataFiles = new List <string>();
if (config.DataFormat == DataFileFormat.Mgf)
{
dataFiles.Add(config.DataPath + dataSet + "." + config.DataFormat);
}
else
{
// Read directory
var txtFilesTemp = Directory.GetFiles(tsvName).ToList();
txtFiles = txtFilesTemp.Where(txtFile => Path.GetExtension(txtFile) == ".tsv").ToList();
var dataFilesTemp = Directory.GetFiles(rawName).ToList();
dataFiles =
dataFilesTemp.Where(dataFile => Path.GetExtension(dataFile) == ".raw").ToList();
Assert.True(dataFiles.Count == txtFiles.Count);
}
// Read Data files
for (int i = 0; i < dataFiles.Count; i++)
{
SpectrumMatchList targets;
if (config.DataFormat == DataFileFormat.Mgf)
{
Console.WriteLine(dataSet + ".mgf");
targets = new SpectrumMatchList(dataFiles[i], config.PrecursorCharge);
}
else
{
string textFile = txtFiles[i];
string rawFile = dataFiles[i];
Console.WriteLine("{0}\t{1}", textFile, rawFile);
var lcms = new LazyLcMsRun(rawFile, 0, 0);
targets = new SpectrumMatchList(lcms, txtFiles[i], config.DataFormat, config.PrecursorCharge);
}
// Add PSMs
trainingParameters.AddMatches(targets);
}
// Write output file
var outputFileName = config.OutputFileName.Replace("@", dataSet);
trainingParameters.WriteToFile(outputFileName);
}
}
public IcBottomUpTsvReader(string fileName, LazyLcMsRun lcms, bool decoy)
{
_fileName = fileName;
_lcms = lcms;
_decoy = decoy;
}
public static IDataFileReader Create(DataFileFormat format, string annotations, bool decoy, LazyLcMsRun lcms = null)
{
IDataFileReader reader;
switch (format)
{
case DataFileFormat.Mgf:
reader = new MgfReader(annotations, decoy);
break;
case DataFileFormat.IcBottomUp:
reader = new IcBottomUpTsvReader(annotations, lcms, decoy);
break;
case DataFileFormat.Dia:
reader = new DiaTsvReader(annotations, lcms, decoy);
break;
default:
reader = null;
break;
}
return(reader);
}
public void IonFrequencyFunction()
{
var methodName = MethodBase.GetCurrentMethod().Name;
TestUtils.ShowStarting(methodName);
const string configFilePath = @"C:\Users\wilk011\Documents\DataFiles\IonFreqConfig.ini";
if (!File.Exists(configFilePath))
{
Assert.Ignore(@"Skipping test {0} since file not found: {1}", methodName, configFilePath);
}
InitTest(new ConfigFileReader(configFilePath));
foreach (var name in _names)
{
var tsvName = _preTsv.Replace("@", name);
var rawName = _preRaw.Replace("@", name);
var txtFiles = Directory.GetFiles(tsvName).ToList();
var rawFilesTemp = Directory.GetFiles(rawName).ToList();
var rawFiles = rawFilesTemp.Where(rawFile => Path.GetExtension(rawFile) == ".raw").ToList();
Assert.True(rawFiles.Count == txtFiles.Count);
int tableCount = 1;
if (_precursorCharge > 0)
{
tableCount = _precursorCharge;
}
var ionFrequencyFunctions = new IonFrequencyTable[tableCount];
var decoyionFrequencyFunctions = new IonFrequencyTable[tableCount];
for (int i = 0; i < tableCount; i++)
{
ionFrequencyFunctions[i] = new IonFrequencyTable(_ionTypes,
_defaultTolerance, _relativeIntensityThreshold, _combineCharges);
decoyionFrequencyFunctions[i] = new IonFrequencyTable(_ionTypes,
_defaultTolerance, _relativeIntensityThreshold, _combineCharges);
}
for (int i = 0; i < txtFiles.Count; i++)
{
string textFile = txtFiles[i];
string rawFile = rawFiles[i];
Console.WriteLine("{0}\t{1}", Path.GetFileName(textFile), Path.GetFileName(rawFile));
var lcms = new LazyLcMsRun(rawFile, NoiseFiltration, NoiseFiltration);
var matchList = new SpectrumMatchList(lcms, txtFiles[i], DataFileFormat.IcBottomUp);
SpectrumMatchList decoyMatchList = null;
if (_useDecoy)
{
decoyMatchList = new SpectrumMatchList(lcms, txtFiles[i], DataFileFormat.IcBottomUp, 0, true);
}
for (int j = 0; j < tableCount; j++)
{
var matches = _precursorCharge > 0 ? matchList.GetCharge(j + 1) : matchList;
matches.FilterSpectra();
ionFrequencyFunctions[j].AddMatches(matches);
if (decoyMatchList != null)
{
var decoyMatches = _precursorCharge > 0 ? decoyMatchList.GetCharge(j + 1) : decoyMatchList;
decoyMatches.FilterSpectra();
decoyionFrequencyFunctions[j].AddMatches(decoyMatches);
}
}
}
// Print Offset Frequency tables to output file
var outFile = _outFileName.Replace("@", name);
for (int i = 0; i < tableCount; i++)
{
string outFileName = outFile.Replace("*", (i + 1).ToString(CultureInfo.InvariantCulture));
var ionFrequencies = ionFrequencyFunctions[i].GetProbabilities();
var decoyionFrequencies = decoyionFrequencyFunctions[i].GetProbabilities();
using (var finalOutputFile = new StreamWriter(outFileName))
{
finalOutputFile.Write("Ion\tTarget");
if (_useDecoy)
{
finalOutputFile.Write("\tDecoy");
}
finalOutputFile.WriteLine();
for (int j = 0; j < ionFrequencies.Length; j++)
{
finalOutputFile.Write("{0}\t{1}", ionFrequencies[j].Label.Name, ionFrequencies[j].Prob);
if (_useDecoy)
{
finalOutputFile.Write("\t{0}", decoyionFrequencies[j]);
}
finalOutputFile.WriteLine();
}
}
}
}
}
public void OffsetFrequencyFunction()
{
var methodName = MethodBase.GetCurrentMethod().Name;
TestUtils.ShowStarting(methodName);
const string configFilePath = @"C:\Users\wilk011\Documents\DataFiles\OffsetFreqConfig.ini";
if (!File.Exists(configFilePath))
{
Assert.Ignore(@"Skipping test {0} since file not found: {1}", methodName, configFilePath);
}
InitTest(new ConfigFileReader(configFilePath));
foreach (var name in _names)
{
var tsvName = _preTsv.Replace("@", name);
var rawName = _preRaw.Replace("@", name);
var txtFiles = Directory.GetFiles(tsvName).ToList();
var rawFilesTemp = Directory.GetFiles(rawName).ToList();
var rawFiles = rawFilesTemp.Where(rawFile => Path.GetExtension(rawFile) == ".raw").ToList();
Assert.True(rawFiles.Count == txtFiles.Count);
int tableCount = 1;
if (_precursorCharge > 0)
{
tableCount = _precursorCharge;
}
var offsetFrequencyTables = new PrecursorOffsetFrequencyTable[tableCount];
for (int i = 0; i < tableCount; i++)
{
if (_precursorCharge > 0)
{
offsetFrequencyTables[i] = new PrecursorOffsetFrequencyTable(_searchWidth / (i + 1), i + 1, _binWidth / (i + 1));
}
else
{
offsetFrequencyTables[i] = new PrecursorOffsetFrequencyTable(_searchWidth, i + 1, _binWidth);
}
}
for (int i = 0; i < txtFiles.Count; i++)
{
string textFile = txtFiles[i];
string rawFile = rawFiles[i];
Console.WriteLine("{0}\t{1}", Path.GetFileName(textFile), Path.GetFileName(rawFile));
var lcms = new LazyLcMsRun(rawFile, _noiseFiltration, _noiseFiltration);
var matchList = new SpectrumMatchList(lcms, txtFiles[i], DataFileFormat.IcBottomUp);
for (int j = 0; j < tableCount; j++)
{
offsetFrequencyTables[j].AddMatches(
_precursorCharge > 0 ? matchList.GetCharge(j + 1) : matchList);
}
}
var offsetFrequencies = new List <Probability <double> > [tableCount];
for (int i = 0; i < tableCount; i++)
{
offsetFrequencies[i] = offsetFrequencyTables[i].GetProbabilities().ToList();
}
var outFileName = _outFileName.Replace("@", name);
for (int i = 0; i < tableCount; i++)
{
var chargeOutFileName = outFileName.Replace("*", (i + 1).ToString(CultureInfo.InvariantCulture));
using (var outFile = new StreamWriter(chargeOutFileName))
{
outFile.WriteLine("Offset\tFound");
foreach (var offsetFrequency in offsetFrequencies[i])
{
// int integerOffset = (int) Math.Round(offsetFrequency.Offset*_binWidth*(i + 1));
outFile.WriteLine("{0}\t{1}", offsetFrequency.Label, offsetFrequency.Prob);
}
}
}
}
}
public void PrecursorOffsetFrequencyFunction()
{
var methodName = MethodBase.GetCurrentMethod().Name;
TestUtils.ShowStarting(methodName);
const string configFilePath = @"C:\Users\wilk011\Documents\DataFiles\PrecursorOffsetFreqConfig.ini";
if (!File.Exists(configFilePath))
{
Assert.Ignore(@"Skipping test {0} since file not found: {1}", methodName, configFilePath);
}
InitTest(new ConfigFileReader(configFilePath));
foreach (var name in _names)
{
var tsvName = _preTsv.Replace("@", name);
var rawName = _preRaw.Replace("@", name);
var txtFiles = Directory.GetFiles(tsvName).ToList();
var rawFilesTemp = Directory.GetFiles(rawName).ToList();
var rawFiles = rawFilesTemp.Where(rawFile => Path.GetExtension(rawFile) == ".raw").ToList();
Assert.True(rawFiles.Count == txtFiles.Count);
var offsetFrequencyTables = new List <PrecursorOffsetFrequencyTable> [_precursorCharge];
for (int i = 0; i < _precursorCharge; i++)
{
offsetFrequencyTables[i] = new List <PrecursorOffsetFrequencyTable>();
for (int j = 1; j <= (i + 1); j++)
{
offsetFrequencyTables[i].Add(new PrecursorOffsetFrequencyTable(_searchWidth / j, j, _binWidth / j));
}
}
for (int i = 0; i < txtFiles.Count; i++)
{
string textFile = txtFiles[i];
string rawFile = rawFiles[i];
Console.WriteLine("{0}\t{1}", Path.GetFileName(textFile), Path.GetFileName(rawFile));
var lcms = new LazyLcMsRun(rawFile, _noiseFiltration, _noiseFiltration);
var matchList = new SpectrumMatchList(lcms, txtFiles[i], DataFileFormat.IcBottomUp);
for (int j = 0; j < _precursorCharge; j++)
{
var chargeMatches = matchList.GetCharge(j + 1);
foreach (var offsetFrequencyTable in offsetFrequencyTables[j])
{
offsetFrequencyTable.AddMatches(chargeMatches);
}
}
}
var outFileName = _outFileName.Replace("@", name);
for (int i = 0; i < _precursorCharge; i++)
{
var chargeOutFileName = outFileName.Replace("*", (i + 1).ToString(CultureInfo.InvariantCulture));
using (var outFile = new StreamWriter(chargeOutFileName))
{
outFile.Write("Offset\t");
var offsetFrequencyList = new List <List <Probability <double> > >();
for (int j = offsetFrequencyTables[i].Count - 1; j >= 0; j--)
{
offsetFrequencyList.Add(offsetFrequencyTables[i][j].GetProbabilities().ToList());
outFile.Write("{0}", (j + 1));
if (j != 0)
{
outFile.Write("\t");
}
}
outFile.WriteLine();
for (int j = 0; j < offsetFrequencyList.First().Count; j++)
{
var offset = offsetFrequencyList.First()[j].Label;
var integerOffset = Math.Round(offset * (1 / _binWidth), 2);
outFile.Write(integerOffset + "\t");
for (int k = 0; k < offsetFrequencyList.Count; k++)
{
outFile.Write(offsetFrequencyList[k][j].Prob);
if (k != offsetFrequencyList.Count - 1)
{
outFile.Write("\t");
}
}
outFile.WriteLine();
}
}
}
}
}
