private bool Statistics(string[] args) { if (args.Length != 2) { Herald.Announce(Herald.MessageType.Error, string.Format("Invalid arguments.")); return(false); } string resultFile = ""; if (!ExtractResultsFile(args[1], out resultFile)) { return(false); // invalid file URI. } SortedDictionary <int, int> result = new SortedDictionary <int, int>(); Herald.AnnounceExeReport("Statistics", di4B.LambdaSizeStats(out result)); using (StreamWriter writer = new StreamWriter(resultFile)) { writer.WriteLine("Lambda Size\tCount"); foreach (var item in result) { writer.WriteLine("{0}\t{1}", item.Key, item.Value); } } return(true); }
private bool AccumulationHistogram(string[] args) { if (args.Length != 2 && args.Length != 3) { Herald.Announce(Herald.MessageType.Error, string.Format("Invalid arguments.")); return(false); } if (args.Length == 3 && !ParseMux(args[2])) { return(false); } string resultFile = ""; if (!ExtractResultsFile(args[1], out resultFile)) { return(false); // invalid file URI. } ConcurrentDictionary <string, ConcurrentDictionary <char, List <AccEntry <int> > > > results; Herald.AnnounceExeReport("AccHistogram", di4B.AccumulationHistogram(out results, _maxDegreeOfParallelism)); Herald.AnnounceExeReport("Export", Exporter.Export(resultFile, results, "chr\tleft\tright\taccumulation\tstrand", mux: _mux)); return(true); }
private bool tmpLoadVCF(string fileName) { if (!ValidateFileName(fileName, out fileName)) { return(false); } _parserSTW.Restart(); VCFParser <Variant, VariantData> vcfParser = new VCFParser <Variant, VariantData>(source: fileName, species: Genomes.HomoSapiens, assembly: Assemblies.hg19); try { Repository.parsedVariants = vcfParser.Parse(); } catch (Exception e) { if (Path.GetDirectoryName(fileName) + Path.DirectorySeparatorChar == _workingDirectory && Path.GetExtension(fileName) == _logFile) { Herald.Announce(Herald.MessageType.Error, string.Format("The requested extension should not have same extension as the log file.")); } else { Herald.Announce(Herald.MessageType.Error, string.Format("{0}", e.Message)); } return(false); } _parserSTW.Stop(); _accumulatedLoadET += _parserSTW.Elapsed.TotalSeconds; Herald.AnnounceExeReport("Loaded", new ExecutionReport(Repository.parsedVariants.intervalsCount, _parserSTW.Elapsed)); return(true); }
public bool Cover(string[] args) { if (args.Length < 6) { Herald.Announce(Herald.MessageType.Error, string.Format("Missing parameter.")); return(false); } char strand; int minAcc, maxAcc; string coverOrSummit = args[0].ToLower(); string resultFile = ""; if (!ExtractResultsFile(args[1], out resultFile)) { return(false); // invalid file URI. } if (!char.TryParse(args[2], out strand)) { Herald.Announce(Herald.MessageType.Error, string.Format("Invalid strand parameter.")); return(false); } if (!int.TryParse(args[3], out minAcc)) { Herald.Announce(Herald.MessageType.Error, string.Format("Invalid minimum accumulation parameter.")); return(false); } if (!int.TryParse(args[4], out maxAcc)) { Herald.Announce(Herald.MessageType.Error, string.Format("Invalid maximum accumulation parameter.")); return(false); } Aggregate agg = Aggregate.Count; if (!String2Aggregate(args[5], out agg)) { return(false); } FunctionOutput <Output <int, Peak, PeakData> > result = null; switch (coverOrSummit) { case "cover": Herald.AnnounceExeReport("Cover", di4B.Cover(CoverVariation.Cover, strand, minAcc, maxAcc, agg, out result, _maxDegreeOfParallelism), Herald.SpeedUnit.bookmarkPerSecond); break; case "summit": Herald.AnnounceExeReport("Summit", di4B.Cover(CoverVariation.Summit, strand, minAcc, maxAcc, agg, out result, _maxDegreeOfParallelism), Herald.SpeedUnit.bookmarkPerSecond); break; } Herald.AnnounceExeReport("Export", Exporter.Export(resultFile, result, "chr\tleft\tright\tcount\tstrand")); return(true); }
public bool Index2ndResolution(string[] args) { if (args.Length < 2) { Herald.Announce(Herald.MessageType.Error, string.Format("Invalid arguments.")); return(false); } int binCount = 0; CuttingMethod cuttingMethod = CuttingMethod.ZeroThresholding; switch (args[1].ToLower()) { case "zt": case "zerothresholding": cuttingMethod = CuttingMethod.ZeroThresholding; break; case "uq": case "uniformscalarquantization": cuttingMethod = CuttingMethod.UniformScalarQuantization; if (args.Length != 3) { Herald.Announce(Herald.MessageType.Error, string.Format("Invalid arguments.")); return(false); } if (!int.TryParse(args[2], out binCount)) { Herald.Announce(Herald.MessageType.Error, string.Format("Invalid arguments.")); return(false); } break; case "nuq": case "nonuniformscalarquantization": cuttingMethod = CuttingMethod.NonUniformScalarQuantization; if (args.Length != 3) { Herald.Announce(Herald.MessageType.Error, string.Format("Invalid arguments.")); return(false); } if (!int.TryParse(args[2], out binCount)) { Herald.Announce(Herald.MessageType.Error, string.Format("Invalid arguments.")); return(false); } break; default: Herald.Announce(Herald.MessageType.Error, string.Format("Invalid arguments.")); return(false); } Herald.AnnounceExeReport("2RIndex", di4B.SecondResolutionIndex(cuttingMethod, binCount, _maxDegreeOfParallelism), speedUnit: Herald.SpeedUnit.blockPerSecond); return(true); }
private void BenchmarkAccHis() { int tries = 20; ConcurrentDictionary <string, ConcurrentDictionary <char, List <AccEntry <int> > > > results; for (int i = 0; i < tries; i++) { Herald.AnnounceExeReport("Run_" + i, di4B.AccumulationHistogram(out results, _maxDegreeOfParallelism)); } }
private bool Index(string[] args) { if (args.Length != 2) { Herald.Announce(Herald.MessageType.Error, string.Format("Missing arguments.")); return(false); } if (Path.GetExtension(args[1]) == ".vcf") { if (!tmpLoadVCF(args[1])) { return(false); } var tmp = new Dictionary <string, Dictionary <char, List <Peak> > >(); foreach (var chr in Repository.parsedVariants.intervals) { tmp.Add(chr.Key, new Dictionary <char, List <Peak> >()); foreach (var strand in chr.Value) { tmp[chr.Key].Add(strand.Key, new List <Peak>()); foreach (var peak in strand.Value) { tmp[chr.Key][strand.Key].Add(new Peak() { left = peak.left, right = peak.right, hashKey = peak.hashKey }); } } } var report = di4B.Add(Repository.parsedVariants.fileHashKey, tmp, _indexingMode, _maxDegreeOfParallelism); Herald.AnnounceExeReport("Indexed", report); _tN2i += report.count; } else { if (!Load(args[1])) { return(false); } var report = di4B.Add(Repository.parsedSample.fileHashKey, Repository.parsedSample.intervals, _indexingMode, _maxDegreeOfParallelism); Herald.AnnounceExeReport("Indexed", report); _tN2i += report.count; } return(true); }
private bool Load(string fileName) { if (!ValidateFileName(fileName, out fileName)) { return(false); } _parserSTW.Restart(); BEDParser <Peak, PeakData> bedParser = new BEDParser <Peak, PeakData>( source: fileName, species: Genomes.HomoSapiens, assembly: Assemblies.hg19, readOnlyValidChrs: true, startOffset: 0, chrColumn: UserConfig.ParserParameters.chrColumn, leftEndColumn: UserConfig.ParserParameters.leftEndColumn, rightEndColumn: UserConfig.ParserParameters.rightEndColumn, summitColumn: -1, nameColumn: UserConfig.ParserParameters.nameColumn, valueColumn: UserConfig.ParserParameters.valueColumn, strandColumn: -1, defaultValue: 0.01, pValueFormat: pValueFormat.minus10_Log10_pValue, dropPeakIfInvalidValue: false, hashFunction: HashFunction.FNV); try { Repository.parsedSample = bedParser.Parse(); } catch (Exception e) { if (Path.GetDirectoryName(fileName) + Path.DirectorySeparatorChar == _workingDirectory && Path.GetExtension(fileName) == _logFile) { Herald.Announce(Herald.MessageType.Error, string.Format("The requested extension should not have same extension as the log file.")); } else { Herald.Announce(Herald.MessageType.Error, string.Format("{0}", e.Message)); } return(false); } _parserSTW.Stop(); _accumulatedLoadET += _parserSTW.Elapsed.TotalSeconds; Herald.AnnounceExeReport("Loaded", new ExecutionReport(Repository.parsedSample.intervalsCount, _parserSTW.Elapsed)); return(true); }
private bool Dichotomies(string[] args) { if (args.Length != 2) { Herald.Announce(Herald.MessageType.Error, string.Format("Invalid arguments.")); return(false); } string resultFile = ""; if (!ExtractResultsFile(args[1], out resultFile)) { return(false); // invalid file URI. } ConcurrentDictionary <string, ConcurrentDictionary <char, ICollection <BlockKey <int> > > > results = null; Herald.AnnounceExeReport("Dichotomies", di4B.Dichotomies(out results, _maxDegreeOfParallelism)); Herald.AnnounceExeReport("Export", Exporter.Export(resultFile, results)); return(true); }
private bool ReportStats(string[] args) { if (args.Length != 2) { Herald.Announce(Herald.MessageType.Error, string.Format("Invalid arguments.")); return(false); } string resultFile = ""; if (!ExtractResultsFile(args[1], out resultFile)) { return(false); // invalid file URI. } SortedDictionary <string, SortedDictionary <char, Stats> > results = null; Herald.AnnounceExeReport("Statistics", di4B.Statistics(out results)); Herald.AnnounceExeReport("Export", Exporter.Export(resultFile, results)); return(true); }
private bool BlockInfoDis(string[] args) { if (args.Length != 2) { Herald.Announce(Herald.MessageType.Error, string.Format("Invalid arguments.")); return(false); } string resultFile = ""; if (!ExtractResultsFile(args[1], out resultFile)) { return(false); // invalid file URI. } BlockInfoDis results = null; Herald.AnnounceExeReport("BlockInfo", di4B.BlocksInfoDistribution(out results, _maxDegreeOfParallelism)); Herald.AnnounceExeReport("Export", Exporter.Export(resultFile, results)); return(true); }
private bool Map(string[] args) { if (args.Length != 5) { Herald.Announce(Herald.MessageType.Error, string.Format("Invalid arguments.")); return(false); } string resultFile = ""; if (!ExtractResultsFile(args[2], out resultFile)) { return(false); // invalid file URI. } char strand = '*'; if (!char.TryParse(args[3], out strand)) { Herald.Announce(Herald.MessageType.Error, string.Format("Invalid strand argument [{0}].", args[3])); return(false); } Aggregate agg = Aggregate.Count; if (!String2Aggregate(args[4], out agg)) { return(false); } if (!Load(args[1])) { return(false); } FunctionOutput <Output <int, Peak, PeakData> > result; Herald.AnnounceExeReport("Map", di4B.Map(strand, Repository.parsedSample.intervals, agg, out result, _maxDegreeOfParallelism)); Herald.AnnounceExeReport("Export", Exporter.Export(resultFile, result, "chr\tleft\tright\tcount\tstrand")); return(true); }
private bool AccumulationDistribution(string[] args) { if (args.Length != 2) { Herald.Announce(Herald.MessageType.Error, string.Format("Invalid arguments.")); return(false); } string resultFile = ""; if (!ExtractResultsFile(args[1], out resultFile)) { return(false); // invalid file URI. } ConcurrentDictionary <string, ConcurrentDictionary <char, SortedDictionary <int, int> > > results; SortedDictionary <int, int> mergedResults; Herald.AnnounceExeReport("AccDistribution", di4B.AccumulationDistribution(out results, out mergedResults, _maxDegreeOfParallelism)); Herald.AnnounceExeReport("Export", Exporter.Export(resultFile, results, mergedResults, "chr\tstrand\taccumulation\tcount")); return(true); }
private void BenchmarkCover() { int tries = 10; var agg = Aggregate.Count; FunctionOutput <Output <int, Peak, PeakData> > result = null; var combinations = new List <int[]> { new int[] { 1, 2 }, new int[] { 5, 10 }, new int[] { 10, 20 }, new int[] { 50, 60 }, new int[] { 80, 90 }, new int[] { 100, 200 }, new int[] { 200, 220 }, new int[] { 300, 320 }, new int[] { 400, 500 }, new int[] { 550, 1000 }, new int[] { 1, 1 }, new int[] { 10, 10 }, new int[] { 25, 25 }, new int[] { 50, 50 }, new int[] { 60, 60 }, new int[] { 80, 80 }, new int[] { 100, 100 }, new int[] { 150, 150 }, new int[] { 200, 200 }, new int[] { 500, 500 }, }; foreach (var c in combinations) { for (int i = 0; i < tries; i++) { Herald.AnnounceExeReport(c[0] + "," + c[1], di4B.Cover(CoverVariation.Cover, '*', c[0], c[1], agg, out result, _maxDegreeOfParallelism), Herald.SpeedUnit.bookmarkPerSecond); } } }
private bool VariantAnalysis(string[] args) { if (args.Length != 3) { Herald.Announce(Herald.MessageType.Error, string.Format("Invalid arguments.")); return(false); } string resultFile = ""; if (!ExtractResultsFile(args[2], out resultFile)) { return(false); // invalid file URI. } if (!tmpLoadVCF(args[1])) { return(false); } var tmp = new Dictionary <string, Dictionary <char, List <Peak> > >(); foreach (var chr in Repository.parsedVariants.intervals) { tmp.Add(chr.Key, new Dictionary <char, List <Peak> >()); foreach (var s in chr.Value) { tmp[chr.Key].Add(s.Key, new List <Peak>()); foreach (var peak in s.Value) { tmp[chr.Key][s.Key].Add(new Peak() { left = peak.left, right = peak.right, hashKey = peak.hashKey }); } } } FunctionOutput <Output <int, Peak, PeakData> > result; Dictionary <uint, int> newRes = new Dictionary <uint, int>(); Herald.AnnounceExeReport("Variant Analysis", di4B.VariantAnalysis('*', tmp, Aggregate.Count, out result, _maxDegreeOfParallelism, out newRes)); Herald.AnnounceExeReport("Export", Exporter.Export(resultFile, result, "chr\tleft\tright\tcount\tstrand")); var sortedRes = newRes.ToList(); sortedRes.Sort( delegate(KeyValuePair <uint, int> i, KeyValuePair <uint, int> j) { return(j.Value.CompareTo(i.Value)); }); using (StreamWriter writer = new StreamWriter(resultFile)) { writer.WriteLine("Sampled_ID\tVariations_in_common_with_reference"); foreach (var item in sortedRes) { writer.WriteLine("{0}\t{1}", item.Key, item.Value); } } return(true); }
private bool Index2ndPass() { Herald.AnnounceExeReport("2ndPass", di4B.Add2ndPass(_maxDegreeOfParallelism), speedUnit: Herald.SpeedUnit.bookmarkPerSecond); return(true); }