public SpectrumMatch(string peptide, DataFileFormat sequenceFormat,
LazyLcMsRun lcms, int scanNum = 0, int precursorCharge = 1,
bool decoy = false, string formula = "")
{
Peptide = peptide;
_spectrum = null;
_lcms = lcms;
ScanNum = scanNum;
PrecursorCharge = precursorCharge;
Decoy = decoy;
var sequenceReader = new SequenceReader(sequenceFormat);
Sequence = sequenceReader.GetSequence(peptide);
if (decoy)
{
CreateDecoy();
}
else if (formula.Length > 0)
{
var composition = Composition.Parse(formula);
if (!composition.Equals(Sequence.Composition + Composition.H2O))
{
throw new MismatchException();
}
}
}
// 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 SpectrumMatch(Sequence sequence, LazyLcMsRun lcms, int scanNum = 0, int precursorCharge = 1, bool decoy = false)
{
Peptide = "";
foreach (var aa in sequence) Peptide += aa.Residue;
_spectrum = null;
_lcms = lcms;
ScanNum = scanNum;
PrecursorCharge = precursorCharge;
Decoy = decoy;
Sequence = sequence;
if (decoy) CreateDecoy();
}
public SpectrumMatchList(LazyLcMsRun lcms, string tsvFile, DataFileFormat sequenceFormat,
int maxCharge = 0, bool useDecoy = false)
{
Decoy = useDecoy;
MaxCharge = maxCharge;
SequenceFormat = sequenceFormat;
var fileReader = DataFileReaderFactory.Create(SequenceFormat, tsvFile, useDecoy, lcms);
var specMatches = fileReader.Read();
AddRange(from i in specMatches
where i.PrecursorCharge <= maxCharge
select i);
}
public SpectrumMatch(Sequence sequence, LazyLcMsRun lcms, int scanNum = 0, int precursorCharge = 1, bool decoy = false)
{
Peptide = "";
foreach (var aa in sequence)
{
Peptide += aa.Residue;
}
_spectrum = null;
_lcms = lcms;
ScanNum = scanNum;
PrecursorCharge = precursorCharge;
Decoy = decoy;
Sequence = sequence;
if (decoy)
{
CreateDecoy();
}
}
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 SpectrumMatch(string peptide, DataFileFormat sequenceFormat,
LazyLcMsRun lcms, int scanNum = 0, int precursorCharge = 1,
bool decoy = false, string formula="")
{
Peptide = peptide;
_spectrum = null;
_lcms = lcms;
ScanNum = scanNum;
PrecursorCharge = precursorCharge;
Decoy = decoy;
var sequenceReader = new SequenceReader(sequenceFormat);
Sequence = sequenceReader.GetSequence(peptide);
if (decoy) CreateDecoy();
else if (formula.Length > 0)
{
var composition = Composition.Parse(formula);
if (!composition.Equals(Sequence.Composition + Composition.H2O))
{
throw new MismatchException();
}
}
}
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();
}
}
}
}
}
public IcBottomUpTsvReader(string fileName, LazyLcMsRun lcms, bool decoy)
{
_fileName = fileName;
_lcms = lcms;
_decoy = decoy;
}
public void RankProbability()
{
var methodName = MethodBase.GetCurrentMethod().Name;
TestUtils.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 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();
}
}
}
}
}
