public async Task <VariableStatistics> GetVariableStatistics(string systemName, SessionDetails sessionDetails)
{
IFastStatsSystemsApi systemApi = connectorFactory.CreateFastStatsSystemsApi(sessionDetails);
PagedResultsVariable variables = await systemApi.FastStatsSystemsGetFastStatsVariablesAsync(dataViewName, systemName, null, null, null, 1000000);
VariableStatistics variableStatistics = new VariableStatistics();
variableStatistics.SystemName = systemName;
List <double> numberOfCodesList = new List <double>();
List <double> totalCodeSizeList = new List <double>();
foreach (Variable variable in variables.List)
{
variableStatistics.NumberOfVariables++;
if (variable.SelectorInfo != null)
{
int numberOfCodes = variable.SelectorInfo.NumberOfCodes ?? 0;
variableStatistics.NumberOfSelectors++;
numberOfCodesList.Add(numberOfCodes);
totalCodeSizeList.Add(numberOfCodes * variable.SelectorInfo.CodeLength ?? 0);
}
}
variableStatistics.TotalNumberOfVarCodes = (int)numberOfCodesList.Sum();
variableStatistics.MedianCodesPerVariable = DistributionUtilities.GetMedian(numberOfCodesList);
variableStatistics.TotalCodeSize = (long)totalCodeSizeList.Sum();
variableStatistics.MedianCodeSizePerVariable = DistributionUtilities.GetMedian(totalCodeSizeList);
return(variableStatistics);
}
/// <summary>
///
/// </summary>
/// <param name="numCnStates">number of CN states considered by the model</param>
/// <param name="maxCoverage">mean depth coverage</param>
/// <param name="meanCoverage">max depth coverage</param>
/// <param name="diploidAlleleMeanCounts">mean diploid allele counts</param>
/// <returns></returns>
public ICopyNumberModel CreateModel(int numCnStates, int maxCoverage, double meanCoverage, double diploidAlleleMeanCounts)
{
var cnDistribution = new List <List <double> >();
double haploidAlleleMeanCounts = diploidAlleleMeanCounts / 2.0;
double haploidMean = meanCoverage / 2.0;
double mafVariance = diploidAlleleMeanCounts * 2.5;
double variance = meanCoverage * 2.5;
const double alleleStateZeroCorrector = 0.1; // prevent from using zero as a mean of model distribution
for (int copyNumber = 0; copyNumber < numCnStates; copyNumber++)
{
var multiplier = copyNumber * 1.0;
// allow for low bin counts for CN=0, i.e. due to imprecise breakpoints
if (copyNumber == 0)
{
multiplier = 0.1;
}
cnDistribution.Add(DistributionUtilities.NegativeBinomialWrapper(haploidMean * multiplier, variance,
maxCoverage, adjustClumpingParameter: true));
}
var alleleDistribution = new Tuple <List <double>, List <double> > [numCnStates][];
for (int i = 0; i < numCnStates; i++)
{
alleleDistribution[i] = new Tuple <List <double>, List <double> > [numCnStates];
}
for (int gt1 = 0; gt1 < numCnStates; gt1++)
{
for (int gt2 = 0; gt2 < numCnStates; gt2++)
{
var gt1Probabilities =
DistributionUtilities.NegativeBinomialWrapper(haploidAlleleMeanCounts * Math.Max(gt1, alleleStateZeroCorrector),
mafVariance, maxCoverage);
var gt2Probabilities =
DistributionUtilities.NegativeBinomialWrapper(haploidAlleleMeanCounts * Math.Max(gt2, alleleStateZeroCorrector),
mafVariance, maxCoverage);
alleleDistribution[gt1][gt2] =
new Tuple <List <double>, List <double> >(gt1Probabilities, gt2Probabilities);
}
}
// meanMafCoverage * 3 will cap the coverage at 6 CN, which corresponds to 0-5 CN range captured by the model
// this will prevent a read stacking scenario with high depth (i.e. > 1000) returning likelihoods of 0 for all models
int coverageCeiling = Convert.ToInt32(diploidAlleleMeanCounts * 3);
// also compute distributions for total reads as a function of total copy number,
// so we can compute likelihoods for homozygous and hemizygous loci
int maxTotalAlleleCoverage = 2 * maxCoverage;
int numTotalCnStates = 2 * numCnStates;
var alleleReadDepthDistribution = new List <double> [numTotalCnStates];
for (int gt1 = 0; gt1 < numTotalCnStates; gt1++)
{
alleleReadDepthDistribution[gt1] = DistributionUtilities.NegativeBinomialWrapper(haploidAlleleMeanCounts * gt1,
mafVariance, maxTotalAlleleCoverage);
}
return(new HaplotypeCopyNumberModel(cnDistribution, alleleDistribution, coverageCeiling, alleleReadDepthDistribution, maxTotalAlleleCoverage));
}
public CopyNumberModel(int numCnStates, double haploidMean, double haploidMafMean, double variance, double mafVariance, int maxValue)
{
for (int copyNumber = 0; copyNumber < numCnStates; copyNumber++)
{
var multiplier = 1.0;
if (copyNumber == 1)
{
multiplier = 0.9;
}
if (copyNumber == 3)
{
multiplier = 1.1;
}
CnDistribution.Add(DistributionUtilities.NegativeBinomialWrapper(haploidMean * copyNumber * multiplier, variance, maxValue, adjustR: true));
}
_alleleDistribution = new Tuple <List <double>, List <double> > [numCnStates][];
for (int i = 0; i < numCnStates; i++)
{
_alleleDistribution[i] = new Tuple <List <double>, List <double> > [numCnStates];
}
for (int gt1 = 0; gt1 < numCnStates; gt1++)
{
for (int gt2 = 0; gt2 < numCnStates; gt2++)
{
var gt1Probabilities = DistributionUtilities.NegativeBinomialWrapper(haploidMafMean * gt1, mafVariance, maxValue);
var gt2Probabilities = DistributionUtilities.NegativeBinomialWrapper(haploidMafMean * gt2, mafVariance, maxValue);
_alleleDistribution[gt1][gt2] = new Tuple <List <double>, List <double> >(gt1Probabilities, gt2Probabilities);
}
}
}
public MultivariateNegativeBinomial(List <double> means, List <double> variances, int maxValue)
{
_negativeBinomials = new List <List <double> >();
for (int i = 0; i < means.Count; i++)
{
_negativeBinomials.Add(DistributionUtilities.NegativeBinomialWrapper(means[i], variances[i], maxValue));
}
Means = means;
Variances = variances;
}
public void TestNegativeBinomialWrapperMaxDensityEqualsMean()
{
const double mean = 50.0;
const double variance = 50.0;
const int maxValue = 200;
var result = DistributionUtilities.NegativeBinomialWrapper(mean, variance, maxValue);
double medianIndex = 49;
int maxIndex = result.IndexOf(result.Max());
Assert.Equal(medianIndex, maxIndex);
}
public void TestGetGenotypeCombinationsSingleSample()
{
int numSamples = 1;
int altCN = 1;
var result = DistributionUtilities.GetGenotypeCombinations(numSamples, altCN);
Assert.Equal(new[]
{
new [] { 1 }.ToList(),
}.ToList(), result);
}
public void UpdateNegativeBinomial(double[] gamma, List <List <double> > data, List <double> variance, int maxValue)
{
var m = this.GetDimensions();
for (int dimension = 0; dimension < m; dimension++)
{
var newMeans = CanvasCommon.Utilities.WeightedMean(data.Select(x => x[dimension]).ToList(),
gamma.ToList());
Means[dimension] = newMeans;
NegativeBinomials[dimension] = DistributionUtilities.NegativeBinomialWrapper(newMeans, variance[dimension], maxValue);
}
}
public NegativeBinomialMixture(List <MultivariateNegativeBinomial> negativeBinomialDistributions, List <double> haploidMeans, bool useAllStates = false)
{
_negativeBinomialDistributions = negativeBinomialDistributions;
GenotypePermutations = new Dictionary <int, List <List <int> > >();
for (int cnState = 0; cnState < negativeBinomialDistributions.Count; cnState++)
{
int nDimensions = _negativeBinomialDistributions[cnState].GetDimensions();
GenotypePermutations[cnState] = DistributionUtilities.GetGenotypeCombinations(nDimensions, cnState);
}
_useAllStates = useAllStates;
}
public void TestGetGenotypeCombinations()
{
int numSamples = 2;
int altCN = 1;
var result = DistributionUtilities.GetGenotypeCombinations(numSamples, altCN);
Assert.Equal(new List <List <int> >
{
new [] { 1, 1 }.ToList(),
new [] { 1, 2 }.ToList(),
new [] { 2, 1 }.ToList(),
}, result);
}
public PoissonMixture(List <MultivariatePoissonDistribution> poissonDistributions, List <double> haploidMeans)
{
_poissonDistributions = poissonDistributions;
GenotypePermutations = new Dictionary <int, List <List <int> > >();
for (int cnState = 0; cnState < _poissonDistributions.Count; cnState++)
{
List <List <int> > currentGenotypePermutation = null;
int nDimensions = _poissonDistributions[cnState].GetDimensions();
if (_poissonDistributions[cnState].Mean().Average() < haploidMeans.Average() * 1.5 ||
_poissonDistributions[cnState].Mean().Average() > haploidMeans.Average() * 1.5)
{
currentGenotypePermutation = DistributionUtilities.GetGenotypeCombinations(nDimensions, cnState);
}
GenotypePermutations[cnState] = currentGenotypePermutation;
}
}
