public void Cnv()
{
const string vcfLine = "chr1 713044 DUP_gs_CNV_1_713044_755966 C <CN0>,<CN2> 100 PASS AC=3,206;AF=0.000599042,0.0411342;AN=5008;CS=DUP_gs;END=755966;NS=2504;SVTYPE=CNV;DP=20698;EAS_AF=0.001,0.0615;AMR_AF=0.0014,0.0259;AFR_AF=0,0.0303;EUR_AF=0.001,0.0417;SAS_AF=0,0.045";
var altAllele = new VariantAlternateAllele(713045, 755966, "C", "CN0")
{
VepVariantType = VariantType.copy_number_variation,
IsStructuralVariant = true
};
var altAllele2 = new VariantAlternateAllele(713045, 755966, "C", "CN2")
{
VepVariantType = VariantType.copy_number_variation,
IsStructuralVariant = true
};
var expectedReferenceName = "chr1";
var expectedAlternateAlleles = new List <VariantAlternateAllele> {
altAllele, altAllele2
};
var expectedVcfReferenceBegin = altAllele.Start - 1;
var expectedVcfReferenceEnd = altAllele.End;
var variant = VcfUtilities.GetVariant(vcfLine, _renamer);
Assert.Equal(expectedReferenceName, variant.ReferenceName);
Assert.Equal(expectedVcfReferenceBegin, variant.VcfReferenceBegin);
Assert.Equal(expectedVcfReferenceEnd, variant.VcfReferenceEnd);
Assert.True(expectedAlternateAlleles.SequenceEqual(variant.AlternateAlleles));
}
public void Duplication2()
{
const string vcfLine = "chrX 66764988 . G <DUP> 100 PASS IMPRECISE;SVTYPE=DUP;END=66943683;SVLEN=178696;CIPOS=-1,1;CIEND=-1,1;DP=2635";
var altAllele = new VariantAlternateAllele(66764989, 66943683, "G", "duplication")
{
VepVariantType = VariantType.duplication,
IsStructuralVariant = true,
AlternateAllele = "duplication"
};
var expectedReferenceName = "chrX";
var expectedAlternateAlleles = new List <VariantAlternateAllele> {
altAllele
};
var expectedVcfReferenceBegin = altAllele.Start - 1;
var expectedVcfReferenceEnd = altAllele.End;
var variant = VcfUtilities.GetVariant(vcfLine, _renamer);
Assert.Equal(expectedReferenceName, variant.ReferenceName);
Assert.Equal(expectedVcfReferenceBegin, variant.VcfReferenceBegin);
Assert.Equal(expectedVcfReferenceEnd, variant.VcfReferenceEnd);
Assert.True(expectedAlternateAlleles.SequenceEqual(variant.AlternateAlleles));
}
public void Insertion()
{
const string vcfLine = "chr22 15883626 P1_MEI_4726 T <INS> 40 . SVTYPE=INS;CIPOS=-23,23;IMPRECISE;NOVEL;SVMETHOD=SR;NSF5=1;NSF3=0";
var altAllele = new VariantAlternateAllele(15883627, 15883626, "T", "insertion")
{
VepVariantType = VariantType.insertion,
IsStructuralVariant = true,
AlternateAllele = "insertion"
};
var expectedReferenceName = "chr22";
var expectedAlternateAlleles = new List <VariantAlternateAllele> {
altAllele
};
var expectedVcfReferenceBegin = altAllele.Start - 1;
var expectedVcfReferenceEnd = altAllele.End;
var variant = VcfUtilities.GetVariant(vcfLine, _renamer);
Assert.Equal(expectedReferenceName, variant.ReferenceName);
Assert.Equal(expectedVcfReferenceBegin, variant.VcfReferenceBegin);
Assert.Equal(expectedVcfReferenceEnd, variant.VcfReferenceEnd);
Assert.True(expectedAlternateAlleles.SequenceEqual(variant.AlternateAlleles));
}
private void AnnotateAltAllele(VariantFeature variant, VariantAlternateAllele altAllele, Transcript transcript)
{
// handle upstream or downstream transcripts
if (!Overlap.Partial(transcript.Start, transcript.End, altAllele.Start, altAllele.End))
{
return;
}
var ta = new TranscriptAnnotation
{
AlternateAllele = altAllele,
HasValidCdnaCodingStart = false,
HasValidCdsStart = false
};
MapCdnaCoordinates(transcript, ta, altAllele);
_pianoVariant.CreateAnnotationObject(transcript, altAllele);
GetCodingAnnotations(transcript, ta, _compressedSequence);
var consequence = new Consequences(new VariantEffect(ta, transcript, variant.InternalCopyNumberType));
consequence.DetermineVariantEffects(variant.InternalCopyNumberType);
_pianoVariant.FinalizeAndAddAnnotationObject(transcript, ta, consequence.GetConsequenceStrings());
}
public SvOverlapTranscript(DataStructures.Transcript transcript, VariantAlternateAllele altAllele)
{
TranscriptID = TranscriptUtilities.GetTranscriptId(transcript);
IsCanonical = transcript.IsCanonical ? "true" : null;
Hgnc = transcript.Gene.Symbol;
var isFullOverlap = altAllele.Start <= transcript.Start && altAllele.End >= transcript.End;
IsPartialOverlap = isFullOverlap ? null : "true";
}
public PianoAllele(VariantAlternateAllele altAllele)
{
VariantId = altAllele.VariantId;
VariantType = altAllele.NirvanaVariantType.ToString();
ReferenceBegin = altAllele.Start;
ReferenceEnd = altAllele.End;
RefAllele = altAllele.ReferenceAllele;
AltAllele = altAllele.AlternateAllele;
SaAltAllele = altAllele.SuppAltAllele;
Transcripts = new List <Transcript>();
}
public void AddOverlappingTranscript(Transcript transcript, VariantAlternateAllele altAllele)
{
if (!altAllele.IsStructuralVariant)
{
return;
}
FindCorrespondingJsonVariant(altAllele);
var svOverlapTranscript = new JsonVariant.SvOverlapTranscript(transcript, altAllele);
_currJsonVariant.SvOverlappingTranscripts.Add(svOverlapTranscript);
}
private JsonVariant(VariantAlternateAllele altAllele) : this()
{
VariantId = altAllele.VariantId;
VariantType = altAllele.NirvanaVariantType.ToString();
ReferenceBegin = altAllele.Start;
ReferenceEnd = altAllele.End;
RefAllele = altAllele.ReferenceAllele;
AltAllele = altAllele.AlternateAllele;
SaAltAllele = altAllele.SuppAltAllele;
GenotypeIndex = altAllele.GenotypeIndex;
}
public JsonVariant(VariantAlternateAllele altAllele, VariantFeature variant) : this(altAllele)
{
IsReferenceMinor = variant.IsRefMinor;
IsReference = variant.IsReference;
IsReferenceNoCall = variant.IsRefNoCall;
PhylopScore = altAllele.ConservationScore;
ReferenceName = variant.ReferenceName;
// change the ref and alternate allele for ref minor
RefAllele = variant.IsRefMinor ? altAllele.AlternateAllele : altAllele.ReferenceAllele;
AltAllele = variant.IsRefMinor ? null : altAllele.AlternateAllele;
}
public void AddRegulatoryFeature(RegulatoryElement regulatoryFeature, VariantAlternateAllele altAllele, string[] consequences)
{
var regulatoryRegion = new JsonVariant.RegulatoryRegion
{
ID = regulatoryFeature.Id.ToString(),
Type = regulatoryFeature.Type.ToString(),
Consequence = consequences
};
FindCorrespondingJsonVariant(altAllele);
_currJsonVariant.RegulatoryRegions.Add(regulatoryRegion);
}
public void AddOverlappingGenes(HashSet <string> overlappingGeneSymbols, VariantAlternateAllele altAllele)
{
if (!altAllele.IsStructuralVariant)
{
return;
}
FindCorrespondingJsonVariant(altAllele);
foreach (var geneSymbol in overlappingGeneSymbols)
{
_currJsonVariant.OverlappingGenes.Add(geneSymbol);
}
}
private static void AddCustomIntervals(VariantAlternateAllele altAllele, JsonVariant jsonVariant)
{
// adding the custom intervals
if (altAllele.CustomIntervals == null)
{
return;
}
jsonVariant.CustomIntervals.Clear();
foreach (var custInterval in altAllele.CustomIntervals)
{
jsonVariant.CustomIntervals.Add(custInterval);
}
}
/// <summary>
/// constructor
/// </summary>
public VariantEffect(TranscriptAnnotation ta, Transcript transcript, VariantType internalCopyNumberType = VariantType.unknown)
{
_ta = ta;
_transcript = transcript;
_altAllele = ta.AlternateAllele;
_preCache = new BasicVariantEffects(ta);
_cache = new VariantEffectCache();
_tempCache = new TempVariantEffectCache();
_featureVariantEffects = new FeatureVariantEffects(transcript, _altAllele.NirvanaVariantType,
_altAllele.Start, _altAllele.End, _altAllele.IsStructuralVariant, internalCopyNumberType);
}
private static void GetReferenceCoordinates(Transcript transcript, VariantAlternateAllele altAllele,
out int hgvsStart, out int hgvsEnd)
{
// calculate the HGVS position: use HGVS coordinates not variation feature coordinates due to duplications
if (transcript.Gene.OnReverseStrand)
{
hgvsStart = transcript.End - altAllele.End + 1;
hgvsEnd = transcript.End - altAllele.Start + 1;
}
else
{
hgvsStart = altAllele.Start - transcript.Start + 1;
hgvsEnd = altAllele.End - transcript.Start + 1;
}
}
private void FindCorrespondingJsonVariant(VariantAlternateAllele altAllele)
{
_currPianoAllele = null;
foreach (var pianoAllele in PianoAlleles)
{
if (pianoAllele.ReferenceBegin != altAllele.Start)
{
continue;
}
if (pianoAllele.SaAltAllele != altAllele.SuppAltAllele)
{
continue;
}
_currPianoAllele = pianoAllele;
}
}
public void CreateAnnotationObject(Transcript transcript, VariantAlternateAllele altAllele)
{
FindCorrespondingJsonVariant(altAllele);
if (_currPianoAllele == null)
{
throw new GeneralException("Cannot find jsonVariant corresponding to alternate allele");
}
_currTranscript = new PianoAllele.Transcript
{
IsCanonical = transcript.IsCanonical ? "true" : null,
TranscriptID = transcript.Id.ToString(),
BioType = BioTypeUtilities.GetBiotypeDescription(transcript.BioType),
Gene = transcript.TranscriptSource == TranscriptDataSource.Ensembl ? transcript.Gene.EnsemblId.ToString() : transcript.Gene.EntrezGeneId.ToString(),
Hgnc = transcript.Gene.Symbol
};
}
private void FindCorrespondingJsonVariant(VariantAlternateAllele altAllele)
{
_currJsonVariant = null;
foreach (var annotatedAllele in AnnotatedAlternateAlleles)
{
var jsonVariant = annotatedAllele as JsonVariant;
if (jsonVariant?.ReferenceBegin != altAllele.Start)
{
continue;
}
if (jsonVariant.SaAltAllele != altAllele.SuppAltAllele)
{
continue;
}
_currJsonVariant = jsonVariant;
}
}
public void CreateAnnotationObject(Transcript transcript, VariantAlternateAllele altAllele)
{
// while annotating alternate allele, the first output function to be called is AddExonData.
// So, we set the current json variant and transcript here.
// they will subsequently be used in other output functions.
FindCorrespondingJsonVariant(altAllele);
if (_currJsonVariant == null)
{
throw new GeneralException("Cannot find jsonVariant corresponding to alternate allele");
}
_currTranscript = new JsonVariant.Transcript
{
IsCanonical = transcript.IsCanonical ? TrueTag : null,
TranscriptID = TranscriptUtilities.GetTranscriptId(transcript),
BioType = BioTypeUtilities.GetBiotypeDescription(transcript.BioType),
Gene = transcript.TranscriptSource == TranscriptDataSource.Ensembl ? transcript.Gene.EnsemblId.ToString() : transcript.Gene.EntrezGeneId.ToString(),
Hgnc = transcript.Gene.Symbol
};
}
private static void MapCdnaCoordinates(Transcript transcript, TranscriptAnnotation ta, VariantAlternateAllele altAllele)
{
if (transcript.Gene.OnReverseStrand)
{
ta.TranscriptReferenceAllele = SequenceUtilities.GetReverseComplement(altAllele.ReferenceAllele);
ta.TranscriptAlternateAllele = SequenceUtilities.GetReverseComplement(altAllele.AlternateAllele);
}
else
{
ta.TranscriptReferenceAllele = altAllele.ReferenceAllele;
ta.TranscriptAlternateAllele = altAllele.AlternateAllele;
}
CdnaMapper.MapCoordinates(altAllele.Start, altAllele.End, ta, transcript);
}
/// <summary>
/// constructs a VID based on the supplied feature
/// </summary>
public string Create(ChromosomeRenamer renamer, string referenceName, VariantAlternateAllele altAllele)
{
referenceName = renamer.GetEnsemblReferenceName(referenceName);
string vid;
switch (altAllele.NirvanaVariantType)
{
case VariantType.SNV:
vid = $"{referenceName}:{altAllele.Start}:{altAllele.AlternateAllele}";
break;
case VariantType.insertion:
vid = altAllele.IsStructuralVariant
? $"{referenceName}:{altAllele.Start}:{altAllele.End}:INS"
: $"{referenceName}:{altAllele.Start}:{altAllele.End}:{GetInsertedAltAllele(altAllele.AlternateAllele)}";
break;
case VariantType.deletion:
vid = $"{referenceName}:{altAllele.Start}:{altAllele.End}";
break;
case VariantType.MNV:
case VariantType.indel:
vid = $"{referenceName}:{altAllele.Start}:{altAllele.End}:{GetInsertedAltAllele(altAllele.AlternateAllele)}";
break;
case VariantType.duplication:
vid = $"{referenceName}:{altAllele.Start}:{altAllele.End}:DUP";
break;
case VariantType.tandem_duplication:
vid = $"{referenceName}:{altAllele.Start}:{altAllele.End}:TDUP";
break;
case VariantType.translocation_breakend:
vid = altAllele.BreakEnds?[0].ToString();
break;
case VariantType.inversion:
vid = $"{referenceName}:{altAllele.Start}:{altAllele.End}:Inverse";
break;
case VariantType.mobile_element_insertion:
vid = $"{referenceName}:{altAllele.Start}:{altAllele.End}:MEI";
break;
case VariantType.copy_number_gain:
case VariantType.copy_number_loss:
case VariantType.copy_number_variation:
vid = $"{referenceName}:{altAllele.Start}:{altAllele.End}:{altAllele.CopyNumber}";
break;
case VariantType.reference_no_call:
vid = $"{referenceName}:{altAllele.Start}:{altAllele.End}:NC";
break;
default:
vid = $"{referenceName}:{altAllele.Start}:{altAllele.End}";
break;
}
return(vid);
}
public void AddIntergenicVariant(VariantAlternateAllele altAllele)
{
// in json, we do not output intergenic_variant since consequences are per transcripts and there are no transcripts for intergenic variants
FindCorrespondingJsonVariant(altAllele);
_currJsonVariant.IsIntergenic = true;
}
public void ToStringTest()
{
var vaa = new VariantAlternateAllele(100, 101, "AT", "A");
Assert.NotNull(vaa.ToString());
}
