Struct ReadConfig 

#[non_exhaustive]
pub struct ReadConfig {
    pub number: NonZeroU32,
    pub mapq_range: OrdPair<u8>,
    pub base_qual_range: OrdPair<u8>,
    pub len_range: OrdPair<F32Bw0and1>,
    pub barcode: Option<DNARestrictive>,
    pub delete: Option<OrdPair<F32Bw0and1>>,
    pub insert_middle: Option<DNARestrictive>,
    pub mismatch: Option<F32Bw0and1>,
    pub mods: Vec<ModConfig>,
}

Configuration for read generation. Also refer to SimulationConfig to see how this struct can be used, and to ReadConfigBuilder for how to build this (as shown below in the examples).

Example 1

Request reads without modifications

use nanalogue_core::Error;
use nanalogue_core::simulate_mod_bam::ReadConfigBuilder;

// First set of reads
let read_config1 = ReadConfigBuilder::default()
    .number(100)
    .mapq_range((10, 20))
    .base_qual_range((30, 40))
    .len_range((0.5, 0.6)).build()?;

Example 2

Request reads with modifications, but also with insertions, deletions, and a mismatch rate.

use nanalogue_core::Error;
use nanalogue_core::simulate_mod_bam::{ReadConfigBuilder, ModConfigBuilder};

let mod_config = ModConfigBuilder::default()
    .base('C')
    .is_strand_plus(true)
    .mod_code("m".into())
    .win(vec![2, 3])
    .mod_range(vec![(0.1, 0.8), (0.3, 0.4)]).build()?;

let read_config2 = ReadConfigBuilder::default()
    .number(200)
    .mapq_range((30, 40))
    .base_qual_range((50, 60))
    .barcode("AATTG".into())
    .len_range((0.7, 0.8))
    .delete((0.2, 0.3))
    .insert_middle("ATCGA".into())
    .mismatch(0.1)
    .mods(vec![mod_config]).build()?;

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

number: NonZeroU32

Total number of reads to generate

mapq_range: OrdPair<u8>

Mapping quality range [min, max]

base_qual_range: OrdPair<u8>

Base quality score range [min, max]

len_range: OrdPair<F32Bw0and1>

Read length range as fraction of contig [min, max] (e.g.: [0.1, 0.8] = 10% to 80%)

barcode: Option<DNARestrictive>

Optional barcode DNA sequence to add to read ends

delete: Option<OrdPair<F32Bw0and1>>

Optional deletion: fractional range [start, end] of read to delete (e.g., [0.5, 0.7] deletes middle 20%)

insert_middle: Option<DNARestrictive>

Optional sequence to insert at the middle of the read

mismatch: Option<F32Bw0and1>

Optional mismatch fraction: random fraction of bases to mutate (e.g., 0.5 = 50% of bases)

mods: Vec<ModConfig>

Modification configurations

Trait Implementations

impl Clone for ReadConfig

fn clone(&self) -> ReadConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReadConfig

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

Formats the value using the given formatter.

impl Default for ReadConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ReadConfig

where ReadConfig: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ReadConfig

fn eq(&self, other: &ReadConfig) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ReadConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ReadConfig