public static List <ITranscript> GetTranscripts(DataBundle bundle, IChromosomeInterval interval)
{
ITranscript[] overlappingTranscripts =
bundle.TranscriptCache.TranscriptIntervalForest.GetAllOverlappingValues(interval.Chromosome.Index,
interval.Start, interval.End);
return(overlappingTranscripts?.ToList() ?? new List <ITranscript>());
}
private static BreakEndAdjacency[] CreateFromDuplication(IChromosomeInterval interval)
{
// 1 1 . N ]1:10]N
var origin = new BreakPoint(interval.Chromosome, interval.End, false);
var remote = new BreakPoint(interval.Chromosome, interval.Start - 1, false);
var adjacency = new BreakEndAdjacency(origin, remote);
return(new[] { adjacency, adjacency.Flip() });
}
public RepeatExpansionPhenotype(IChromosomeInterval chromosomeInterval, string phenotype, string omimId,
int[] repeatNumbers, double[] percentiles, string[] classifications, Interval[] classificationRanges)
{
ChromosomeInterval = chromosomeInterval;
_phenotype = phenotype;
_omimId = omimId;
_repeatNumbers = repeatNumbers;
_percentiles = percentiles;
_classifications = classifications;
_classificationRanges = classificationRanges;
}
private static BreakEndAdjacency[] CreateFromInversion(IChromosomeInterval interval)
{
// 1 10 . N N]1:20]
// 1 11 . N [1:21[N
var origin = new BreakPoint(interval.Chromosome, interval.Start - 1, false);
var remote = new BreakPoint(interval.Chromosome, interval.End, true);
var adjacency = new BreakEndAdjacency(origin, remote);
var origin2 = new BreakPoint(interval.Chromosome, interval.End + 1, true);
var remote2 = new BreakPoint(interval.Chromosome, interval.Start, false);
var adjacency2 = new BreakEndAdjacency(origin2, remote2);
return(new[] { adjacency, adjacency2 });
}
private int[] GetFunctionBlockDistances(IChromosomeInterval chrInterval)
{
var overlappingCodingBlocks = GetOverlappingCodingBlocks(chrInterval);
if (overlappingCodingBlocks == null)
{
return(null);
}
var functionBlockRanges = new int[overlappingCodingBlocks.Length];
for (var i = 0; i < overlappingCodingBlocks.Length; i++)
{
var overlappingCodingBlock = overlappingCodingBlocks[i];
functionBlockRanges[i] = GetFunctionBlockRange(chrInterval, overlappingCodingBlock);
}
return(functionBlockRanges);
}
public static BreakEndAdjacency[] CreateFromSymbolicAllele(IChromosomeInterval interval, VariantType variantType)
{
// ReSharper disable once SwitchStatementMissingSomeCases
switch (variantType)
{
case VariantType.deletion:
return(CreateFromDeletion(interval));
case VariantType.tandem_duplication:
return(CreateFromDuplication(interval));
case VariantType.inversion:
return(CreateFromInversion(interval));
default:
return(null);
}
}
public int GetLongestFunctionBlockDistance(IChromosomeInterval chrInterval)
{
var functionBlockRanges = GetFunctionBlockDistances(chrInterval);
if (functionBlockRanges == null)
{
return(-1);
}
int longestRange = functionBlockRanges[0];
for (var i = 1; i < functionBlockRanges.Length; i++)
{
if (functionBlockRanges[i] > longestRange)
{
longestRange = functionBlockRanges[i];
}
}
return(longestRange);
}
private static string GetReferenceBases(ILogger logger, CompressedSequenceReader reader, IChromosomeInterval interval)
{
logger.Write("- retrieving reference bases... ");
reader.GetCompressedSequence(interval.Chromosome);
string referenceBases = reader.Sequence.Substring(interval.Start, interval.End - interval.Start + 1);
logger.WriteLine($"{referenceBases.Length} bases extracted.");
return(referenceBases);
}
public static List <ITranscript> GetTranscripts(DataBundle bundle, IChromosomeInterval interval)
{
var overlappingTranscripts = bundle.TranscriptCache.GetOverlappingTranscripts(interval.Chromosome, interval.Start, interval.End);
return(overlappingTranscripts?.ToList() ?? new List <ITranscript>());
}
private ICodingBlock[] GetOverlappingCodingBlocks(IChromosomeInterval chrInterval)
{
UpdateCodingBlockArray(chrInterval.Chromosome.Index);
return(_commonCodingBlockArray?.GetAllOverlappingValues(chrInterval.Start, chrInterval.End));
}
public IRegulatoryRegion[] GetOverlappingRegulatoryRegions(IChromosomeInterval interval) => _regulatoryIntervalForest.GetAllOverlappingValues(interval.Chromosome.Index, interval.Start, interval.End);
public ITranscript[] GetOverlappingTranscripts(IChromosomeInterval interval) => GetOverlappingTranscripts(interval.Chromosome, interval.Start, interval.End);
public static ITranscript[] GetAllFlankingValues(this IIntervalForest <ITranscript> transcriptIntervalForest,
IChromosomeInterval interval) => transcriptIntervalForest.GetAllOverlappingValues(interval.Chromosome.Index,
interval.Start - interval.Chromosome.FlankingLength, interval.End + interval.Chromosome.FlankingLength);
public bool OverlapsAny(IChromosomeInterval variant)
{
return(_intervalForest.OverlapsAny(variant.Chromosome.Index, variant.Start, variant.End));
}
public static (double?ReciprocalOverlap, double?AnnotationOverlap) GetOverlapFractions(IChromosomeInterval saInterval, ISimpleVariant variant)
{
if (saInterval.Chromosome.Index != variant.Chromosome.Index)
{
return(null, null);
}
//skip for insertions
if (saInterval.Start >= saInterval.End || variant.Type == VariantType.insertion)
{
return(null, null);
}
//skip for break-ends
if (variant.Type == VariantType.translocation_breakend)
{
return(null, null);
}
if (!Overlaps(saInterval.Start, saInterval.End, variant.Start, variant.End))
{
return(null, null);
}
var overlapSize = (double)(Math.Min(saInterval.End, variant.End) - Math.Max(saInterval.Start, variant.Start) + 1);
int annoSize = saInterval.End - saInterval.Start + 1;
int varSize = variant.End - variant.Start + 1;
int maxSize = Math.Max(annoSize, varSize);
return(overlapSize / maxSize, overlapSize / annoSize);
}
