public void PrintOffsetFrequency()
        {
            var methodName = MethodBase.GetCurrentMethod().Name;
            TestUtils.ShowStarting(methodName);

            if (!File.Exists(TsvFile))
            {
                Assert.Ignore(@"Skipping test {0} since file not found: {1}", methodName, TsvFile);
            }

            var spectrumMatches = InitTest();

            using (var debugFile = new StreamWriter(OutputFileName))
            {
                foreach (var spectrumMatch in spectrumMatches)
                {

                    var offsetFrequencyTable = new PrecursorOffsetFrequencyTable(100, spectrumMatch.PrecursorCharge,
                        1.005/spectrumMatch.PrecursorCharge);

                    var ionType = _ionTypes[spectrumMatch.PrecursorCharge - 1];
                    var ion = ionType.GetIon(spectrumMatch.PeptideComposition);
                    var mz = ion.GetMonoIsotopicMz();

                    offsetFrequencyTable.AddMatches(new List<SpectrumMatch> {spectrumMatch});
                    var offsetFrequencies = offsetFrequencyTable.GetProbabilities();

                    debugFile.WriteLine("ScanNum\tM/Z\tPrecursor Charge\tIon Type\tPeptide");
                    debugFile.WriteLine("{0}\t{1}\t{2}\t{3}\t{4}",
                        spectrumMatch.Spectrum.ScanNum, mz, spectrumMatch.PrecursorCharge, ionType.Name, spectrumMatch.Peptide);
                    debugFile.WriteLine("Offset\tM/Z");
                    foreach (var offsetFrequency in offsetFrequencies)
                    {
                        if (offsetFrequency.Found > 0)
                            debugFile.WriteLine("{0}\t{1}", offsetFrequency.Label, offsetFrequency.Label+mz);
                    }
                }
            }
        }
示例#2
0
        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);
                        }
                    }
                }
            }
        }