Struct InputMods 

#[non_exhaustive]
pub struct InputMods<S: TagState + Args + FromArgMatches + Default> {
    pub tag: S,
    pub mod_strand: Option<RestrictModCalledStrand>,
    pub mod_prob_filter: ThresholdState,
    pub trim_read_ends_mod: usize,
    pub base_qual_filter_mod: u8,
    pub mod_region: Option<GenomicRegion>,
    pub region_bed3: Option<Bed3<i32, u64>>,
}

This struct contains the options input to our modification-data functions with restrictions on data received.

If you want to build this, use InputModsBuilder. In CLI mode, clap populates this struct. This and the InputBam struct are used to set almost all input options to many of our functions that process BAM/modBAM files.

Examples

Please look at the documentation of InputBam to see a fully-worked example to set up inputs to perform a calculation.

Following example uses many fields and is for a RequiredTag variant. You can omit some of them depending on your use case. mod_region must can be converted to region_bed3 using GenomicRegion::try_to_bed3 with a suitable BAM header before this struct can be used with most of our functions. We do not force this in the builder route as we may not want to do this for some reason.

use nanalogue_core::{InputModsBuilder, Error, RequiredTag, ThresholdState};
use std::str::FromStr;

let input_options = InputModsBuilder::default()
    .tag(RequiredTag::from_str("m")?)
    .mod_strand("bc".into())
    .mod_prob_filter(ThresholdState::GtEq(0))
    .trim_read_ends_mod(10)
    .base_qual_filter_mod(10)
    .mod_region("chr3:4000-5000".into())
    .build()?;

A RequiredTag variant that sets region_bed3 instead of mod_region. If mod_region is set, then a downstream function must parse a BAM file, and then convert mod_region into region_bed3 using the header. If the user is confident that they know the index number of a contig, then they can directly set region_bed3. In the example below, the user knows chr3 corresponds to 4, so they set the region directly.

use bedrs::prelude::Bed3;
use nanalogue_core::{InputModsBuilder, Error, RequiredTag, ThresholdState};
use std::str::FromStr;

let input_options = InputModsBuilder::<RequiredTag>::default()
    .tag(RequiredTag::from_str("m")?)
    .mod_strand("bc".into())
    .mod_prob_filter(ThresholdState::GtEq(0))
    .trim_read_ends_mod(10)
    .base_qual_filter_mod(10)
    .region_bed3(Bed3::<i32, u64>::new(4, 4000, 5000))
    .build()?;

Setting both region_bed3 and mod_region should result in an error, even if they both refer to the same region. This is because setting both can result in an undefined state, so we do not allow this.

use bedrs::prelude::Bed3;
use nanalogue_core::{InputModsBuilder, Error, RequiredTag, ThresholdState};
use std::str::FromStr;

let input_options = InputModsBuilder::<RequiredTag>::default()
    .mod_prob_filter(ThresholdState::GtEq(0))
    .region_bed3(Bed3::<i32, u64>::new(4, 4000, 5000))
    .mod_region("chr3:4000-5000".into())
    .build()?;

Following example is for an OptionalTag variant with the tag omitted, and many other fields omitted as well, which take on a default value.

use nanalogue_core::{InputModsBuilder, Error, OptionalTag, ThresholdState};
use std::str::FromStr;

let input_options = InputModsBuilder::<OptionalTag>::default()
    .mod_prob_filter(ThresholdState::GtEq(0))
    .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.

tag: S

modified tag

mod_strand: Option<RestrictModCalledStrand>

modified strand, set this to bc or bc_comp, meaning on basecalled strand or its complement. Some technologies like PacBio or ONT duplex can call mod data on both a strand and its complementary DNA and store it in the record corresponding to the strand, so you can use this filter to select only for mod data on a strand or its complement. Please note that this filter is different from selecting for forward or reverse aligned reads using the BAM flags.

mod_prob_filter: ThresholdState

Filter to reject mods before analysis. Specify as low,high where both are fractions to reject modifications where the probabilities (p) are in this range e.g. “0.4,0.6” rejects 0.4 <= p <= 0.6. You can use this to reject ‘weak’ modification calls before analysis i.e. those with probabilities close to 0.5. NOTE: (1) Whether this filtration is applied or not, mods < 0.5 are considered unmodified and >= 0.5 are considered modified by our program. (2) mod probabilities are stored as a number from 0-255 in the modBAM format, so we internally convert 0.0-1.0 to 0-255. Default: reject nothing.

trim_read_ends_mod: usize

Filter this many bp at the start and end of a read before any mod operations. Please note that the units here are bp and not units of base being queried.

base_qual_filter_mod: u8

Exclude bases whose base quality is below this threshold before any mod operation, defaults to 0 i.e. unused. NOTE: (1) This step is only applied before modification operations, and not before any other operations. (2) No offsets such as +33 are needed here. (3) Modifications on reads where base quality information is not available are all rejected if this is non-zero.

mod_region: Option<GenomicRegion>

Only keep modification data from this region

region_bed3: Option<Bed3<i32, u64>>

Only keep modification data from this region. We do not expose this to the user, but infer it from the other options set by the user. We cannot populate this directly at the time of CLI parsing, as we need to look at the BAM header to convert a contig name into a numeric contig id.

Implementations

impl InputMods<RequiredTag>

can return tag without encasing in an option in the RequiredTag variant

pub fn required_tag(&self) -> ModChar

retrieves tag

Trait Implementations

impl<S: TagState + Args + FromArgMatches + Default> Args for InputMods<S>

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

impl<S: Clone + TagState + Args + FromArgMatches + Default> Clone for InputMods<S>

fn clone(&self) -> InputMods<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug + TagState + Args + FromArgMatches + Default> Debug for InputMods<S>

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

Formats the value using the given formatter.

impl<S: TagState + Args + FromArgMatches + Default> Default for InputMods<S>

Implements defaults for InputMods

fn default() -> Self

Returns the “default value” for a type.

impl<'de, S> Deserialize<'de> for InputMods<S>

where InputMods<S>: Default, S: Deserialize<'de> + TagState + Args + FromArgMatches + Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S: TagState + Args + FromArgMatches + Default> FromArgMatches for InputMods<S>

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl<S: TagState + Args + FromArgMatches + Default> InputModOptions for InputMods<S>

fn tag(&self) -> Option<ModChar>

retrieves tag

fn mod_strand(&self) -> Option<RestrictModCalledStrand>

retrieves option to set basecalled strand or opposite in mod retrieval

fn mod_prob_filter(&self) -> ThresholdState

returns probability filter

fn trim_read_ends_mod(&self) -> usize

returns read end trimming

fn base_qual_filter_mod(&self) -> u8

returns threshold for filtering base PHRED quality

impl<S: TagState + Args + FromArgMatches + Default> InputRegionOptions for InputMods<S>

fn region_filter_genomic_string(&self) -> Option<GenomicRegion>

returns region requested but region in genomic string format

fn region_filter(&self) -> &Option<Bed3<i32, u64>>

returns region requested

fn set_region_filter(&mut self, value: Option<Bed3<i32, u64>>)

sets region requested

fn is_full_overlap(&self) -> bool

returns true if full overlap with region is requested as opposed to only partial overlap. defaults to false.

fn convert_region_to_bed3(&mut self, header: HeaderView) -> Result<(), Error>

converts region from genomic string representation to bed3 representation

impl<S> Serialize for InputMods<S>

where S: Serialize + TagState + Args + FromArgMatches + Default,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.