Struct ParGranges

pub struct ParGranges<R: 'static + RegionProcessor + Send + Sync> { /* private fields */ }

ParGranges holds all the information and configuration needed to launch the ParGranges::process.

Implementations

impl<R: RegionProcessor + Send + Sync> ParGranges<R>

pub fn new( reads: PathBuf, ref_fasta: Option<PathBuf>, regions_bed: Option<PathBuf>, regions_bcf: Option<PathBuf>, merge_regions: bool, threads: Option<usize>, chunksize: Option<u32>, channel_size_modifier: Option<f64>, processor: R, ) -> Self

Create a ParIO object

Arguments

• reads- path to an indexed BAM/CRAM
• ref_fasta- path to an indexed reference file for CRAM
• regions_bed- Optional BED file path restricting the regions to be examined
• regions_bcf- Optional BCF/VCF file path restricting the regions to be examined
• merge_regions - If regions_bed and or regions_bcf is specified, and this is true, merge any overlapping regions to avoid duplicate output.
• threads- Optional threads to restrict the number of threads this process will use, defaults to all
• chunksize- optional argument to change the default chunksize of 1_000_000. chunksize determines the number of bases each worker will get to work on at one time.
• channel_size_modifier- Optional argument to modify the default size ration of the channel that R::P is sent on. formula is: ((BYTES_INA_GIGABYTE * channel_size_modifier) * threads) / size_of(R::P)
• processor- Something that implements RegionProcessor

pub fn process(self) -> Result<Receiver<R::P>>

Process each region.

This method splits the sequences in the BAM/CRAM header into chunksize * self.threads regions (aka ‘super chunks’). It then queries that ‘super chunk’ against the intervals (either the BED file, or the whole genome broken up into chunksize regions). The results of that query are then processed by a pool of workers that apply process_region to reach interval to do perbase analysis on. The collected result for each region is then sent back over the returned Receiver<R::P> channel for the caller to use. The results will be returned in order according to the order of the intervals used to drive this method.

While one ‘super chunk’ is being worked on by all workers, the last ‘super chunks’ results are being printed to either to a file or to STDOUT, in order.

Note, a common use case of this will be to fetch a region and do a pileup. The bounds of bases being looked at should still be checked since a fetch will pull all reads that overlap the region in question.

Trait Implementations

impl<R: Debug + 'static + RegionProcessor + Send + Sync> Debug for ParGranges<R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.