// ReSharper disable once UnusedParameter.Global
public static void CheckAlleleFrequencies(IAnnotatedAlternateAllele altAllele, double expectedValue, string key)
{
double observedValue;
Assert.True(double.TryParse(typeof(IAnnotatedAlternateAllele).GetProperty(key).GetValue(altAllele).ToString(), out observedValue));
Assert.Equal(expectedValue, observedValue);
}
private string LofteeAnalysis(IAnnotatedTranscript ta, IAnnotatedAlternateAllele allele,
ICompressedSequence sequence)
{
if (!LofteeUtilities.IsApplicable(ta))
{
return(null);
}
var filters = new HashSet <LofteeFilter.Filter>();
var flags = new HashSet <LofteeFilter.Flag>();
var transcript = _transcriptsById[ta.TranscriptID];
CheckSingleExon(transcript, flags);
if (LofteeUtilities.IsInExon(ta))
{
CheckEndTruncation(ta, transcript, filters);
CheckIncompleteCds();
CheckNonCanonicalSpliceSurr(ta, transcript, filters, sequence);
}
var intronIdx = LofteeUtilities.GetIntronIndex(ta, transcript);
if (LofteeUtilities.IsSpliceVariant(ta) && intronIdx != -1)
{
CheckSmallIntron(intronIdx, transcript, filters);
CheckNonCanonicalSplice(intronIdx, transcript, filters, sequence);
CheckNagnagSite(transcript, allele, flags, sequence);
}
return(GetLofteeString(filters, flags));
}
// ReSharper disable once UnusedParameter.Global
public static void CheckAlleleCoverage(IAnnotatedAlternateAllele altAllele, int expectedValue, string key)
{
int observedValue;
Assert.True(int.TryParse(typeof(IAnnotatedAlternateAllele).GetProperty(key).GetValue(altAllele).ToString(), out observedValue));
Assert.Equal(expectedValue, observedValue);
}
public void AddAnnotationToVariant(IAnnotatedAlternateAllele jsonVariant)
{
jsonVariant.ExacCoverage = ExacCoverage > 0 ? ExacCoverage.ToString(CultureInfo.InvariantCulture) : null;
jsonVariant.ExacAlleleNumberAfrican = ExacAfrAn?.ToString(CultureInfo.InvariantCulture);
jsonVariant.ExacAlleleNumberAmerican = ExacAmrAn?.ToString(CultureInfo.InvariantCulture);
jsonVariant.ExacAlleleNumberAll = ExacAllAn?.ToString(CultureInfo.InvariantCulture);
jsonVariant.ExacAlleleNumberEastAsian = ExacEasAn?.ToString(CultureInfo.InvariantCulture);
jsonVariant.ExacAlleleNumberFinish = ExacFinAn?.ToString(CultureInfo.InvariantCulture);
jsonVariant.ExacAlleleNumberNonFinish = ExacNfeAn?.ToString(CultureInfo.InvariantCulture);
jsonVariant.ExacAlleleNumberOther = ExacOthAn?.ToString(CultureInfo.InvariantCulture);
jsonVariant.ExacAlleleNumberSouthAsian = ExacSasAn?.ToString(CultureInfo.InvariantCulture);
jsonVariant.ExacAlleleCountAfrican = ExacAfrAc?.ToString(CultureInfo.InvariantCulture);
jsonVariant.ExacAlleleCountAmerican = ExacAmrAc?.ToString(CultureInfo.InvariantCulture);
jsonVariant.ExacAlleleCountAll = ExacAllAc?.ToString(CultureInfo.InvariantCulture);
jsonVariant.ExacAlleleCountEastAsian = ExacEasAc?.ToString(CultureInfo.InvariantCulture);
jsonVariant.ExacAlleleCountFinish = ExacFinAc?.ToString(CultureInfo.InvariantCulture);
jsonVariant.ExacAlleleCountNonFinish = ExacNfeAc?.ToString(CultureInfo.InvariantCulture);
jsonVariant.ExacAlleleCountOther = ExacOthAc?.ToString(CultureInfo.InvariantCulture);
jsonVariant.ExacAlleleCountSouthAsian = ExacSasAc?.ToString(CultureInfo.InvariantCulture);
jsonVariant.ExacAlleleFrequencyAfrican = ComputeFrequency(ExacAfrAn, ExacAfrAc);
jsonVariant.ExacAlleleFrequencyAmerican = ComputeFrequency(ExacAmrAn, ExacAmrAc);
jsonVariant.ExacAlleleFrequencyAll = ComputeFrequency(ExacAllAn, ExacAllAc);
jsonVariant.ExacAlleleFrequencyEastAsian = ComputeFrequency(ExacEasAn, ExacEasAc);
jsonVariant.ExacAlleleFrequencyFinish = ComputeFrequency(ExacFinAn, ExacFinAc);
jsonVariant.ExacAlleleFrequencyNonFinish = ComputeFrequency(ExacNfeAn, ExacNfeAc);
jsonVariant.ExacAlleleFrequencyOther = ComputeFrequency(ExacOthAn, ExacOthAc);
jsonVariant.ExacAlleleFrequencySouthAsian = ComputeFrequency(ExacSasAn, ExacSasAc);
}
public void AddAnnotationToVariant(IAnnotatedAlternateAllele jsonVariant)
{
jsonVariant.AncestralAllele = AncestralAllele;
jsonVariant.OneKgAlleleNumberAfrican = OneKgAfrAn?.ToString(CultureInfo.InvariantCulture);
jsonVariant.OneKgAlleleNumberAmerican = OneKgAmrAn?.ToString(CultureInfo.InvariantCulture);
jsonVariant.OneKgAlleleNumberAll = OneKgAllAn?.ToString(CultureInfo.InvariantCulture);
jsonVariant.OneKgAlleleNumberEastAsian = OneKgEasAn?.ToString(CultureInfo.InvariantCulture);
jsonVariant.OneKgAlleleNumberEuropean = OneKgEurAn?.ToString(CultureInfo.InvariantCulture);
jsonVariant.OneKgAlleleNumberSouthAsian = OneKgSasAn?.ToString(CultureInfo.InvariantCulture);
jsonVariant.OneKgAlleleCountAfrican = OneKgAfrAc?.ToString(CultureInfo.InvariantCulture);
jsonVariant.OneKgAlleleCountAmerican = OneKgAmrAc?.ToString(CultureInfo.InvariantCulture);
jsonVariant.OneKgAlleleCountAll = OneKgAllAc?.ToString(CultureInfo.InvariantCulture);
jsonVariant.OneKgAlleleCountEastAsian = OneKgEasAc?.ToString(CultureInfo.InvariantCulture);
jsonVariant.OneKgAlleleCountEuropean = OneKgEurAc?.ToString(CultureInfo.InvariantCulture);
jsonVariant.OneKgAlleleCountSouthAsian = OneKgSasAc?.ToString(CultureInfo.InvariantCulture);
jsonVariant.AlleleFrequencyAll = ComputeFrequency(OneKgAllAn, OneKgAllAc);
jsonVariant.AlleleFrequencyAfrican = ComputeFrequency(OneKgAfrAn, OneKgAfrAc);
jsonVariant.AlleleFrequencyAdMixedAmerican = ComputeFrequency(OneKgAmrAn, OneKgAmrAc);
jsonVariant.AlleleFrequencyEastAsian = ComputeFrequency(OneKgEasAn, OneKgEasAc);
jsonVariant.AlleleFrequencyEuropean = ComputeFrequency(OneKgEurAn, OneKgEurAc);
jsonVariant.AlleleFrequencySouthAsian = ComputeFrequency(OneKgSasAn, OneKgSasAc);
}
private void WriteJson(IAnnotatedVariant annotatedVariant, IAnnotatedAlternateAllele firstAllele,
UnifiedJsonWriter writer)
{
if (firstAllele.IsReference && !firstAllele.IsReferenceMinor && !firstAllele.IsReferenceNoCall)
{
return;
}
writer.Write(annotatedVariant.ToString());
}
private static void WriteVcf(string output, IAnnotatedAlternateAllele firstAllele,
LiteVcfWriter writer)
{
if (firstAllele.IsReference && !firstAllele.IsReferenceMinor)
{
return;
}
writer.Write(output);
}
public void AddAnnotationToVariant(IAnnotatedAlternateAllele jsonVariant)
{
jsonVariant.EvsCoverage = EvsCoverage;
jsonVariant.EvsSamples = NumEvsSamples;
jsonVariant.EvsAlleleFrequencyAfricanAmerican = EvsAfr;
jsonVariant.EvsAlleleFrequencyEuropeanAmerican = EvsEur;
jsonVariant.EvsAlleleFrequencyAll = EvsAll;
}
/// <summary>
/// adds a phyloP score to the specified alternate allele
/// </summary>
internal static void SetConservationScore(IAnnotatedAlternateAllele altAllele, string phylopScore)
{
var jsonVariant = altAllele as JsonVariant;
if (jsonVariant == null)
{
return;
}
jsonVariant.PhylopScore = phylopScore;
}
public void AddSaPositionToVariant(IAnnotatedAlternateAllele jsonVariant)
{
jsonVariant.GlobalMinorAllele = GlobalMinorAllele;
jsonVariant.GlobalMinorAlleleFrequency = GlobalMinorAlleleFrequency;
// adding cosmic
foreach (var cosmicItem in CosmicItems)
{
jsonVariant.CosmicEntries.Add(cosmicItem);
}
// adding ClinVar
foreach (var clinVarItem in ClinVarItems)
{
jsonVariant.ClinVarEntries.Add(clinVarItem);
}
// adding custom items
foreach (var customItem in CustomItems)
{
// we need to check if a custom annotation is allele specific. If so, we match the alt allele.
if (!customItem.IsPositional &&
customItem.SaAltAllele != jsonVariant.SaAltAllele)
{
continue;
}
jsonVariant.CustomItems.Add(new CustomItem(jsonVariant.ReferenceName,
jsonVariant.ReferenceBegin ?? 0,
jsonVariant.RefAllele,
jsonVariant.AltAllele,
customItem.AnnotationType,
customItem.Id,
customItem.IsPositional,
customItem.StringFields,
customItem.BooleanFields,
customItem.IsAlleleSpecific));
}
// adding allele-specific annotations
AlleleSpecificAnnotation asa;
if (!AlleleSpecificAnnotations.TryGetValue(jsonVariant.SaAltAllele, out asa))
{
return;
}
foreach (DataSourceCommon.DataSource dataSource in Enum.GetValues(typeof(DataSourceCommon.DataSource)))
{
if (asa.HasDataSource(dataSource))
{
asa.Annotations[DataSourceCommon.GetIndex(dataSource)].AddAnnotationToVariant(jsonVariant);
}
}
}
public void AddAnnotationToVariant(IAnnotatedAlternateAllele jsonVariant)
{
if (DbSnp == null)
{
return;
}
var newDbSnp = new List <string>();
foreach (var dbSnp in DbSnp)
{
newDbSnp.Add("rs" + dbSnp);
}
jsonVariant.DbSnpIds = newDbSnp.ToArray();
}
private void CheckNagnagSite(Transcript transcript, IAnnotatedAlternateAllele allele,
HashSet <LofteeFilter.Flag> flags, ICompressedSequence sequence)
{
if (allele.ReferenceBegin == null || allele.ReferenceEnd == null ||
allele.ReferenceBegin.Value != allele.ReferenceEnd.Value)
{
return;
}
int pos = allele.ReferenceBegin.Value;
string upStreamSeq = sequence.Substring(pos - 6, 6);
string downStreamSeq = sequence.Substring(pos, 5);
var combineSeq = transcript.Gene.OnReverseStrand
? SequenceUtilities.GetReverseComplement(upStreamSeq + downStreamSeq)
: upStreamSeq + downStreamSeq;
if (Regex.Match(combineSeq, "[A|T|C|G]AG[A|T|C|G]AG").Success)
{
flags.Add(LofteeFilter.Flag.nagnag_site);
}
}
internal static List <string> GetOverlappingTranscriptIds(IAnnotatedAlternateAllele annotatedAllele)
{
return(annotatedAllele.SvOverlappingTranscripts.Select(transcript => transcript.TranscriptID).ToList());
}
// ReSharper disable once UnusedParameter.Global
public static void CheckRegulatoryCount(int expectedCount, IAnnotatedAlternateAllele altAllele)
{
var observedCount = altAllele?.RegulatoryRegions.Count;
Assert.Equal(expectedCount, observedCount);
}
// ReSharper disable once UnusedParameter.Global
public static void CheckRefSeqTranscriptCount(int expectedCount, IAnnotatedAlternateAllele altAllele)
{
var observedCount = altAllele?.RefSeqTranscripts.Count;
Assert.Equal(expectedCount, observedCount);
}
