public StrandBiasFileWriter CreateStrandBiasFileWriter(string outputVcfPath)
{
var writer = new StrandBiasFileWriter(outputVcfPath);
writer.WriteHeader();
return(writer);
}
public static void CallStrandedVariantsWithMockData(string vcfOutputPath, ApplicationOptions options, AmpliconTestFactory testFactory)
{
var appFactory = new MockFactoryWithDefaults(options);
using (var vcfWriter = appFactory.CreateVcfWriter(vcfOutputPath, new VcfWriterInputContext()))
{
using (var biasWriter = new StrandBiasFileWriter(vcfOutputPath))
{
var svc = CreateMockVariantCaller(vcfWriter, options, testFactory.ChrInfo, testFactory.AlignmentExtractor, biasWriter);
vcfWriter.WriteHeader();
biasWriter.WriteHeader();
svc.Execute();
biasWriter.Dispose();
}
}
Assert.True(File.Exists(vcfOutputPath));
}
public void Write()
{
var outputFile = Path.Combine(UnitTestPaths.TestDataDirectory, "StrandBiasWriterTests.txt");
File.Delete(outputFile);
var chromosome = "chr1";
var reference = "TTT";
var alternate = "T";
var position = 123;
var BaseCalledAlleles = new List <CalledAllele>();
var variant = new CalledAllele(AlleleCategory.Deletion)
{
Chromosome = chromosome,
Reference = reference,
Alternate = alternate,
Coordinate = position,
StrandBiasResults = new StrandBiasResults()
{
BiasAcceptable = true,
BiasScore = 1,
CovPresentOnBothStrands = true,
ForwardStats = StrandBiasCalculator.CreateStats(10, 100, .1, .1, StrandBiasModel.Poisson),
GATKBiasScore = .2,
OverallStats = StrandBiasCalculator.CreateStats(20, 200, .2, .2, StrandBiasModel.Poisson),
ReverseStats = StrandBiasCalculator.CreateStats(30, 300, .3, .3, StrandBiasModel.Poisson),
StitchedStats = StrandBiasCalculator.CreateStats(40, 400, .4, .4, StrandBiasModel.Poisson),
TestAcceptable = true,
TestScore = .5,
VarPresentOnBothStrands = true,
}
};
BaseCalledAlleles.Add(variant);
var writer = new StrandBiasFileWriter(outputFile);
writer.WriteHeader();
writer.Write(BaseCalledAlleles);
writer.Dispose();
var biasFileContents = File.ReadAllLines(outputFile);
Assert.True(biasFileContents.Length == 2);
var header = biasFileContents.First().Split('\t');
var data = biasFileContents.Skip(1).First().Split('\t');
var dict = header.Select((a, i) => new { key = a, data = data[i] })
.ToDictionary(b => b.key, c => c.data);
// Make sure well-formed and populated with the right data
Assert.Equal(chromosome, dict["Chr"]);
Assert.Equal(position.ToString(), dict["Position"]);
Assert.Equal(reference, dict["Reference"]);
Assert.Equal(alternate, dict["Alternate"]);
Assert.Equal(variant.StrandBiasResults.OverallStats.ChanceFalsePos.ToString(), dict["Overall_ChanceFalsePos"]);
Assert.Equal(variant.StrandBiasResults.ForwardStats.ChanceFalsePos.ToString(), dict["Forward_ChanceFalsePos"]);
Assert.Equal(variant.StrandBiasResults.ReverseStats.ChanceFalsePos.ToString(), dict["Reverse_ChanceFalsePos"]);
Assert.Equal(variant.StrandBiasResults.OverallStats.ChanceFalseNeg.ToString(), dict["Overall_ChanceFalseNeg"]);
Assert.Equal(variant.StrandBiasResults.ForwardStats.ChanceFalseNeg.ToString(), dict["Forward_ChanceFalseNeg"]);
Assert.Equal(variant.StrandBiasResults.ReverseStats.ChanceFalseNeg.ToString(), dict["Reverse_ChanceFalseNeg"]);
Assert.Equal(variant.StrandBiasResults.OverallStats.Frequency.ToString(), dict["Overall_Freq"]);
Assert.Equal(variant.StrandBiasResults.ForwardStats.Frequency.ToString(), dict["Forward_Freq"]);
Assert.Equal(variant.StrandBiasResults.ReverseStats.Frequency.ToString(), dict["Reverse_Freq"]);
Assert.Equal(variant.StrandBiasResults.OverallStats.Support.ToString(), dict["Overall_Support"]);
Assert.Equal(variant.StrandBiasResults.ForwardStats.Support.ToString(), dict["Forward_Support"]);
Assert.Equal(variant.StrandBiasResults.ReverseStats.Support.ToString(), dict["Reverse_Support"]);
Assert.Equal(variant.StrandBiasResults.OverallStats.Coverage.ToString(), dict["Overall_Coverage"]);
Assert.Equal(variant.StrandBiasResults.ForwardStats.Coverage.ToString(), dict["Forward_Coverage"]);
Assert.Equal(variant.StrandBiasResults.ReverseStats.Coverage.ToString(), dict["Reverse_Coverage"]);
Assert.Equal(variant.StrandBiasResults.BiasAcceptable.ToString(), dict["BiasAcceptable?"]);
Assert.Equal(variant.StrandBiasResults.VarPresentOnBothStrands.ToString(), dict["VarPresentOnBothStrands?"]);
Assert.Equal(variant.StrandBiasResults.CovPresentOnBothStrands.ToString(), dict["CoverageAvailableOnBothStrands?"]);
//TODO RawCoverage/RawSupport tests
Assert.Throws <Exception>(() => writer.WriteHeader());
Assert.Throws <Exception>(() => writer.Write(BaseCalledAlleles));
writer.Dispose();
}
public void TestForStrandBiasOnStitchingScenarios(StitchingScenario scenario, string resultFile)
{
//limit the scope of concern for now.
if (scenario.ShouldRefStitch != true)
{
return;
}
//limit the scope of concern for now.
if (scenario.ShouldStitch != true)
{
return;
}
var resultsSummary = Path.Combine(Options.OutputFolder, StrandBiasSummaryFileName);
using (StreamWriter sw = new StreamWriter(resultsSummary, true))
{
var sb = new StringBuilder(
string.Join(",", DateTime.Today.ToShortDateString(),
DateTime.Now.ToLongTimeString(),
scenario.Category, scenario.Id));
try
{
if (!Directory.Exists(Options.OutputFolder))
{
Directory.CreateDirectory(Options.OutputFolder);
}
var factory = new AmpliconTestFactory(new string('A', 100), sourceIsStitched: true);
byte qualityForAll = 30;
int numVariantCounts = 2; // 10;
int numReferenceCounts = 2; // 90;
var varRead = BuildRead(scenario.OutputRead1, qualityForAll, StageMNVdata(scenario));
var refRead = BuildRead(scenario.OutputRefRead1, qualityForAll, NoMNVdata(scenario));
if (refRead == null)
{
return;
}
factory.StageStitchedVariant(
varRead, numVariantCounts,
refRead, numReferenceCounts);
var outputFileName = string.Format("{0}_{1}.vcf", scenario.Category, scenario.Id);
var vcfOutputPath = Path.Combine(Options.OutputFolder, outputFileName);
var biasOutputPath = StrandBiasFileWriter.GetBiasFilePath(vcfOutputPath);
File.Delete(vcfOutputPath);
File.Delete(biasOutputPath);
StitchedReadBiasHelper.CallStrandedVariantsWithMockData(vcfOutputPath, Options, factory);
var varResults = StitchedReadBiasHelper.GetResults(VcfReader.GetAllVariantsInFile(vcfOutputPath));
var biasResults = StitchedReadBiasHelper.GetStrandResultsFromFile(biasOutputPath);
var observedFrequency = (varResults.Count == 0) ? "0": "";
var observedSB = (biasResults.Count == 0) ? "FN": "";
for (int i = 0; i < varResults.Count; i++)
{
var varResult = varResults[i];
if (i != 0)
{
observedFrequency += ";";
}
observedFrequency += varResult.VariantFrequency;
}
for (int i = 0; i < biasResults.Count; i++)
{
var biasResult = biasResults[i];
if (i != 0)
{
observedSB += ";";
}
observedSB += biasResult.HasStrandBias;
//there should be no SB on our current set of stitched scenarios.
Assert.True(!biasResult.HasStrandBias);
}
var expectedValues = new List <string>()
{
"1", scenario.Frequency, scenario.ShouldBias
};
var observedValues = new List <string>()
{
varResults.Count.ToString(), observedFrequency, observedSB
};
sb.Append(GetResultString(expectedValues, observedValues));
sw.WriteLine(sb.ToString());
}
catch (Exception ex)
{
sb.Append(",Fail: " + ex);
sw.WriteLine(sb.ToString());
}
}
}
protected override void Initialize()
{
if (ShouldThrottle)
{
// one writer per bam
foreach (var workRequest in WorkRequests)
{
var vcfWriter = _factory.CreateVcfWriter(workRequest.OutputFilePath, new VcfWriterInputContext
{
ReferenceName = Genome.Directory,
QuotedCommandLineString = _factory.GetCommandLine(),
SampleName = Path.GetFileName(workRequest.BamFilePath),
ContigsByChr = Genome.ChromosomeLengths
});
if (_writeHeader)
{
vcfWriter.WriteHeader();
}
StrandBiasFileWriter sbBiasFileWriter = null;
AmpliconBiasFileWriter abBiasFileWriter = null;
if (_factory.Options.OutputBiasFiles)
{
sbBiasFileWriter = _factory.CreateStrandBiasFileWriter(workRequest.OutputFilePath);
abBiasFileWriter = _factory.CreateAmpliconBiasFileWriter(workRequest.OutputFilePath);
}
// use same writer across all chr. we will never be writing multiple chrs for a given bam at the same time
foreach (var chrName in Genome.ChromosomesToProcess)
{
var writerKey = GetChrOutputPath(workRequest, chrName);
_writerByChrLookup[writerKey] = vcfWriter;
_sbBiasWriterByChrLookup[writerKey] = sbBiasFileWriter;
_abBiasWriterByChrLookup[writerKey] = abBiasFileWriter;
}
_writers.Add(vcfWriter);
if (sbBiasFileWriter != null)
{
_sbBiasWriters.Add(sbBiasFileWriter);
}
if (abBiasFileWriter != null)
{
_abBiasWriters.Add(abBiasFileWriter);
}
}
}
else
{
// one writer per bam and per chr
// files will get stitched together later
foreach (var workRequest in WorkRequests)
{
foreach (var chrName in Genome.ChromosomesToProcess)
{
var outputPath = GetChrOutputPath(workRequest, chrName);
var vcfWriter = _factory.CreateVcfWriter(outputPath, new VcfWriterInputContext
{
ReferenceName = Genome.Directory,
QuotedCommandLineString = _factory.GetCommandLine(),
SampleName = Path.GetFileName(workRequest.BamFilePath),
ContigsByChr = Genome.ChromosomeLengths
});
StrandBiasFileWriter sbBiasFileWriter = null;
AmpliconBiasFileWriter abBiasFileWriter = null;
if (_factory.Options.OutputBiasFiles)
{
sbBiasFileWriter = _factory.CreateStrandBiasFileWriter(outputPath);
abBiasFileWriter = _factory.CreateAmpliconBiasFileWriter(outputPath);
}
var writerKey = outputPath;
_writerByChrLookup[writerKey] = vcfWriter;
_sbBiasWriterByChrLookup[writerKey] = sbBiasFileWriter;
_abBiasWriterByChrLookup[writerKey] = abBiasFileWriter;
_writers.Add(vcfWriter);
if (sbBiasFileWriter != null)
{
_sbBiasWriters.Add(sbBiasFileWriter);
}
if (abBiasFileWriter != null)
{
_abBiasWriters.Add(abBiasFileWriter);
}
}
}
}
}
