private IVariant GetVariant()
{
var behavior = new AnnotationBehavior(false, false, false, false, false, false);
return(new Variant(_chromosome, 100, 200, "A", "G", VariantType.SNV, "bob:100:G", false, false, false,
new[] { "bob:100:102:TAT" }, null, behavior));
}
internal static Status DecideAnnotationStatus(IInterval variant, IInterval transcript,
AnnotationBehavior behavior, IInterval gene)
{
if (variant.Contains(gene) && behavior.ReducedTranscriptAnnotation)
{
return(Status.SvCompleteOverlapAnnotation);
}
if (variant.Contains(gene) && !behavior.ReducedTranscriptAnnotation)
{
return(Status.FullAnnotation);
}
if (!variant.Contains(gene) && variant.Overlaps(transcript) && behavior.ReducedTranscriptAnnotation)
{
return(Status.ReducedAnnotation);
}
if (!variant.Contains(gene) && variant.Overlaps(transcript) && !behavior.ReducedTranscriptAnnotation)
{
return(Status.FullAnnotation);
}
if (!variant.Overlaps(transcript) && variant.Overlaps(transcript, OverlapBehavior.FlankingLength) && behavior.NeedFlankingTranscript)
{
return(Status.FlankingAnnotation);
}
return(Status.NoAnnotation);
}
public void Variant_Set()
{
var expectedChromosome = new Chromosome("chr1", "1", 0);
const int expectedStart = 100;
const int expectedEnd = 102;
const string expectedRef = "AT";
const string expectedAlt = "";
const VariantType expectedType = VariantType.deletion;
const string expectedVid = "1:100:A:C";
const bool expectedRefMinor = true;
const bool expectedDecomposed = false;
const bool expectedRecomposed = true;
var expectedLinkedVids = new[] { "1:102:T:G" };
var expectedBreakEnds = new IBreakEnd[] { new BreakEnd(expectedChromosome, expectedChromosome, 100, 200, false, false) };
var expectedBehavior = new AnnotationBehavior(false, false, false, false, true);
var variant = new Variant(expectedChromosome, expectedStart, expectedEnd, expectedRef, expectedAlt,
expectedType, expectedVid, expectedRefMinor, expectedDecomposed, expectedRecomposed, expectedLinkedVids,
expectedBreakEnds, expectedBehavior);
Assert.Equal(expectedChromosome, variant.Chromosome);
Assert.Equal(expectedStart, variant.Start);
Assert.Equal(expectedEnd, variant.End);
Assert.Equal(expectedRef, variant.RefAllele);
Assert.Equal(expectedAlt, variant.AltAllele);
Assert.Equal(expectedType, variant.Type);
Assert.Equal(expectedVid, variant.VariantId);
Assert.Equal(expectedRefMinor, variant.IsRefMinor);
Assert.Equal(expectedDecomposed, variant.IsDecomposed);
Assert.Equal(expectedRecomposed, variant.IsRecomposed);
Assert.Equal(expectedLinkedVids, variant.LinkedVids);
Assert.Equal(expectedBreakEnds, variant.BreakEnds);
Assert.Equal(expectedBehavior, variant.Behavior);
}
public void AnnotationBehavior_Set()
{
var behavior = new AnnotationBehavior(true, true, true, true, true);
Assert.True(behavior.NeedFlankingTranscript);
Assert.True(behavior.NeedSaInterval);
Assert.True(behavior.NeedSaPosition);
Assert.True(behavior.ReducedTranscriptAnnotation);
Assert.True(behavior.StructuralVariantConsequence);
}
private static IVariant GetVariant()
{
var behavior = new AnnotationBehavior(false, false, false, false, false);
var variant = new Mock <IVariant>();
variant.SetupGet(x => x.Type).Returns(VariantType.SNV);
variant.SetupGet(x => x.Start).Returns(949523);
variant.SetupGet(x => x.End).Returns(949523);
variant.SetupGet(x => x.Behavior).Returns(behavior);
return(variant.Object);
}
private IVariant[] GetVariants()
{
var behavior = new AnnotationBehavior(false, false, false, false, false, false);
var variant = new Mock <IVariant>();
variant.SetupGet(x => x.Chromosome).Returns(_chromosome);
variant.SetupGet(x => x.Type).Returns(VariantType.SNV);
variant.SetupGet(x => x.Start).Returns(949523);
variant.SetupGet(x => x.End).Returns(949523);
variant.SetupGet(x => x.RefAllele).Returns("C");
variant.SetupGet(x => x.AltAllele).Returns("T");
variant.SetupGet(x => x.Behavior).Returns(behavior);
return(new[] { variant.Object });
}
public static IVariant Create(IChromosome chromosome, int start, int end, string refAllele, string altAllele, string svType, string vid)
{
VariantType variantType = GetVariantType(altAllele, svType);
AnnotationBehavior behavior = variantType == VariantType.translocation_breakend
? AnnotationBehavior.BreakendVariants
: AnnotationBehavior.StructuralVariants;
if (variantType != VariantType.translocation_breakend)
{
start++;
}
return(new Variant(chromosome, start, end, refAllele, altAllele, variantType, vid, false, false, false,
null, behavior, true));
}
public Variant(IChromosome chromosome, int start, int end, string refAllele, string altAllele,
VariantType variantType, string variantId, bool isRefMinor, bool isDecomposed, bool isRecomposed, string[] linkedVids, IBreakEnd[] breakEnds,
AnnotationBehavior behavior)
{
Chromosome = chromosome;
Start = start;
End = end;
RefAllele = refAllele;
AltAllele = altAllele;
Type = variantType;
VariantId = variantId;
IsRefMinor = isRefMinor;
IsRecomposed = isRecomposed;
IsDecomposed = isDecomposed;
LinkedVids = linkedVids;
Behavior = behavior;
BreakEnds = breakEnds;
}
internal static Status DecideAnnotationStatus(IInterval variant, IInterval transcript, AnnotationBehavior behavior)
{
var overlapsTranscript = variant.Overlaps(transcript);
if (!behavior.ReducedTranscriptAnnotation)
{
// handle small variants
if (overlapsTranscript)
{
return(Status.FullAnnotation);
}
if (behavior.NeedFlankingTranscript && variant.Overlaps(transcript, OverlapBehavior.FlankingLength))
{
return(Status.FlankingAnnotation);
}
}
else if (overlapsTranscript)
{
// handle large variants
if (behavior.CanonicalTranscriptOnly)
{
return(Status.RohAnnotation);
}
return(variant.Contains(transcript) ? Status.CompleteOverlapAnnotation : Status.ReducedAnnotation);
}
return(Status.NoAnnotation);
}
internal static Status DecideAnnotationStatus(IInterval variant, IInterval transcript, AnnotationBehavior behavior, int flankingLength)
{
bool overlapsTranscript = variant.Overlaps(transcript);
if (!behavior.ReducedTranscriptAnnotation)
{
// handle small variants
if (overlapsTranscript)
{
return(Status.FullAnnotation);
}
if (behavior.NeedFlankingTranscripts && variant.Overlaps(transcript, flankingLength))
{
return(Status.FlankingAnnotation);
}
}
else if (overlapsTranscript)
{
// handle large variants
if (behavior.CanonicalTranscriptOnly)
{
return(Status.RohAnnotation);
}
return(Status.ReducedAnnotation);
}
return(Status.NoAnnotation);
}
