Struct SamStats 

pub struct SamStats {

    pub total_reads: usize,
    pub mapped_reads: usize,
    pub unmapped_reads: usize,
    pub properly_paired: usize,
    pub duplicates: usize,
    pub secondary_alignments: usize,
    pub supplementary_alignments: usize,
    pub qc_failed: usize,
    pub mapq_stats: RunningStats,
    pub mapq_distribution: CategoryCounter<u8>,
    pub length_stats: RunningStats,
    pub length_distribution: CategoryCounter<usize>,
    pub reads_per_chrom: CategoryCounter<String>,
    pub high_quality_mapq10: usize,
    pub high_quality_mapq20: usize,
    pub high_quality_mapq30: usize,
    pub first_in_pair: usize,
    pub second_in_pair: usize,
    pub reverse_strand: usize,
    pub total_matches: u64,
    pub total_insertions: u64,
    pub total_deletions: u64,
    pub total_soft_clips: u64,
    pub total_hard_clips: u64,
}

Comprehensive statistics for SAM files

Fields

total_reads: usize

Total number of reads

mapped_reads: usize

Number of mapped reads

unmapped_reads: usize

Number of unmapped reads

properly_paired: usize

Number of reads mapped in proper pairs

duplicates: usize

Number of duplicate reads

secondary_alignments: usize

Number of secondary alignments

supplementary_alignments: usize

Number of supplementary alignments

qc_failed: usize

Number of QC-failed reads

mapq_stats: RunningStats

Mapping quality statistics (for mapped reads only)

mapq_distribution: CategoryCounter<u8>

Distribution of mapping qualities

length_stats: RunningStats

Read length statistics

length_distribution: CategoryCounter<usize>

Distribution of read lengths

reads_per_chrom: CategoryCounter<String>

Reads per chromosome

high_quality_mapq10: usize

Number of reads with MAPQ >= 10

high_quality_mapq20: usize

Number of reads with MAPQ >= 20

high_quality_mapq30: usize

Number of reads with MAPQ >= 30

first_in_pair: usize

Paired-end statistics

second_in_pair: usize

reverse_strand: usize

total_matches: u64

CIGAR operation statistics

total_insertions: u64

total_deletions: u64

total_soft_clips: u64

total_hard_clips: u64

Implementations

impl SamStats

pub fn new() -> Self

Create a new statistics collector

pub fn update(&mut self, record: &SamRecord)

Update statistics with a single record (streaming)

Optimized for single-pass processing: computes all statistics in one iteration over alignment data, avoiding repeated allocations and iterations.

pub fn par_compute(_reader: &mut SamReader, _threads: usize) -> Result<Self>

Compute statistics in parallel (not yet implemented for SAM)

SAM files are text-based and harder to parallelize efficiently than binary BAM files. For now, use compute() for sequential processing, which is still fast.

Future implementation may support:

• Chunked parallel processing with line-boundary detection
• Memory-mapped file access with parallel scanning

For parallel statistics on alignment files, consider using BAM format instead.

pub fn compute(reader: &mut SamReader) -> Result<Self>

Compute statistics from a SAM reader (sequential processing)

SAM files are text-based, so parallel processing is more complex than BAM. For now, we use sequential processing which is still very fast for text parsing.

Example

use genomicframe_core::formats::sam::{SamReader, SamStats};

let mut reader = SamReader::from_path("alignments.sam")?;
reader.read_header()?;
let stats = SamStats::compute(&mut reader)?;
stats.print_summary();

pub fn mean_length(&self) -> Option<f64>

Mean read length

pub fn std_length(&self) -> Option<f64>

Standard deviation of read length

pub fn min_length(&self) -> Option<f64>

Min read length

pub fn max_length(&self) -> Option<f64>

Max read length

pub fn mean_mapq(&self) -> Option<f64>

Mean mapping quality (for mapped reads)

pub fn std_mapq(&self) -> Option<f64>

Standard deviation of mapping quality

pub fn mapping_rate(&self) -> f64

Mapping rate (percentage of mapped reads)

pub fn properly_paired_rate(&self) -> f64

Properly paired rate (percentage of properly paired reads)

pub fn duplicate_rate(&self) -> f64

Duplicate rate (percentage of duplicate reads)

pub fn percent_mapq10(&self) -> f64

Percentage of reads with MAPQ >= 10

pub fn percent_mapq20(&self) -> f64

Percentage of reads with MAPQ >= 20

pub fn percent_mapq30(&self) -> f64

Percentage of reads with MAPQ >= 30

pub fn print_summary(&self)

Print a human-readable summary of statistics

Trait Implementations

impl Clone for SamStats

fn clone(&self) -> SamStats

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SamStats

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

Formats the value using the given formatter.

impl Default for SamStats

fn default() -> Self

Returns the “default value” for a type.

impl Mergeable for SamStats

Implementation of Mergeable for parallel statistics computation

Merges SAM statistics from multiple threads/chunks. All statistics are correctly combined using the underlying Mergeable implementations for RunningStats and CategoryCounter.

fn merge(&mut self, other: Self)

Merge another stats object into this one

fn merge_all(stats: Vec<Self>) -> Option<Self>

Merge multiple stats objects into one (convenience method)