private static List <CalledAllele> UpdateMultiAllelicQScores(List <CalledAllele> variantList, RecalibrationResults results)
{
// Determine model types
RecalibrationResult model1 = GetModelFromType(variantList[0], results);
RecalibrationResult model2 = GetModelFromType(variantList[1], results);
// Calculate posteriors based on multinomial distribution
int dp = variantList[0].TotalCoverage;
int[] ad = new int[3];
ad[2] = variantList[0].AlleleSupport; //temp[1];
ad[1] = variantList[1].AlleleSupport; //temp[0];
ad[0] = dp - ad[1] - ad[2];
if (ad[0] < 0)
{
ad[0] = 0;
dp = ad[1] + ad[2];
}
var mixtureModelResult = MixtureModel.GetMultinomialQScores(ad, dp,
new List <double[]> {
model1.Means, model2.Means
});
// Update variant genotypes fields
variantList[0].GenotypePosteriors = mixtureModelResult.GenotypePosteriors;
variantList[1].GenotypePosteriors = mixtureModelResult.GenotypePosteriors;
variantList[0].GenotypeQscore = mixtureModelResult.QScore;
variantList[1].GenotypeQscore = mixtureModelResult.QScore;
return(variantList);
}
public void TestMixtureModelOnChr1()
{
string file = Path.Combine(TestPaths.LocalTestDataDirectory, "Chr1.csv");
SparseArray <int> AD = new SparseArray <int>();
SparseArray <int> DP = new SparseArray <int>();
using (StreamReader sr = new StreamReader(new FileStream(file, FileMode.Open)))
{
var counter = 0;
while (counter < 20000)
{
string line = sr.ReadLine();
string[] arr = line.Split(',');
int dp = int.Parse(arr[arr.Length - 1]);
DP.Add(dp);
if (arr.Length == 2)
{
AD.Add(dp - int.Parse(arr[0]));
}
else
{
AD.Add(int.Parse(arr[arr.Length - 2]));
}
counter++;
}
}
MixtureModel model = MixtureModel.FitMixtureModel(AD, DP);
Assert.Equal(0.000656, model.Means[0], 3);
Assert.Equal(0.366, model.Means[1], 3);
Assert.Equal(0.998, model.Means[2], 3);
}
private static MixtureModelResult GetModelResult(CalledAllele allele, RecalibrationResult result)
{
var recal = new RecalibratedVariantsCollection();
recal.AddLocus(allele);
return(MixtureModel.UsePrefitModel(recal.Ad, recal.Dp, result.Means, result.Priors).PrimaryResult);
}
public void TestMixtureModelOnThreeCoins()
{
string file = Path.Combine(TestPaths.LocalTestDataDirectory, "ThreeCoins.csv");
List <int> k = new List <int>();
List <int> n = new List <int>();
using (StreamReader sr = new StreamReader(new FileStream(file, FileMode.Open)))
{
while (true)
{
string line = sr.ReadLine();
if (line == null)
{
break;
}
string[] arr = line.Split(',');
k.Add(int.Parse(arr[0]));
n.Add(int.Parse(arr[1]));
}
}
MixtureModel model;
model = MixtureModel.FitMixtureModel(k, n,
new double[] { 0.5686903, 0.3308862, 0.4617437 });
Assert.True(Math.Abs(model.Means[0] - 0.2335885) < 0.001);
Assert.True(Math.Abs(model.Means[1] - 0.4100772) < 0.001);
Assert.True(Math.Abs(model.Means[2] - 0.5074295) < 0.001);
}
public void AddMixtureModelResults(MixtureModel model)
{
if (Dp.Count != model.Clustering.Count)
{
throw new MixtureModelException("Model does not come from same data source.");
}
Categories = model.Clustering;
Gp = model.PhredPosteriors;
QScores = model.QScores;
}
private static List <MixtureModel> ApplyModels(string vcfIn, string modelFile, List <RecalibratedVariantsCollection> variants)
{
List <MixtureModelParameters> modelParams = MixtureModel.ReadModelsFile(modelFile);
var models = new List <MixtureModel>();
Logger.WriteToLog("Applying models");
for (int i = 0; i < variants.Count; i++)
{
models.Add(MixtureModel.UsePrefitModel(variants[i].Ad, variants[i].Dp, modelParams[i].Means, modelParams[i].Priors));
}
return(models);
}
public void MalformedDataTest()
{
SparseArray <int> alleleDepth = new SparseArray <int>();
SparseArray <int> totalDepth = new SparseArray <int>();
for (int i = 0; i < 10; i++)
{
alleleDepth.Add(0);
totalDepth.Add(10);
}
Assert.Throws <MixtureModelException>(() => MixtureModel.FitMixtureModel(alleleDepth, totalDepth));
}
public void RecalibratedVariantModelAndIndexerTests()
{
var modelsFile = Path.Combine(TestPaths.LocalTestDataDirectory, "example.model");
List <MixtureModelParameters> models = MixtureModel.ReadModelsFile(modelsFile);
var mm = MixtureModel.UsePrefitModel(RecalCollection.Ad, RecalCollection.Dp, models[0].Means, models[0].Priors);
RecalCollection.AddMixtureModelResults(mm);
Assert.Equal(14, RecalCollection.Categories.Count);
Assert.Equal(14, RecalCollection.QScores.Count);
RecalibratedVariant variant1 = RecalCollection["chr1:115252176"];
Assert.Equal(SimplifiedDiploidGenotype.HeterozygousAltRef, variant1.MixtureModelResult.GenotypeCategory);
RecalibratedVariant variant2 = RecalCollection["chr1:115252177"];
Assert.Equal(SimplifiedDiploidGenotype.HomozygousAlt, variant2.MixtureModelResult.GenotypeCategory);
}
private static List <MixtureModel> GetNewModels(string vcfIn, string outDir, List <RecalibratedVariantsCollection> variants)
{
var models = new List <MixtureModel>();
// Perform fitting for SNVs
Logger.WriteToLog("Finding thresholds for SNVs.");
MixtureModel snvModel = MixtureModel.FitMixtureModel(variants[0].Ad, variants[0].Dp);
models.Add(snvModel);
// Perform fitting for indels
Logger.WriteToLog("Finding thresholds for indels.");
MixtureModel indelModel = MixtureModel.FitMixtureModel(variants[1].Ad, variants[1].Dp);
models.Add(indelModel);
MixtureModel.WriteModelFile(outDir, Path.GetFileName(vcfIn).Replace(".vcf", ".model"), models);
return(models);
}
public void OutOfOrderStartingMeansTest()
{
string file = Path.Combine(TestPaths.LocalTestDataDirectory, "Chr1.csv");
SparseArray <int> AD = new SparseArray <int>();
SparseArray <int> DP = new SparseArray <int>();
using (StreamReader sr = new StreamReader(new FileStream(file, FileMode.Open)))
{
int counter = 0;
while (true)
{
string line = sr.ReadLine();
if (line == null || counter > 100000)
{
break;
}
string[] arr = line.Split(',');
int dp = int.Parse(arr[arr.Length - 1]);
DP.Add(dp);
if (arr.Length == 2)
{
AD.Add(dp - int.Parse(arr[0]));
}
else
{
AD.Add(int.Parse(arr[arr.Length - 2]));
}
counter++;
}
}
var model1 = MixtureModel.FitMixtureModel(AD, DP, new double[] { 0.01, 0.45, 0.99 });
var model2 = MixtureModel.FitMixtureModel(AD, DP, new double[] { 0.45, 0.01, 0.99 });
for (int i = 0; i < model1.Means.Length; i++)
{
Assert.Equal(model1.Means[i], model2.Means[i], 4);
Assert.Equal(model1.MixtureWeights[i], model2.MixtureWeights[i], 4);
}
}
private static AdaptiveGenotypingParameters UpdateAdaptiveGenotypingParameters(AdaptiveGenotypingParameters parameters, string inputModelFilePath)
{
if (File.Exists(inputModelFilePath))
{
var newModels = MixtureModel.ReadModelsFile(inputModelFilePath);
parameters.SnvModel = newModels[0].Means;
parameters.SnvPrior = newModels[0].Priors;
parameters.IndelModel = newModels[1].Means;
parameters.IndelPrior = newModels[1].Priors;
}
else
{
throw new ArgumentException("No AdaptiveGT model file found at " + inputModelFilePath);
}
return(parameters);
}
public AdaptiveGtWriterTests()
{
List <MixtureModelParameters> modelParameters = MixtureModel.ReadModelsFile(
Path.Combine(TestPaths.LocalTestDataDirectory, "example.model"));
DefaultResults = new RecalibrationResults
{
SnvResults = new RecalibrationResult
{
Means = modelParameters[0].Means,
Priors = modelParameters[0].Priors,
Variants = new RecalibratedVariantsCollection()
},
IndelResults = new RecalibrationResult
{
Means = modelParameters[1].Means,
Priors = modelParameters[1].Priors,
Variants = new RecalibratedVariantsCollection()
}
};
}
private static List <MixtureModelParameters> ReadAdaptiveGenotypingParametersFromFile(string value)
{
var ListOfMixtureModels = MixtureModel.ReadModelsFile(value);
return(ListOfMixtureModels);
}
