public void CreateAndAdd() { var candidates = new List <CandidateAllele>() { new CandidateAllele("chr1", 100, "A", "AT", AlleleCategory.Insertion), new CandidateAllele("chr1", 100, "A", "A", AlleleCategory.Reference), new CandidateAllele("chr1", 100, "A", "T", AlleleCategory.Snv), new CandidateAllele("chr1", 200, "A", "T", AlleleCategory.Mnv) }; var batch = new CandidateBatch(candidates); var batchCandidates = batch.GetCandidates(); Assert.Equal(4, batchCandidates.Count); foreach (var candidate in candidates) { Assert.True(batchCandidates.Contains(candidate)); } // add new candidate var newCandidate = new CandidateAllele("chr1", 200, "AT", "A", AlleleCategory.Deletion); batch.Add(new List <CandidateAllele>() { newCandidate }); Assert.Equal(5, batchCandidates.Count); Assert.True(batchCandidates.Contains(newCandidate)); }
/// <summary> /// Only pass back candidates from blocks where the entire block region is less than upToPosition. /// The second criteria is to ensure variants that span blocks have fully completed info in either flanking block. /// </summary> /// <param name="upToPosition"></param> /// /// <param name="chrReference"></param> /// /// <param name="intervalSet"></param> /// <returns></returns> public virtual ICandidateBatch GetCandidatesToProcess(int?upToPosition, ChrReference chrReference = null, HashSet <Tuple <string, int, string, string> > forcesGtAlleles = null) { try { // only create a real batch if we haved moved onto another block if (upToPosition.HasValue && GetBlockKey(upToPosition.Value) == _lastUpToBlockKey) { return(null); } var batch = new CandidateBatch { MaxClearedPosition = upToPosition.HasValue ? -1 : (int?)null }; var blockKeys = upToPosition.HasValue ? _regionLookup.Keys.Where(k => k * _regionSize <= upToPosition).ToArray() : _regionLookup.Keys.ToArray(); var blocks = new List <MyRegionState>(); Array.Sort(blockKeys); // need to sort the keys so we can bounce out as soon as we hit a held block foreach (var key in blockKeys) { var block = _regionLookup[key]; if (upToPosition != null && block.MaxAlleleEndpoint > upToPosition) { break; } //Console.WriteLine("block start="+ block.StartPosition+" ;block end = "+ block.EndPosition); batch.Add(block.GetAllCandidates(_includeRefAlleles, chrReference, _intervalSet, forcesGtAlleles)); batch.BlockKeys.Add(key); blocks.Add(block); } if (blocks.Any()) { batch.ClearedRegions = new List <Region>(blocks.Select(b => b as Region)); batch.MaxClearedPosition = blocks.Max(b => b.EndPosition); if (upToPosition.HasValue && blocks.Max(b => b.MaxAlleleEndpoint) > batch.MaxClearedPosition.Value && _trackOpenEnded) { AddCollapsableFromOtherBlocks(batch, batch.MaxClearedPosition.Value, upToPosition.Value); } } return(batch); } finally { _lastUpToBlockKey = upToPosition.HasValue ? GetBlockKey(upToPosition.Value) : -1; // doesnt matter what we set to for last round } }
public override ICandidateBatch GetCandidatesToProcess(int?upToPosition, ChrReference chrReference = null, HashSet <Tuple <string, int, string, string> > forcedGtAlleles = null) { try { // only create a real batch if we haved moved onto another block if (upToPosition.HasValue && GetBlockKey(upToPosition.Value) == _lastUpToBlockKey) { return(null); } var batch = new CandidateBatch { MaxClearedPosition = upToPosition.HasValue ? -1 : (int?)null }; var blockKeys = upToPosition.HasValue ? _regionLookup.Keys.Where(k => k * _regionSize <= upToPosition).ToArray() : _regionLookup.Keys.ToArray(); var blocksToRealign = new List <MyRegionState>(); Array.Sort(blockKeys); // need to sort the keys so we can bounce out as soon as we hit a held block foreach (var key in blockKeys) { // add candidates from everyone var block = _regionLookup[key]; batch.Add(block.GetAllCandidates(false, chrReference, null)); // only realign blocks that havent been cleared and are one window away from upToPosition if (block.StartPosition > _lastMaxClearedPosition && (upToPosition.HasValue && block.EndPosition + _regionSize < upToPosition)) { batch.BlockKeys.Add(key); blocksToRealign.Add(block); } } if (blocksToRealign.Any()) { batch.ClearedRegions = new List <Region>(blocksToRealign.Select(b => b as Region)); batch.MaxClearedPosition = blocksToRealign.Max(b => b.EndPosition); } return(batch); } finally { _lastUpToBlockKey = upToPosition.HasValue ? GetBlockKey(upToPosition.Value) : -1; // doesnt matter what we set to for last round } }
/// <summary> /// Only pass back candidates from blocks where the entire block region is less than upToPosition /// and there's a fully completed block after it. The second criteria is to ensure variants that /// span blocks have fully completed info in either flanking block. /// </summary> /// <param name="upToPosition"></param> /// /// <param name="chrReference"></param> /// /// <param name="intervalSet"></param> /// <returns></returns> public ICandidateBatch GetCandidatesToProcess(int?upToPosition, ChrReference chrReference = null) { var batch = new CandidateBatch { MaxClearedPosition = upToPosition.HasValue ? -1 : (int?)null }; // only create a real batch if we haved moved onto another block if (!upToPosition.HasValue || GetBlockKey(upToPosition.Value) != _lastUpToKey) { var blockKeys = upToPosition.HasValue ? _regionLookup.Keys.Where(k => (k + 1) * _regionSize <= upToPosition).ToArray() : _regionLookup.Keys.ToArray(); var blocks = new List <RegionState>(); Array.Sort(blockKeys); // need to sort the keys so we can bounce out as soon as we hit a held block foreach (var key in blockKeys) { var block = _regionLookup[key]; if (upToPosition != null && block.MaxAlleleEndpoint > upToPosition) { break; } batch.Add(block.GetAllCandidates(_includeRefAlleles, chrReference, _intervalSet)); batch.BlockKeys.Add(key); blocks.Add(block); } if (blocks.Any()) { batch.ClearedRegions = new List <Region>(blocks.Select(b => b as Region)); batch.MaxClearedPosition = blocks.Max(b => b.EndPosition); } } _lastUpToKey = upToPosition.HasValue ? GetBlockKey(upToPosition.Value) : -1; // doesnt matter what we set to for last round return(batch); }