private static MZAnalyzerType GetMassAnalyzerType(MassAnalyzerType massAnalyzerType)
{
switch (massAnalyzerType)
{
case MassAnalyzerType.MassAnalyzerFTMS: return(MZAnalyzerType.Orbitrap);
case MassAnalyzerType.MassAnalyzerITMS: return(MZAnalyzerType.IonTrap2D);
case MassAnalyzerType.MassAnalyzerSector: return(MZAnalyzerType.Sector);
case MassAnalyzerType.MassAnalyzerTOFMS: return(MZAnalyzerType.TOF);
default: return(MZAnalyzerType.Unknown);
}
}
public static void Quantify(this QuantDataCollection quantData, RawDataCollection rawData, IRawDataPlus rawFile, string labelingReagent)
{
MassAnalyzerType quantAnalyzer = rawData.methodData.QuantAnalyzer;
if (quantAnalyzer == MassAnalyzerType.MassAnalyzerFTMS)
{
rawData.ExtractCentroidStreams(rawFile, rawData.methodData.AnalysisOrder);
}
else
{
rawData.ExtractSegmentScans(rawFile, rawData.methodData.AnalysisOrder);
}
int[] scans;
ScanIndex scanIndex = rawData.scanIndex;
Dictionary <int, CentroidStreamData> centroidScans = rawData.centroidStreams;
Dictionary <int, SegmentedScanData> segmentScans = rawData.segmentedScans;
scans = scanIndex.ScanEnumerators[scanIndex.AnalysisOrder];
ProgressIndicator progress = new ProgressIndicator(scans.Length, "Quantifying reporter ions");
quantData.LabelingReagents = labelingReagent;
foreach (int scan in scans)
{
if (quantAnalyzer == MassAnalyzerType.MassAnalyzerFTMS)
{
quantData.Add(scan, new QuantifyReporters(centroidScans[scan], labelingReagent).quantData);
}
else
{
quantData.Add(scan, new QuantifyReporters(segmentScans[scan], labelingReagent).quantData);
}
progress.Update();
}
progress.Done();
rawData.Performed.Add(Operations.Quantification);
}
private string readDetectorType(MassAnalyzerType type)
{
switch (type)
{
case MassAnalyzerType.MassAnalyzerFTMS:
return("FTMS");
case MassAnalyzerType.MassAnalyzerITMS:
return("ITMS");
case MassAnalyzerType.MassAnalyzerSQMS:
return("SQMS");
case MassAnalyzerType.MassAnalyzerTOFMS:
return("TOFMS");
case MassAnalyzerType.MassAnalyzerTQMS:
return("TQMS");
default:
return("");
}
}
public static void IdentipyExecute(string pyExec, string idpyScript, string mgfFile, SearchParameters identipyParameters, MassAnalyzerType Ms2Analyzer)
{
string fastaDB = identipyParameters.FastaDatabase;
string fmods = identipyParameters.FixedMods;
string vmods = null;
var tempMods = from x in (new string[] { identipyParameters.NMod, identipyParameters.KMod, identipyParameters.XMod })
where x != null
select x;
if (tempMods.Count() > 0)
{
vmods = tempMods.Aggregate((i, j) => i + "," + j);
}
string appDir = AppInformation.AssemblyDirectory;
string N;
string parameters = String.Empty;
string idpyConfig;
//string constants = "-ad -method reverse -prefix DECOY_ -at";
string constants = "";
// get the appropriate identipy config file
if (Ms2Analyzer == MassAnalyzerType.MassAnalyzerFTMS)
{
idpyConfig = Path.Combine(appDir, "orbitrap_config.cfg");
}
else
{
idpyConfig = Path.Combine(appDir, "iontrap_config.cfg");
}
// N is number of processors to use. Must be 1 on windows, but otherwise Identipy can decide how many to use
// I don't really know about on MacOS, so I'm going to leave it as 1 for that one for now
if (Environment.OSVersion.Platform == PlatformID.Unix)
{
N = "0";
}
else
{
N = "1";
}
if (fmods != null & vmods != null)
{
parameters = string.Format("-W ignore " + idpyScript + " -cfg {0} {1} -nproc {2} -db {3} -fmods {4} -vmods {5} {6}", idpyConfig, constants, N, fastaDB, fmods, vmods, mgfFile);
}
if (fmods == null & vmods != null)
{
parameters = string.Format("-W ignore " + idpyScript + " -cfg {0} {1} -nproc {2} -db {3} -vmods {4} {5}", idpyConfig, constants, N, fastaDB, vmods, mgfFile);
}
if (fmods != null & vmods == null)
{
parameters = string.Format("-W ignore " + idpyScript + " -cfg {0} {1} -nproc {2} -db {3} -fmods {4} {5}", idpyConfig, constants, N, fastaDB, fmods, mgfFile);
}
if (fmods == null & vmods == null)
{
parameters = string.Format("-W ignore " + idpyScript + " -cfg {0} {1} -nproc {2} -db {3} {4}", idpyConfig, constants, N, fastaDB, mgfFile);
}
ConsoleUtils.VoidBash(pyExec, parameters);
}
public static void WriteChromatogram(this RawDataCollection rawData, IRawDataPlus rawFile, MSOrderType order, bool TIC, bool BP, string outputDirectory)
{
List <Operations> operations = new List <Operations>()
{
Operations.RetentionTimes
};
//MSOrderType order = (MSOrderType)msOrder;
MassAnalyzerType analyzer = rawData.methodData.MassAnalyzers[order];
if (analyzer == MassAnalyzerType.MassAnalyzerFTMS)
{
if (order == MSOrderType.Ms)
{
operations.Add(Operations.Ms1CentroidStreams);
}
if (order == MSOrderType.Ms2)
{
operations.Add(Operations.Ms2CentroidStreams);
}
if (order == MSOrderType.Ms3)
{
operations.Add(Operations.Ms3CentroidStreams);
}
}
else
{
if (order == MSOrderType.Ms)
{
operations.Add(Operations.Ms1SegmentedScans);
}
if (order == MSOrderType.Ms2)
{
operations.Add(Operations.Ms2SegmentedScans);
}
if (order == MSOrderType.Ms3)
{
operations.Add(Operations.Ms3SegmentedScans);
}
}
CheckIfDone.Check(rawData, rawFile, operations);
int[] scans = rawData.scanIndex.ScanEnumerators[order];
if (TIC)
{
ProgressIndicator progress = new ProgressIndicator(scans.Length, String.Format("Writing {0} TIC chromatogram", order));
progress.Start();
string fileName = ReadWrite.GetPathToFile(outputDirectory, rawData.rawFileName, "_" + order + "_TIC_chromatogram.txt");
using (StreamWriter f = new StreamWriter(fileName))
{
f.WriteLine("RetentionTime\tIntensity");
if (analyzer == MassAnalyzerType.MassAnalyzerFTMS)
{
foreach (int scan in scans)
{
if (rawData.centroidStreams[scan].Intensities.Length > 0)
{
f.WriteLine("{0}\t{1}", rawData.retentionTimes[scan], rawData.centroidStreams[scan].Intensities.Sum());
}
else
{
f.WriteLine("{0}\t{1}", rawData.retentionTimes[scan], 0);
}
progress.Update();
}
}
else
{
foreach (int scan in scans)
{
if (rawData.segmentedScans[scan].Intensities.Length > 0)
{
f.WriteLine("{0}\t{1}", rawData.retentionTimes[scan], rawData.segmentedScans[scan].Intensities.Sum());
}
else
{
f.WriteLine("{0}\t{1}", rawData.retentionTimes[scan], 0);
}
progress.Update();
}
}
}
progress.Done();
}
if (BP)
{
ProgressIndicator progress = new ProgressIndicator(scans.Length, String.Format("Writing {0} base peak chromatogram", order));
progress.Start();
string fileName = ReadWrite.GetPathToFile(outputDirectory, rawData.rawFileName, "_" + order + "_BP_chromatogram.txt");
using (StreamWriter f = new StreamWriter(fileName))
{
f.WriteLine("RetentionTime\tIntensity");
if (analyzer == MassAnalyzerType.MassAnalyzerFTMS)
{
foreach (int scan in scans)
{
if (rawData.centroidStreams[scan].Intensities.Length > 0)
{
f.WriteLine("{0}\t{1}", rawData.retentionTimes[scan], rawData.centroidStreams[scan].Intensities.Max());
}
else
{
f.WriteLine("{0}\t{1}", rawData.retentionTimes[scan], 0);
}
progress.Update();
}
}
else
{
foreach (int scan in scans)
{
if (rawData.segmentedScans[scan].Intensities.Length > 0)
{
f.WriteLine("{0}\t{1}", rawData.retentionTimes[scan], rawData.segmentedScans[scan].Intensities.Max());
}
else
{
f.WriteLine("{0}\t{1}", rawData.retentionTimes[scan], 0);
}
progress.Update();
}
}
}
progress.Done();
}
}
public static void WriteMGF(RawDataCollection rawData, IRawDataPlus rawFile, string outputDirectory, double cutoff = 0, int[] scans = null, double intensityCutoff = 0.01)
{
double intCutoff = 0;
string fileName = ReadWrite.GetPathToFile(outputDirectory, rawData.rawFileName, ".mgf");
MassAnalyzerType ms2MassAnalyzer = rawData.methodData.MassAnalyzers[MSOrderType.Ms2];
List <Operations> operations = new List <Operations> {
Operations.ScanIndex, Operations.MethodData, Operations.TrailerExtras, Operations.RetentionTimes
};
if (ms2MassAnalyzer == MassAnalyzerType.MassAnalyzerFTMS)
{
operations.Add(Operations.Ms2CentroidStreams);
}
else
{
operations.Add(Operations.Ms2SegmentedScans);
}
CheckIfDone.Check(rawData, rawFile, operations);
const int BufferSize = 65536; // 64 Kilobytes
using (StreamWriter f = new StreamWriter(fileName, false, Encoding.UTF8, BufferSize)) //Open a new file, the MGF file
{
// if the scans argument is null, use all scans
if (scans == null)
{
scans = rawData.scanIndex.ScanEnumerators[MSOrderType.Ms2];
}
ProgressIndicator progress = new ProgressIndicator(scans.Count(), String.Format("Writing MGF file"));
foreach (int i in scans)
{
f.WriteLine("\nBEGIN IONS");
f.WriteLine("RAWFILE={0}", rawData.rawFileName);
f.WriteLine("TITLE=Spectrum_{0}", i);
f.WriteLine("SCAN={0}", i);
f.WriteLine("RTINSECONDS={0}", rawData.retentionTimes[i]);
f.WriteLine("PEPMASS={0}", rawData.trailerExtras[i].MonoisotopicMZ);
f.WriteLine("CHARGE={0}", rawData.trailerExtras[i].ChargeState);
if (ms2MassAnalyzer == MassAnalyzerType.MassAnalyzerFTMS)
{
CentroidStreamData centroid = rawData.centroidStreams[i];
if (centroid.Intensities.Length > 0)
{
intCutoff = centroid.Intensities.Max() * intensityCutoff;
}
else
{
intCutoff = 0;
}
for (int j = 0; j < centroid.Masses.Length; j++)
{
//f.WriteLine(Math.Round(centroid.Masses[j], 4).ToString() + " " + Math.Round(centroid.Intensities[j], 4).ToString());
if (centroid.Masses[j] > cutoff & centroid.Intensities[j] > intCutoff)
{
f.WriteLine("{0} {1}", Math.Round(centroid.Masses[j], 5), Math.Round(centroid.Intensities[j], 4));
}
}
}
else
{
SegmentedScanData segments = rawData.segmentedScans[i];
if (segments.Intensities.Length > 0)
{
intCutoff = segments.Intensities.Max() * intensityCutoff;
}
else
{
intCutoff = 0;
}
for (int j = 0; j < segments.Positions.Length; j++)
{
if (segments.Positions[j] > cutoff & segments.Intensities[j] > intCutoff)
{
f.WriteLine("{0} {1}", Math.Round(segments.Positions[j], 5), Math.Round(segments.Intensities[j], 4));
}
}
}
f.WriteLine("END IONS");
progress.Update();
}
progress.Done();
}
Utilities.ConsoleUtils.ClearLastLine();
}
