public override void ConvertTo(BuildSummaryOptions result)
{
base.ConvertTo(result);
foreach (AbstractExpectValueDatasetOptions ds in result.DatasetList)
{
ds.Enabled = true;
ds.FilterByExpectValue = this.FilterByExpectValue;
ds.FilterByScore = this.FilterByScore;
ds.MaxExpectValue = this.MaxExpectValue;
ds.MinScore = this.MinScore;
ds.TitleParserName = this.TitleParserName;
}
}
public override IEnumerable <string> Process()
{
var result = new List <string>();
BuildSummaryOptions conf = BuildSummaryOptionsUtils.LoadFromFile(options.InputFile);
if (!conf.MergeResult)
{
for (int i = 0; i < conf.DatasetList.Count; i++)
{
for (int j = 0; j < conf.DatasetList[i].PathNames.Count; j++)
{
var curConf = BuildSummaryOptionsUtils.LoadFromFile(options.InputFile);
for (int k = curConf.DatasetList.Count - 1; k >= 0; k--)
{
if (k != i)
{
curConf.DatasetList.RemoveAt(k);
}
}
for (int k = curConf.DatasetList[0].PathNames.Count - 1; k >= 0; k--)
{
if (k != j)
{
curConf.DatasetList[0].PathNames.RemoveAt(k);
}
}
curConf.MergeResult = false;
var curFile = curConf.DatasetList[0].PathNames[0];
var curParamFile = Path.GetDirectoryName(options.InputFile) + "\\" + Path.ChangeExtension(new FileInfo(curFile).Name, ".param");
curConf.SaveToFile(curParamFile);
RunCurrentParameter(curParamFile, result, curConf);
}
}
}
else
{
RunCurrentParameter(options.InputFile, result, conf);
}
return(result);
}
public virtual void ConvertTo(BuildSummaryOptions result)
{
result.ApplicationTitle = this.ApplicationTitle;
result.MergeResult = this.MergeResult;
result.KeepTopPeptideFromSameEngineButDifferentSearchParameters = this.MergeResultFromSameEngineButDifferentSearchParameters;
result.Classification.ClassifyByCharge = this.ClassifyByCharge;
result.Classification.ClassifyByMissCleavage = this.ClassifyByMissCleavage;
result.Classification.ClassifyByModification = this.ClassifyByModification;
result.Classification.ClassifyByNumProteaseTermini = this.ClassifyByNumProteaseTermini;
result.Classification.ModifiedAminoacids = this.ModifiedAminoacids;
result.Classification.ClassifyByProteinTag = this.ClassifyByProteinTag;
result.Classification.ProteinTag = this.ProteinTag;
result.FalseDiscoveryRate.FilterByFdr = this.FilterByFdr;
result.FalseDiscoveryRate.FdrLevel = this.FdrLevel;
result.FalseDiscoveryRate.FdrType = this.FdrType;
result.FalseDiscoveryRate.FdrValue = this.FdrValue;
result.FalseDiscoveryRate.FdrPeptideCount = this.FdrPeptideCount;
result.FalseDiscoveryRate.MaxPeptideFdr = this.MaxPeptideFdr;
result.FalseDiscoveryRate.TargetDecoyConflictType = this.TargetDecoyConflictType;
result.Database = new DatabaseOptions(this.Database);
result.PeptideFilter.FilterBySequenceLength = this.FilterBySequenceLength;
result.PeptideFilter.MinSequenceLength = this.MinSequenceLength;
var dics = from s in this.PathNameBin
group s.Key by s.Value;
result.DatasetList.Clear();
foreach (var tag in dics)
{
var ds = DatasetListOptions.GetDatasetOption(this.SearchEngine);
ds.Name = tag.Key;
ds.Parent = result;
ds.PathNames = (from t in tag
select t).ToList();
ds.FilterByPrecursor = this.FilterByPrecursor;
ds.FilterByPrecursorIsotopic = this.FilterByPrecursorSecondIsotopic;
ds.FilterByPrecursorDynamicTolerance = this.FilterByPrecursorDynamicTolerance;
ds.PrecursorPPMTolerance = this.PrecursorPPMTolerance;
result.DatasetList.Add(ds);
}
}
public override void ConvertTo(BuildSummaryOptions result)
{
base.ConvertTo(result);
foreach (SequestDatasetOptions ds in result.DatasetList)
{
ds.Enabled = true;
ds.FilterByXcorr = this.FilterByXcorr;
ds.FilterByDeltaCn = this.FilterByDeltaCn;
ds.FilterBySpRank = this.FilterBySpRank;
ds.MaxModificationDeltaCn = this.MaxModificationDeltaCn;
ds.MaxSpRank = this.MaxSpRank;
ds.MinDeltaCn = this.MinDeltaCn;
ds.MinXcorr1 = this.MinXcorr1;
ds.MinXcorr2 = this.MinXcorr2;
ds.MinXcorr3 = this.MinXcorr3;
}
}
protected override void SaveDatasetList(BuildSummaryOptions conf)
{
Dictionary <string, IDatasetOptions> dsmap = new Dictionary <string, IDatasetOptions>();
foreach (ListViewItem item in this.lvDatFiles.Items)
{
if (item.Selected)
{
var key = string.Empty;
if (item.SubItems.Count >= 3)
{
key = item.SubItems[2].Text;
}
if (!dsmap.ContainsKey(key))
{
var dsoptions = new MascotDatasetOptions();
dsoptions.Name = key;
dsoptions.Parent = conf;
dsoptions.TitleParserName = this.titleParsers.SelectedItem.FormatName;
dsmap[key] = dsoptions;
conf.DatasetList.Add(dsoptions);
}
dsmap[key].PathNames.Add(item.SubItems[0].Text);
}
}
foreach (MascotDatasetOptions dataset in conf.DatasetList)
{
dataset.FilterByScore = this.filterByScore.Checked;
if (dataset.FilterByScore)
{
dataset.MinScore = this.minScore.Value;
}
dataset.FilterByExpectValue = this.filterByExpectValue.Checked;
if (dataset.FilterByExpectValue)
{
dataset.MaxExpectValue = this.maxExpectValue.Value;
}
}
}
public override void ConvertFrom(BuildSummaryOptions result)
{
base.ConvertFrom(result);
this.PathNameBin.Clear();
var dsList = result.DatasetList.Where(m => m.Enabled).ToList();
if (dsList.Count == 0)
{
return;
}
foreach (var ds1 in dsList)
{
if (ds1 is SequestDatasetOptions)
{
continue;
}
throw new Exception(MyConvert.Format("The data set {0} is not Sequest data set.", ds1.Name));
}
SequestDatasetOptions ds = dsList[0] as SequestDatasetOptions;
this.FilterByXcorr = ds.FilterByXcorr;
this.FilterByDeltaCn = ds.FilterByDeltaCn;
this.FilterBySpRank = ds.FilterBySpRank;
this.MaxModificationDeltaCn = ds.MaxModificationDeltaCn;
this.MaxSpRank = ds.MaxSpRank;
this.MinDeltaCn = ds.MinDeltaCn;
this.MinXcorr1 = ds.MinXcorr1;
this.MinXcorr2 = ds.MinXcorr2;
this.MinXcorr3 = ds.MinXcorr3;
foreach (SequestDatasetOptions ds2 in dsList)
{
foreach (var file in ds2.PathNames)
{
this.PathNameBin[file] = ds2.Name;
}
}
}
protected void WriteFdrFile(string parameterFile, BuildSummaryOptions conf, List <IIdentifiedSpectrum> result)
{
Progress.SetMessage("Calculating identified peptide false discovery rate ...");
IFalseDiscoveryRateCalculator calc = conf.FalseDiscoveryRate.GetFalseDiscoveryRateCalculator();
DecoyPeptideBuilder.AssignDecoy(result, conf.GetDecoySpectrumFilter());
int decoyCount = 0;
int targetCount = 0;
foreach (IIdentifiedSpectrum mph in result)
{
if (mph.FromDecoy)
{
decoyCount++;
}
else
{
targetCount++;
}
}
double fdr = calc.Calculate(decoyCount, targetCount);
string optimalResultFile = FileUtils.ChangeExtension(parameterFile, ".optimal");
using (var sw = new StreamWriter(optimalResultFile))
{
List <string> filters = conf.GetFilterString();
foreach (string filter in filters)
{
sw.WriteLine(filter);
}
sw.WriteLine("DecoyCount\t{0}", decoyCount);
sw.WriteLine("TargetCount\t{0}", targetCount);
sw.WriteLine("FDR\t{0:0.######}", fdr);
}
}
protected override void LoadDatasetList(BuildSummaryOptions options)
{
if (options.DatasetList.Count > 0)
{
var conf = options.DatasetList[0] as MascotDatasetOptions;
this.filterByScore.Checked = conf.FilterByScore;
if (conf.FilterByScore)
{
this.minScore.Value = conf.MinScore;
}
this.filterByExpectValue.Checked = conf.FilterByExpectValue;
if (conf.FilterByExpectValue)
{
this.maxExpectValue.Value = conf.MaxExpectValue;
}
foreach (ITitleParser obj in titleParsers.Items)
{
if (obj.FormatName.Equals(conf.TitleParserName))
{
titleParsers.SelectedItem = obj;
break;
}
}
}
this.lvDatFiles.Items.Clear();
foreach (var dataset in options.DatasetList)
{
foreach (var file in dataset.PathNames)
{
ListViewItem item = this.lvDatFiles.Items.Add(file);
item.SubItems.Add("");
item.SubItems.Add(dataset.Name);
item.Selected = true;
}
}
}
public override void ConvertFrom(BuildSummaryOptions result)
{
base.ConvertFrom(result);
this.PathNameBin.Clear();
var dsList = result.DatasetList.Where(m => m.Enabled).ToList();
if (dsList.Count == 0)
{
return;
}
foreach (var ds in dsList)
{
if (ds.SearchEngine.ToString() == this.SearchEngine)
{
continue;
}
throw new Exception(MyConvert.Format("The data set {0} [{1}] is not {2} data set.", ds.Name, ds.SearchEngine.ToString(), this.SearchEngine));
}
AbstractExpectValueDatasetOptions ds2 = dsList[0] as AbstractExpectValueDatasetOptions;
this.FilterByExpectValue = ds2.FilterByExpectValue;
this.FilterByScore = ds2.FilterByScore;
this.MaxExpectValue = ds2.MaxExpectValue;
this.MinScore = ds2.MinScore;
this.TitleParserName = ds2.TitleParserName;
foreach (var ds3 in dsList)
{
foreach (var file in ds3.PathNames)
{
this.PathNameBin[file] = ds3.Name;
}
}
}
public virtual void ConvertFrom(BuildSummaryOptions result)
{
this.ApplicationTitle = result.ApplicationTitle;
this.MergeResult = result.MergeResult;
this.MergeResultFromSameEngineButDifferentSearchParameters = result.KeepTopPeptideFromSameEngineButDifferentSearchParameters;
this.ClassifyByCharge = result.Classification.ClassifyByCharge;
this.ClassifyByMissCleavage = result.Classification.ClassifyByMissCleavage;
this.ClassifyByModification = result.Classification.ClassifyByModification;
this.ClassifyByNumProteaseTermini = result.Classification.ClassifyByNumProteaseTermini;
this.ModifiedAminoacids = result.Classification.ModifiedAminoacids;
this.ClassifyByProteinTag = result.Classification.ClassifyByProteinTag;
this.ProteinTag = result.Classification.ProteinTag;
this.FilterByFdr = result.FalseDiscoveryRate.FilterByFdr;
this.FdrLevel = result.FalseDiscoveryRate.FdrLevel;
this.FdrType = result.FalseDiscoveryRate.FdrType;
this.FdrValue = result.FalseDiscoveryRate.FdrValue;
this.FdrPeptideCount = result.FalseDiscoveryRate.FdrPeptideCount;
this.MaxPeptideFdr = result.FalseDiscoveryRate.MaxPeptideFdr;
this.TargetDecoyConflictType = result.FalseDiscoveryRate.TargetDecoyConflictType;
this.Database = new DatabaseOptions(result.Database);
this.FilterBySequenceLength = result.PeptideFilter.FilterBySequenceLength;
this.MinSequenceLength = result.PeptideFilter.MinSequenceLength;
var ds = result.DatasetList.First(m => m.Enabled);
if (ds != null)
{
this.FilterByPrecursor = ds.FilterByPrecursor;
this.FilterByPrecursorSecondIsotopic = ds.FilterByPrecursorIsotopic;
this.FilterByPrecursorDynamicTolerance = ds.FilterByPrecursorDynamicTolerance;
this.PrecursorPPMTolerance = ds.PrecursorPPMTolerance;
}
}
public static IdentificationSummary Parse(string proteinFile, string defaultDecoyPattern, IFalseDiscoveryRateCalculator defaultCalc)
{
IdentificationSummary result = new IdentificationSummary();
result.FileName = FileUtils.ChangeExtension(new FileInfo(proteinFile).Name, "");
Regex decoyReg = new Regex(defaultDecoyPattern);
IIdentifiedProteinGroupFilter decoyFilter = null;
IFalseDiscoveryRateCalculator curCalc = null;
var paramFile = FileUtils.ChangeExtension(proteinFile, ".param");
if (File.Exists(paramFile))
{
BuildSummaryOptions options = BuildSummaryOptionsUtils.LoadFromFile(paramFile);
if (options.FalseDiscoveryRate.FilterByFdr)
{
decoyFilter = options.GetDecoyGroupFilter();
curCalc = options.FalseDiscoveryRate.GetFalseDiscoveryRateCalculator();
}
}
if (decoyFilter == null)
{
decoyFilter = new IdentifiedProteinGroupNameRegexFilter(defaultDecoyPattern, false);
curCalc = defaultCalc;
}
var peptideFile = FileUtils.ChangeExtension(proteinFile, ".peptides");
if (File.Exists(peptideFile))
{
var peptides = new MascotPeptideTextFormat().ReadFromFile(peptideFile);
var fullSpectra = GetSpectraByNPT(peptides, 2);
var fullTargetSpectra = GetTargetSpectra(decoyReg, fullSpectra);
var semiSpectra = GetSpectraByNPT(peptides, 1);
var semiTargetSpectra = GetTargetSpectra(decoyReg, semiSpectra);
result.FullSpectrumCount = GetSpectrumCount(fullSpectra);
result.FullTargetSpectrumCount = GetSpectrumCount(fullTargetSpectra);
result.SemiSpectrumCount = GetSpectrumCount(semiSpectra);
result.SemiTargetSpectrumCount = GetSpectrumCount(semiTargetSpectra);
result.FullPeptideCount = IdentifiedSpectrumUtils.GetUniquePeptideCount(fullSpectra);
result.FullTargetPeptideCount = IdentifiedSpectrumUtils.GetUniquePeptideCount(fullTargetSpectra);
result.SemiPeptideCount = IdentifiedSpectrumUtils.GetUniquePeptideCount(semiSpectra);
result.SemiTargetPeptideCount = IdentifiedSpectrumUtils.GetUniquePeptideCount(semiTargetSpectra);
result.FullSpectrumFdr = curCalc.Calculate(result.FullSpectrumCount - result.FullTargetSpectrumCount, result.FullTargetSpectrumCount);
result.SemiSpectrumFdr = curCalc.Calculate(result.SemiSpectrumCount - result.SemiTargetSpectrumCount, result.SemiTargetSpectrumCount);
result.FullPeptideFdr = curCalc.Calculate(result.FullPeptideCount - result.FullTargetPeptideCount, result.FullTargetPeptideCount);
result.SemiPeptideFdr = curCalc.Calculate(result.SemiPeptideCount - result.SemiTargetPeptideCount, result.SemiTargetPeptideCount);
}
if (File.Exists(proteinFile))
{
var ir = new MascotResultTextFormat().ReadFromFile(proteinFile);
ir.InitUniquePeptideCount();
var u2proteins = (from p in ir
where p[0].UniquePeptideCount > 1
select p).ToList();
var u1proteins = (from p in ir
where p[0].UniquePeptideCount == 1
select p).ToList();
result.ProteinGroupCount = ir.Count;
result.Unique2ProteinGroupCount = u2proteins.Count;
int targetCount;
result.Unique2ProteinFdr = CalculateProteinFdr(u2proteins, decoyFilter, defaultCalc, out targetCount);
result.Unique2ProteinGroupTargetCount = (int)targetCount;
result.Unique1ProteinFdr = CalculateProteinFdr(u1proteins, decoyFilter, defaultCalc, out targetCount);
result.Unique1ProteinGroupTargetCount = (int)targetCount;
}
return(result);
}
public void Test()
{
var option = new BuildSummaryOptions();
option.LoadFromFile(TestContext.CurrentContext.TestDirectory + "/../../../data//BuildSummary.param");
}
private void RunCurrentParameter(string parameterFile, List <string> result, BuildSummaryOptions conf)
{
IStringParser <string> acParser = conf.Database.GetAccessNumberParser();
IIdentifiedProteinBuilder proteinBuilder = new IdentifiedProteinBuilder();
IIdentifiedProteinGroupBuilder groupBuilder = new IdentifiedProteinGroupBuilder()
{
Progress = this.Progress
};
IdentifiedSpectrumBuilderResult isbr;
List <IIdentifiedSpectrum> finalPeptides;
if (string.IsNullOrEmpty(options.PeptideFile))
{ //parse from configuration
//build spectrum list
IIdentifiedSpectrumBuilder spectrumBuilder = conf.GetSpectrumBuilder();
if (spectrumBuilder is IProgress)
{
(spectrumBuilder as IProgress).Progress = this.Progress;
}
isbr = spectrumBuilder.Build(parameterFile);
finalPeptides = isbr.Spectra;
}
else
{
Progress.SetMessage("Reading peptides from {0} ...", options.PeptideFile);
finalPeptides = new MascotPeptideTextFormat().ReadFromFile(options.PeptideFile);
conf.SavePeptidesFile = false;
isbr = null;
}
CalculateIsoelectricPoint(finalPeptides);
//如果需要通过蛋白质注释去除contamination，首先需要在肽段水平删除
if (conf.Database.HasContaminationDescriptionFilter() && (conf.FalseDiscoveryRate.FdrLevel != FalseDiscoveryRateLevel.Protein))
{
Progress.SetMessage("Removing contamination by description ...");
var notConGroupFilter = conf.Database.GetNotContaminationDescriptionFilter(Progress);
var tempResultBuilder = new IdentifiedResultBuilder(null, null);
while (true)
{
List <IIdentifiedProtein> proteins = proteinBuilder.Build(finalPeptides);
List <IIdentifiedProteinGroup> groups = groupBuilder.Build(proteins);
IIdentifiedResult tmpResult = tempResultBuilder.Build(groups);
HashSet <IIdentifiedSpectrum> notConSpectra = new HashSet <IIdentifiedSpectrum>();
foreach (var group in tmpResult)
{
if (notConGroupFilter.Accept(group))
{
notConSpectra.UnionWith(group[0].GetSpectra());
}
}
if (notConSpectra.Count == finalPeptides.Count)
{
break;
}
finalPeptides = notConSpectra.ToList();
}
}
if (conf.FalseDiscoveryRate.FilterOneHitWonder && conf.FalseDiscoveryRate.MinOneHitWonderPeptideCount > 1)
{
Progress.SetMessage("Filtering single wonders ...");
var proteinFilter = new IdentifiedProteinSingleWonderPeptideCountFilter(conf.FalseDiscoveryRate.MinOneHitWonderPeptideCount);
List <IIdentifiedProtein> proteins = proteinBuilder.Build(finalPeptides);
int oldProteinCount = proteins.Count;
proteins.RemoveAll(l => !proteinFilter.Accept(l));
if (oldProteinCount != proteins.Count)
{
HashSet <IIdentifiedSpectrum> newspectra = new HashSet <IIdentifiedSpectrum>();
foreach (var protein in proteins)
{
newspectra.UnionWith(protein.GetSpectra());
}
finalPeptides = newspectra.ToList();
}
}
//if (conf.SavePeptidesFile && !(conf.FalseDiscoveryRate.FilterOneHitWonder && conf.FalseDiscoveryRate.MinOneHitWonderPeptideCount > 1))
if (conf.SavePeptidesFile)
{
if (conf.Database.RemovePeptideFromDecoyDB)
{
DecoyPeptideBuilder.AssignDecoy(finalPeptides, conf.GetDecoySpectrumFilter());
for (int i = finalPeptides.Count - 1; i >= 0; i--)
{
if (finalPeptides[i].FromDecoy)
{
finalPeptides.RemoveAt(i);
}
}
}
finalPeptides.Sort();
//保存肽段文件
IFileFormat <List <IIdentifiedSpectrum> > peptideFormat = conf.GetIdentifiedSpectrumFormat();
string peptideFile = FileUtils.ChangeExtension(parameterFile, ".peptides");
Progress.SetMessage("Writing peptides file...");
peptideFormat.WriteToFile(peptideFile, finalPeptides);
result.Add(peptideFile);
if (!conf.FalseDiscoveryRate.FilterByFdr && conf.Database.DecoyPatternDefined)
{
WriteFdrFile(parameterFile, conf, finalPeptides);
}
Progress.SetMessage("Calculating precursor offset...");
result.AddRange(new PrecursorOffsetCalculator(finalPeptides).Process(peptideFile));
}
Progress.SetMessage("Building protein...");
//构建蛋白质列表
List <IIdentifiedProtein> finalProteins = proteinBuilder.Build(finalPeptides);
Progress.SetMessage("Building protein group...");
//构建蛋白质群列表
List <IIdentifiedProteinGroup> finalGroups = groupBuilder.Build(finalProteins);
if (conf.Database.HasContaminationDescriptionFilter())
{
var notConGroupFilter = conf.Database.GetNotContaminationDescriptionFilter(Progress);
for (int i = finalGroups.Count - 1; i >= 0; i--)
{
if (!notConGroupFilter.Accept(finalGroups[i]))
{
finalGroups.RemoveAt(i);
}
}
}
//构建最终鉴定结果
var resultBuilder = conf.GetIdentifiedResultBuilder();
resultBuilder.Progress = Progress;
IIdentifiedResult finalResult = resultBuilder.Build(finalGroups);
finalResult.BuildGroupIndex();
if (conf.FalseDiscoveryRate.FilterByFdr)
{
var decoyGroupFilter = conf.GetDecoyGroupFilter();
foreach (var group in finalResult)
{
group.FromDecoy = decoyGroupFilter.Accept(group);
foreach (var protein in group)
{
protein.FromDecoy = group.FromDecoy;
}
}
finalResult.ProteinFDR = conf.FalseDiscoveryRate.GetFalseDiscoveryRateCalculator().Calculate(finalResult.Count(l => l[0].FromDecoy), finalResult.Count(l => !l[0].FromDecoy));
}
CalculateIsoelectricPoint(finalResult.GetProteins());
if (isbr != null)
{
finalResult.PeptideFDR = isbr.PeptideFDR;
}
//保存非冗余蛋白质列表文件
var resultFormat = conf.GetIdetifiedResultFormat(finalResult, this.Progress);
string noredundantFile = FileUtils.ChangeExtension(parameterFile, ".noredundant");
Progress.SetMessage("Writing noredundant file...");
resultFormat.WriteToFile(noredundantFile, finalResult);
result.Add(noredundantFile);
Progress.SetMessage("Finished!");
}
public void Test()
{
var option = new BuildSummaryOptions();
option.LoadFromFile("../../../data/BuildSummary.param");
}
public UniformSummaryBuilderUI()
{
InitializeComponent();
Option = new BuildSummaryOptions();
InsertButton(2, btnNew);
InsertButton(3, this.btnLoadParam);
InsertButton(4, this.btnSaveParam);
this.minDecoyScan.DefaultValue = MascotGenericFormatShiftPrecursorProcessorOptions.DEFAULT_ShiftScan.ToString();
this.decoyPattern = new RcpaTextField(this.txtDecoyPattern, "DecoyPattern", "Decoy Database Pattern", "^REVERSED_", false);
AddComponent(this.decoyPattern);
this.removeContamination = new RcpaCheckBox(cbRemoveContamination, "RemoveContamination", false);
AddComponent(this.removeContamination);
this.contaminationNamePattern = new RcpaTextField(this.txtContaminantString, "ContaminationNamePattern", "Contaminant Name Pattern", "CON_", false);
AddComponent(this.contaminationNamePattern);
this.contaminationDescriptionPattern = new RcpaTextField(this.txtContaminantDescriptionPattern, "ContaminantDescriptionPattern", "Contaminant Description Pattern", "KERATIN", false);
AddComponent(this.contaminationDescriptionPattern);
this.filterByFdr = new RcpaCheckBox(this.cbFilterByFDR, "FilterByFDR", true);
AddComponent(this.filterByFdr);
this.maxFdr = new RcpaDoubleField(this.txtMaxFdr, "MaxFdr", "Max False Discovery Rate", 0.01, true);
AddComponent(this.maxFdr);
this.maxPeptideFdr = new RcpaDoubleField(this.txtMaxPeptideFdr, "MaxPeptideFdr", "Max Peptide FDR", 0.01, true);
AddComponent(this.maxPeptideFdr);
this.filterProteinByPeptideCount = new RcpaCheckBox(this.cbPeptideCount, "FilterProteinByPeptideCount", false);
AddComponent(this.filterProteinByPeptideCount);
this.fdrLevel = new RcpaComboBox <FalseDiscoveryRateLevel>(this.cbFdrLevel, "FdrLevel",
new[]
{
FalseDiscoveryRateLevel.Peptide,
FalseDiscoveryRateLevel.Protein,
FalseDiscoveryRateLevel.SimpleProtein,
FalseDiscoveryRateLevel.UniquePeptide
}, 1);
AddComponent(this.fdrLevel);
this.peptideRetrieval = new RcpaCheckBox(this.cbPeptideRetrieval, "PeptideRetrieval", true);
AddComponent(this.peptideRetrieval);
this.fdrType = new RcpaComboBox <FalseDiscoveryRateType>(this.cbFdrType, "FdrType",
new[]
{
FalseDiscoveryRateType.Target,
FalseDiscoveryRateType.Total
},
new[]
{
"Target : N(decoy) / N(target)",
"Global : N(decoy) * 2 / (N(decoy) + N(target))"
}, 0);
AddComponent(this.fdrType);
this.classifyByCharge = new RcpaCheckBox(this.cbClassifyByCharge, "ClassifyByCharge", ClassificationOptions.DEFAULT_ClassifyByCharge);
AddComponent(this.classifyByCharge);
this.classifyByMissCleavage = new RcpaCheckBox(this.cbClassifyByMissCleavage, "ClassifyByMissCleavage", ClassificationOptions.DEFAULT_ClassifyByMissCleavage);
AddComponent(this.classifyByMissCleavage);
this.classifyByNumberOfProteaseTermini = new RcpaCheckBox(this.cbClassifyByPreteaseTermini, "ClassifyByNumberOfProteaseTermini", ClassificationOptions.DEFAULT_ClassifyByNumProteaseTermini);
AddComponent(this.classifyByNumberOfProteaseTermini);
this.classifyByModification = new RcpaCheckBox(this.cbClassifyByModification, "ClassifyByModification", ClassificationOptions.DEFAULT_ClassifyByModification);
AddComponent(this.classifyByModification);
this.modifiedAminoacids = new RcpaTextField(this.txtFdrModifiedAminoacids, "ModifiedAminoacids", "Modified Aminoacids", "STY", true);
this.modifiedAminoacids.PreCondition = this.cbClassifyByModification;
AddComponent(this.modifiedAminoacids);
this.classifyByProteinTag = new RcpaCheckBox(this.cbClassifyByProteinTag, "ClassifyByProteinTag", ClassificationOptions.DEFAULT_ClassifyByProteinTag);
AddComponent(this.classifyByProteinTag);
this.proteinTag = new RcpaTextField(this.txtProteinTag, "ProteinTag", "Protein Tag", "", false);
this.proteinTag.PreCondition = this.cbClassifyByProteinTag;
AddComponent(this.proteinTag);
this.minimumSpectraPerGroup = new RcpaIntegerField(this.txtMinimumSpectraPerGroup, "MinimumSpectraPerGroup", "MinimumSpectraPerGroup", ClassificationOptions.DEFAULT_MinimumSpectraPerGroup, true);
AddComponent(this.minimumSpectraPerGroup);
this.filterSequenceLength = new RcpaCheckBox(this.cbSequenceLength, "FilterSequenceLength", false);
AddComponent(this.filterSequenceLength);
this.minSequenceLength = new RcpaIntegerField(this.txtMinSequenceLength, "MinSequenceLength", "Minmum Sequence Length", PeptideFilterOptions.DEFAULT_MinSequenceLength, false);
this.minSequenceLength.PreCondition = cbSequenceLength;
AddComponent(this.minSequenceLength);
this.filterMaxMissCleavage = new RcpaCheckBox(this.cbMaxMissCleavage, "FilterMaxMisscleavage", false);
AddComponent(this.filterMaxMissCleavage);
this.maxMissCleagage = new RcpaIntegerField(this.txtMaxMissCleavage, "MaxMissCleavage", "Maximum Number of Internal Missed Cleavage", PeptideFilterOptions.DEFAULT_MaxMissCleavage, false);
this.maxMissCleagage.PreCondition = cbMaxMissCleavage;
AddComponent(this.maxMissCleagage);
this.removeDecoyEntry = new RcpaCheckBox(this.cbRemoveDecoyEntry, "RemovePeptideFromDecoyDB", false);
AddComponent(this.removeDecoyEntry);
this.database = new RcpaFileField(btnDatabase, txtDatabase, "Database", new OpenFileArgument("Protein Database", "fasta"), "", true);
AddComponent(this.database);
this.acParsers = new RcpaComboBox <IAccessNumberParser>(this.cbAccessNumberPattern, "AccessNumberPattern", AccessNumberParserFactory.GetParsers().ToArray(), 0);
AddComponent(this.acParsers);
this.seConflictType = new RcpaComboBox <IResolveSearchEngineConflictType>(cbConflict, "ConflictType", ResolveSearchEngineConflictTypeFactory.GetTypes(), 1);
AddComponent(this.seConflictType);
this.conflictAsDecoy = new RcpaComboBox <ITargetDecoyConflictType>(cbConflictAsDecoy, "ConflictAsDecoy", ResolveTargetDecoyConflictTypeFactory.GetTypes(), 0);
AddComponent(this.conflictAsDecoy);
this.minAgreeCount = new RcpaIntegerField(txtMinAgreeCount, "MinAgreeCount", "Minimum agree count of engines", 1, true);
AddComponent(this.minAgreeCount);
minOneHitWonderPeptideCount = new RcpaIntegerField(txtMinOneHitWonderPeptideCount, "MinOneHitWonderPeptideCount", "minimum one-hit-wonder peptide count", 2, false);
AddComponent(minOneHitWonderPeptideCount);
minOneHitWonderPeptideCount.PreCondition = FilterOneHitWonder;
this.AfterLoadOption += DoAfterLoadOption;
Text = Constants.GetSQHTitle(title, version);
var engines = EnumUtils.EnumToArray <SearchEngineType>().OrderByDescending(m => m.ToString()).ToArray();
foreach (var engine in engines)
{
if (engine.HasFactory())
{
var button = new Button();
pnlAdd.Controls.Add(button);
button.Dock = System.Windows.Forms.DockStyle.Top;
button.UseVisualStyleBackColor = true;
button.Text = "Add " + engine.ToString();
button.Name = "btnAdd" + engine.ToString();
button.Tag = engine;
button.Click += button_Click;
}
}
pnlAdd.Update();
}
private void btnNew_Click(object sender, EventArgs e)
{
this.Option = new BuildSummaryOptions();
AssignValueFromOption();
}
