Struct Aligner

pub struct Aligner<S: BuilderState> {
    pub idxopt: IdxOpt,
    pub mapopt: MapOpt,
    pub threads: usize,
    pub idx: Option<Arc<MmIdx>>,
    pub idx_reader: Option<Arc<mm_idx_reader_t>>,
    pub cigar_clipping: bool,
    /* private fields */
}

Aligner struct, mimicking minimap2’s python interface

Aligner::builder();

Fields

idxopt: IdxOpt

Index options passed to minimap2 (mm_idxopt_t)

mapopt: MapOpt

Mapping options passed to minimap2 (mm_mapopt_t)

threads: usize

Number of threads to create the index with

idx: Option<Arc<MmIdx>>

Index created by minimap2

idx_reader: Option<Arc<mm_idx_reader_t>>

Index reader created by minimap2

cigar_clipping: bool

Whether to add soft clipping to CIGAR result

Implementations

impl Aligner<Built>

pub fn populate_header(&self, header: &mut Header)

pub fn map_to_sam( &self, seq: &[u8], qual: Option<&[u8]>, name: Option<&[u8]>, header: &HeaderView, max_frag_len: Option<usize>, extra_flags: Option<Vec<u64>>, ) -> Result<Vec<Record>, &'static str>

impl Aligner<()>

pub fn builder() -> Aligner<Unset>

Create a new aligner with default options

Examples found in repository

examples/rayon.rs (line 47)

fn map(
    target_file: impl AsRef<Path>,
    query_file: impl AsRef<Path>,
    threads: usize,
) -> Result<(), Box<dyn Error>> {
    // Set the number of threads to use
    rayon::ThreadPoolBuilder::new()
        .num_threads(threads)
        .build_global()
        .expect("Unable to set number of threads");

    println!("Creating index");

    // Aligner gets created using the build pattern.
    // Once .with_index is called, the aligner is set to "Built" and can no longer be changed.
    let aligner = Aligner::builder()
        .map_ont()
        .with_cigar()
        .with_index_threads(threads) // Minimap2 uses it's own thread pool for index building
        .with_index(target_file, None)
        .expect("Unable to build index");

    println!("Index created");

    // Read in the query file
    let mut reader = parse_fastx_file(query_file)?;

    let mut queries: Vec<(Vec<u8>, Vec<u8>)> = Vec::new();
    while let Some(record) = reader.next() {
        let record = record.expect("Error reading record");
        queries.push((record.id().to_vec(), record.seq().to_vec()));
    }

    // Map the queries
    let results: Vec<Vec<Mapping>> = queries
        .par_iter()
        .map(|(id, seq)| {
            aligner
                .map(&seq, false, false, None, None, Some(&id))
                .expect("Error mapping")
        })
        .collect();

    // Count total number of alignments
    let total_alignments: usize = results.iter().map(|x| x.len()).sum();
    println!("Iteration complete, total alignments {}", total_alignments);

    Ok(())
}

examples/channels.rs (line 58)

fn map(
    target_file: impl AsRef<Path>,
    query_file: impl AsRef<Path>,
    threads: usize,
) -> Result<(), Box<dyn Error>> {
    // Aligner gets created using the build pattern.
    // Once .with_index is called, the aligner is set to "Built" and can no longer be changed.
    println!("Creating index");
    let aligner = Aligner::builder()
        .map_ont()
        .with_cigar()
        .with_index_threads(threads)
        .with_index(target_file, None)
        .expect("Unable to build index");

    println!("Index created");

    // Create a queue for work and for results
    let work_queue = Arc::new(ArrayQueue::<WorkQueue<WorkUnit>>::new(1024));
    let results_queue = Arc::new(ArrayQueue::<WorkQueue<WorkResult>>::new(1024));

    // I use a shutdown flag
    let shutdown = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));

    // Store join handles, it's just good practice to clean up threads
    let mut jh = Vec::new();

    let aligner = Arc::new(aligner);

    // Spin up the threads
    for _ in 0..threads {
        // Clone everything we will need...
        let work_queue = Arc::clone(&work_queue);
        let results_queue = Arc::clone(&results_queue);
        let shutdown = Arc::clone(&shutdown);
        let aligner = Arc::clone(&aligner);

        let handle =
            std::thread::spawn(move || worker(work_queue, results_queue, shutdown, aligner));

        jh.push(handle);
    }

    // Let's split this into another thread

    {
        let work_queue = Arc::clone(&work_queue);
        let shutdown = Arc::clone(&shutdown);
        let query_file = query_file.as_ref().to_path_buf();

        let handle = std::thread::spawn(move || {
            // Now that the threads are running, read the input file and push the work to the queue
            let mut reader: Box<dyn FastxReader> =
                parse_fastx_file(query_file).unwrap_or_else(|_| panic!("Can't find query FASTA file"));

            // I just do this in the main thread, but you can split threads
            let backoff = crossbeam::utils::Backoff::new();
            while let Some(Ok(record)) = reader.next() {
                let mut work = WorkQueue::Work((record.id().to_vec(), record.seq().to_vec()));
                while let Err(work_packet) = work_queue.push(work) {
                    work = work_packet; // Simple way to maintain ownership
                                        // If we have an error, it's 99% because the queue is full
                    backoff.snooze();
                }
            }

            // Set the shutdown flag
            shutdown.store(true, std::sync::atomic::Ordering::Relaxed);
        });

        jh.push(handle);
    }

    let mut num_alignments = 0;

    let backoff = crossbeam::utils::Backoff::new();
    loop {
        match results_queue.pop() {
            // This is where we processs mapping results as they come in...
            Some(WorkQueue::Result((record, alignments))) => {
                num_alignments += alignments.len();

            }
            Some(_) => unimplemented!("Unexpected result type"),
            None => {
                backoff.snooze();

                // If all join handles are finished, we can break
                if jh.iter().all(|h| h.is_finished()) {
                    break;
                }
                if backoff.is_completed() {
                    backoff.reset();
                    std::thread::sleep(Duration::from_millis(3));
                }
            }
        }
    }

    // Join all the threads
    for handle in jh {
        handle.join().expect("Unable to join thread");
    }

    println!("Total alignments: {}", num_alignments);

    Ok(())
}

impl Aligner<Unset>

pub fn lrhq(self) -> Aligner<PresetSet>

Ergonomic function for Aligner. Sets the minimap2 preset to lr:hq.

Presets should be called before any other options are set, as they change multiple options at once.

pub fn splice(self) -> Aligner<PresetSet>

Ergonomic function for Aligner. Sets the minimap2 preset to splice

Presets should be called before any other options are set, as they change multiple options at once.

Aligner::builder().splice();

pub fn splice_hq(self) -> Aligner<PresetSet>

Ergonomic function for Aligner. Sets the minimap2 preset to splice:hq

Presets should be called before any other options are set, as they change multiple options at once.

Aligner::builder().splice_hq();

pub fn asm(self) -> Aligner<PresetSet>

Ergonomic function for Aligner. Sets the minimap2 preset to Asm

Presets should be called before any other options are set, as they change multiple options at once.

Aligner::builder().asm();

pub fn asm5(self) -> Aligner<PresetSet>

Ergonomic function for Aligner. Sets the minimap2 preset to Asm5

Presets should be called before any other options are set, as they change multiple options at once.

Aligner::builder().asm5();

pub fn asm10(self) -> Aligner<PresetSet>

Ergonomic function for Aligner. Sets the minimap2 preset to Asm10

Presets should be called before any other options are set, as they change multiple options at once.

Aligner::builder().asm10();

pub fn asm20(self) -> Aligner<PresetSet>

Ergonomic function for Aligner. Sets the minimap2 preset to Asm20

Presets should be called before any other options are set, as they change multiple options at once.

Aligner::builder().asm20();

pub fn sr(self) -> Aligner<PresetSet>

Ergonomic function for Aligner. Sets the minimap2 preset to sr

Presets should be called before any other options are set, as they change multiple options at once.

Aligner::builder().sr();

pub fn map_pb(self) -> Aligner<PresetSet>

Ergonomic function for Aligner. Sets the minimap2 preset to MapPb

Presets should be called before any other options are set, as they change multiple options at once.

Aligner::builder().map_pb();

pub fn map_hifi(self) -> Aligner<PresetSet>

Ergonomic function for Aligner. Sets the minimap2 preset to MapHifi

Presets should be called before any other options are set, as they change multiple options at once.

Aligner::builder().map_hifi();

pub fn map_ont(self) -> Aligner<PresetSet>

Ergonomic function for Aligner. Sets the minimap2 preset to MapOnt.

Presets should be called before any other options are set, as they change multiple options at once.

Aligner::builder().map_ont();

Examples found in repository

examples/rayon.rs (line 48)

fn map(
    target_file: impl AsRef<Path>,
    query_file: impl AsRef<Path>,
    threads: usize,
) -> Result<(), Box<dyn Error>> {
    // Set the number of threads to use
    rayon::ThreadPoolBuilder::new()
        .num_threads(threads)
        .build_global()
        .expect("Unable to set number of threads");

    println!("Creating index");

    // Aligner gets created using the build pattern.
    // Once .with_index is called, the aligner is set to "Built" and can no longer be changed.
    let aligner = Aligner::builder()
        .map_ont()
        .with_cigar()
        .with_index_threads(threads) // Minimap2 uses it's own thread pool for index building
        .with_index(target_file, None)
        .expect("Unable to build index");

    println!("Index created");

    // Read in the query file
    let mut reader = parse_fastx_file(query_file)?;

    let mut queries: Vec<(Vec<u8>, Vec<u8>)> = Vec::new();
    while let Some(record) = reader.next() {
        let record = record.expect("Error reading record");
        queries.push((record.id().to_vec(), record.seq().to_vec()));
    }

    // Map the queries
    let results: Vec<Vec<Mapping>> = queries
        .par_iter()
        .map(|(id, seq)| {
            aligner
                .map(&seq, false, false, None, None, Some(&id))
                .expect("Error mapping")
        })
        .collect();

    // Count total number of alignments
    let total_alignments: usize = results.iter().map(|x| x.len()).sum();
    println!("Iteration complete, total alignments {}", total_alignments);

    Ok(())
}

examples/channels.rs (line 59)

fn map(
    target_file: impl AsRef<Path>,
    query_file: impl AsRef<Path>,
    threads: usize,
) -> Result<(), Box<dyn Error>> {
    // Aligner gets created using the build pattern.
    // Once .with_index is called, the aligner is set to "Built" and can no longer be changed.
    println!("Creating index");
    let aligner = Aligner::builder()
        .map_ont()
        .with_cigar()
        .with_index_threads(threads)
        .with_index(target_file, None)
        .expect("Unable to build index");

    println!("Index created");

    // Create a queue for work and for results
    let work_queue = Arc::new(ArrayQueue::<WorkQueue<WorkUnit>>::new(1024));
    let results_queue = Arc::new(ArrayQueue::<WorkQueue<WorkResult>>::new(1024));

    // I use a shutdown flag
    let shutdown = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));

    // Store join handles, it's just good practice to clean up threads
    let mut jh = Vec::new();

    let aligner = Arc::new(aligner);

    // Spin up the threads
    for _ in 0..threads {
        // Clone everything we will need...
        let work_queue = Arc::clone(&work_queue);
        let results_queue = Arc::clone(&results_queue);
        let shutdown = Arc::clone(&shutdown);
        let aligner = Arc::clone(&aligner);

        let handle =
            std::thread::spawn(move || worker(work_queue, results_queue, shutdown, aligner));

        jh.push(handle);
    }

    // Let's split this into another thread

    {
        let work_queue = Arc::clone(&work_queue);
        let shutdown = Arc::clone(&shutdown);
        let query_file = query_file.as_ref().to_path_buf();

        let handle = std::thread::spawn(move || {
            // Now that the threads are running, read the input file and push the work to the queue
            let mut reader: Box<dyn FastxReader> =
                parse_fastx_file(query_file).unwrap_or_else(|_| panic!("Can't find query FASTA file"));

            // I just do this in the main thread, but you can split threads
            let backoff = crossbeam::utils::Backoff::new();
            while let Some(Ok(record)) = reader.next() {
                let mut work = WorkQueue::Work((record.id().to_vec(), record.seq().to_vec()));
                while let Err(work_packet) = work_queue.push(work) {
                    work = work_packet; // Simple way to maintain ownership
                                        // If we have an error, it's 99% because the queue is full
                    backoff.snooze();
                }
            }

            // Set the shutdown flag
            shutdown.store(true, std::sync::atomic::Ordering::Relaxed);
        });

        jh.push(handle);
    }

    let mut num_alignments = 0;

    let backoff = crossbeam::utils::Backoff::new();
    loop {
        match results_queue.pop() {
            // This is where we processs mapping results as they come in...
            Some(WorkQueue::Result((record, alignments))) => {
                num_alignments += alignments.len();

            }
            Some(_) => unimplemented!("Unexpected result type"),
            None => {
                backoff.snooze();

                // If all join handles are finished, we can break
                if jh.iter().all(|h| h.is_finished()) {
                    break;
                }
                if backoff.is_completed() {
                    backoff.reset();
                    std::thread::sleep(Duration::from_millis(3));
                }
            }
        }
    }

    // Join all the threads
    for handle in jh {
        handle.join().expect("Unable to join thread");
    }

    println!("Total alignments: {}", num_alignments);

    Ok(())
}

pub fn ava_pb(self) -> Aligner<PresetSet>

Ergonomic function for Aligner. Sets the minimap2 preset to AvaPb

Presets should be called before any other options are set, as they change multiple options at once.

Aligner::builder().ava_pb();

pub fn ava_ont(self) -> Aligner<PresetSet>

Ergonomic function for Aligner. Sets the minimap2 preset to AvaOnt.

Presets should be called before any other options are set, as they change multiple options at once.

Aligner::builder().ava_ont();

pub fn short(self) -> Aligner<PresetSet>

Ergonomic function for Aligner. Sets the minimap2 preset to Short

Presets should be called before any other options are set, as they change multiple options at once.

Aligner::builder().short();

pub fn map10k(self) -> Aligner<PresetSet>

Ergonomic function for Aligner. Sets the minimap2 preset to Map10k

Presets should be called before any other options are set, as they change multiple options at once.

Aligner::builder().map10k();

pub fn cdna(self) -> Aligner<PresetSet>

Ergonomic function for Aligner. Sets the minimap2 preset to cdna

Presets should be called before any other options are set, as they change multiple options at once.

Aligner::builder().cdna();

pub fn preset(self, preset: Preset) -> Aligner<PresetSet>

Create an aligner using a preset.

Presets should be called before any other options are set, as they change multiple options at once.

impl<S> Aligner<S>

where S: BuilderState + AcceptsParams,

pub fn with_cigar(self) -> Self

Set Alignment mode / cigar mode in minimap2

Aligner::builder().map_ont().with_cigar();

Examples found in repository

examples/rayon.rs (line 49)

fn map(
    target_file: impl AsRef<Path>,
    query_file: impl AsRef<Path>,
    threads: usize,
) -> Result<(), Box<dyn Error>> {
    // Set the number of threads to use
    rayon::ThreadPoolBuilder::new()
        .num_threads(threads)
        .build_global()
        .expect("Unable to set number of threads");

    println!("Creating index");

    // Aligner gets created using the build pattern.
    // Once .with_index is called, the aligner is set to "Built" and can no longer be changed.
    let aligner = Aligner::builder()
        .map_ont()
        .with_cigar()
        .with_index_threads(threads) // Minimap2 uses it's own thread pool for index building
        .with_index(target_file, None)
        .expect("Unable to build index");

    println!("Index created");

    // Read in the query file
    let mut reader = parse_fastx_file(query_file)?;

    let mut queries: Vec<(Vec<u8>, Vec<u8>)> = Vec::new();
    while let Some(record) = reader.next() {
        let record = record.expect("Error reading record");
        queries.push((record.id().to_vec(), record.seq().to_vec()));
    }

    // Map the queries
    let results: Vec<Vec<Mapping>> = queries
        .par_iter()
        .map(|(id, seq)| {
            aligner
                .map(&seq, false, false, None, None, Some(&id))
                .expect("Error mapping")
        })
        .collect();

    // Count total number of alignments
    let total_alignments: usize = results.iter().map(|x| x.len()).sum();
    println!("Iteration complete, total alignments {}", total_alignments);

    Ok(())
}

examples/channels.rs (line 60)

fn map(
    target_file: impl AsRef<Path>,
    query_file: impl AsRef<Path>,
    threads: usize,
) -> Result<(), Box<dyn Error>> {
    // Aligner gets created using the build pattern.
    // Once .with_index is called, the aligner is set to "Built" and can no longer be changed.
    println!("Creating index");
    let aligner = Aligner::builder()
        .map_ont()
        .with_cigar()
        .with_index_threads(threads)
        .with_index(target_file, None)
        .expect("Unable to build index");

    println!("Index created");

    // Create a queue for work and for results
    let work_queue = Arc::new(ArrayQueue::<WorkQueue<WorkUnit>>::new(1024));
    let results_queue = Arc::new(ArrayQueue::<WorkQueue<WorkResult>>::new(1024));

    // I use a shutdown flag
    let shutdown = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));

    // Store join handles, it's just good practice to clean up threads
    let mut jh = Vec::new();

    let aligner = Arc::new(aligner);

    // Spin up the threads
    for _ in 0..threads {
        // Clone everything we will need...
        let work_queue = Arc::clone(&work_queue);
        let results_queue = Arc::clone(&results_queue);
        let shutdown = Arc::clone(&shutdown);
        let aligner = Arc::clone(&aligner);

        let handle =
            std::thread::spawn(move || worker(work_queue, results_queue, shutdown, aligner));

        jh.push(handle);
    }

    // Let's split this into another thread

    {
        let work_queue = Arc::clone(&work_queue);
        let shutdown = Arc::clone(&shutdown);
        let query_file = query_file.as_ref().to_path_buf();

        let handle = std::thread::spawn(move || {
            // Now that the threads are running, read the input file and push the work to the queue
            let mut reader: Box<dyn FastxReader> =
                parse_fastx_file(query_file).unwrap_or_else(|_| panic!("Can't find query FASTA file"));

            // I just do this in the main thread, but you can split threads
            let backoff = crossbeam::utils::Backoff::new();
            while let Some(Ok(record)) = reader.next() {
                let mut work = WorkQueue::Work((record.id().to_vec(), record.seq().to_vec()));
                while let Err(work_packet) = work_queue.push(work) {
                    work = work_packet; // Simple way to maintain ownership
                                        // If we have an error, it's 99% because the queue is full
                    backoff.snooze();
                }
            }

            // Set the shutdown flag
            shutdown.store(true, std::sync::atomic::Ordering::Relaxed);
        });

        jh.push(handle);
    }

    let mut num_alignments = 0;

    let backoff = crossbeam::utils::Backoff::new();
    loop {
        match results_queue.pop() {
            // This is where we processs mapping results as they come in...
            Some(WorkQueue::Result((record, alignments))) => {
                num_alignments += alignments.len();

            }
            Some(_) => unimplemented!("Unexpected result type"),
            None => {
                backoff.snooze();

                // If all join handles are finished, we can break
                if jh.iter().all(|h| h.is_finished()) {
                    break;
                }
                if backoff.is_completed() {
                    backoff.reset();
                    std::thread::sleep(Duration::from_millis(3));
                }
            }
        }
    }

    // Join all the threads
    for handle in jh {
        handle.join().expect("Unable to join thread");
    }

    println!("Total alignments: {}", num_alignments);

    Ok(())
}

pub fn with_cigar_clipping(self) -> Self

pub fn with_sam_out(self) -> Self

pub fn with_sam_hit_only(self) -> Self

pub fn with_gap_open_penalty( self, penalty: i32, penalty_long: Option<i32>, ) -> Self

Sets the gap open penalty for minimap2.

minimap2 -O 4 sets both the short and long gap open penalty to 4. minimap2 code

To set the long gap open penalty, simply provide a value for penalty_long.

pub fn with_index_threads(self, threads: usize) -> Self

Sets the number of threads minimap2 will use for building the index

Aligner::builder().with_index_threads(10);

Set the number of threads (prefer to use the struct config)

Examples found in repository

examples/rayon.rs (line 50)

fn map(
    target_file: impl AsRef<Path>,
    query_file: impl AsRef<Path>,
    threads: usize,
) -> Result<(), Box<dyn Error>> {
    // Set the number of threads to use
    rayon::ThreadPoolBuilder::new()
        .num_threads(threads)
        .build_global()
        .expect("Unable to set number of threads");

    println!("Creating index");

    // Aligner gets created using the build pattern.
    // Once .with_index is called, the aligner is set to "Built" and can no longer be changed.
    let aligner = Aligner::builder()
        .map_ont()
        .with_cigar()
        .with_index_threads(threads) // Minimap2 uses it's own thread pool for index building
        .with_index(target_file, None)
        .expect("Unable to build index");

    println!("Index created");

    // Read in the query file
    let mut reader = parse_fastx_file(query_file)?;

    let mut queries: Vec<(Vec<u8>, Vec<u8>)> = Vec::new();
    while let Some(record) = reader.next() {
        let record = record.expect("Error reading record");
        queries.push((record.id().to_vec(), record.seq().to_vec()));
    }

    // Map the queries
    let results: Vec<Vec<Mapping>> = queries
        .par_iter()
        .map(|(id, seq)| {
            aligner
                .map(&seq, false, false, None, None, Some(&id))
                .expect("Error mapping")
        })
        .collect();

    // Count total number of alignments
    let total_alignments: usize = results.iter().map(|x| x.len()).sum();
    println!("Iteration complete, total alignments {}", total_alignments);

    Ok(())
}

examples/channels.rs (line 61)

fn map(
    target_file: impl AsRef<Path>,
    query_file: impl AsRef<Path>,
    threads: usize,
) -> Result<(), Box<dyn Error>> {
    // Aligner gets created using the build pattern.
    // Once .with_index is called, the aligner is set to "Built" and can no longer be changed.
    println!("Creating index");
    let aligner = Aligner::builder()
        .map_ont()
        .with_cigar()
        .with_index_threads(threads)
        .with_index(target_file, None)
        .expect("Unable to build index");

    println!("Index created");

    // Create a queue for work and for results
    let work_queue = Arc::new(ArrayQueue::<WorkQueue<WorkUnit>>::new(1024));
    let results_queue = Arc::new(ArrayQueue::<WorkQueue<WorkResult>>::new(1024));

    // I use a shutdown flag
    let shutdown = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));

    // Store join handles, it's just good practice to clean up threads
    let mut jh = Vec::new();

    let aligner = Arc::new(aligner);

    // Spin up the threads
    for _ in 0..threads {
        // Clone everything we will need...
        let work_queue = Arc::clone(&work_queue);
        let results_queue = Arc::clone(&results_queue);
        let shutdown = Arc::clone(&shutdown);
        let aligner = Arc::clone(&aligner);

        let handle =
            std::thread::spawn(move || worker(work_queue, results_queue, shutdown, aligner));

        jh.push(handle);
    }

    // Let's split this into another thread

    {
        let work_queue = Arc::clone(&work_queue);
        let shutdown = Arc::clone(&shutdown);
        let query_file = query_file.as_ref().to_path_buf();

        let handle = std::thread::spawn(move || {
            // Now that the threads are running, read the input file and push the work to the queue
            let mut reader: Box<dyn FastxReader> =
                parse_fastx_file(query_file).unwrap_or_else(|_| panic!("Can't find query FASTA file"));

            // I just do this in the main thread, but you can split threads
            let backoff = crossbeam::utils::Backoff::new();
            while let Some(Ok(record)) = reader.next() {
                let mut work = WorkQueue::Work((record.id().to_vec(), record.seq().to_vec()));
                while let Err(work_packet) = work_queue.push(work) {
                    work = work_packet; // Simple way to maintain ownership
                                        // If we have an error, it's 99% because the queue is full
                    backoff.snooze();
                }
            }

            // Set the shutdown flag
            shutdown.store(true, std::sync::atomic::Ordering::Relaxed);
        });

        jh.push(handle);
    }

    let mut num_alignments = 0;

    let backoff = crossbeam::utils::Backoff::new();
    loop {
        match results_queue.pop() {
            // This is where we processs mapping results as they come in...
            Some(WorkQueue::Result((record, alignments))) => {
                num_alignments += alignments.len();

            }
            Some(_) => unimplemented!("Unexpected result type"),
            None => {
                backoff.snooze();

                // If all join handles are finished, we can break
                if jh.iter().all(|h| h.is_finished()) {
                    break;
                }
                if backoff.is_completed() {
                    backoff.reset();
                    std::thread::sleep(Duration::from_millis(3));
                }
            }
        }
    }

    // Join all the threads
    for handle in jh {
        handle.join().expect("Unable to join thread");
    }

    println!("Total alignments: {}", num_alignments);

    Ok(())
}

pub fn with_threads(self, threads: usize) -> Self

👎Deprecated since 0.1.17: Please use with_index_threads instead

pub fn check_opts(&self) -> Result<(), &'static str>

Check if the options are valid - Maps to mm_check_opt in minimap2

pub fn with_index<P>( self, path: P, output: Option<&str>, ) -> Result<Aligner<Built>, &'static str>

where P: AsRef<Path>,

Set index parameters for minimap2 using builder pattern Creates the index as well with the given number of threads (set at struct creation). You must set the number of threads before calling this function.

Parameters: path: Location of pre-built index or FASTA/FASTQ file (may be gzipped or plaintext) Output: Option (None) or a filename

Returns the aligner with the index set

// Do not save the index file
Aligner::builder().map_ont().with_index("test_data/test_data.fasta", None);

// Save the index file as my_index.mmi
Aligner::builder().map_ont().with_index("test_data/test_data.fasta", Some("my_index.mmi"));

// Use the previously built index
Aligner::builder().map_ont().with_index("my_index.mmi", None);

Examples found in repository

examples/rayon.rs (line 51)

fn map(
    target_file: impl AsRef<Path>,
    query_file: impl AsRef<Path>,
    threads: usize,
) -> Result<(), Box<dyn Error>> {
    // Set the number of threads to use
    rayon::ThreadPoolBuilder::new()
        .num_threads(threads)
        .build_global()
        .expect("Unable to set number of threads");

    println!("Creating index");

    // Aligner gets created using the build pattern.
    // Once .with_index is called, the aligner is set to "Built" and can no longer be changed.
    let aligner = Aligner::builder()
        .map_ont()
        .with_cigar()
        .with_index_threads(threads) // Minimap2 uses it's own thread pool for index building
        .with_index(target_file, None)
        .expect("Unable to build index");

    println!("Index created");

    // Read in the query file
    let mut reader = parse_fastx_file(query_file)?;

    let mut queries: Vec<(Vec<u8>, Vec<u8>)> = Vec::new();
    while let Some(record) = reader.next() {
        let record = record.expect("Error reading record");
        queries.push((record.id().to_vec(), record.seq().to_vec()));
    }

    // Map the queries
    let results: Vec<Vec<Mapping>> = queries
        .par_iter()
        .map(|(id, seq)| {
            aligner
                .map(&seq, false, false, None, None, Some(&id))
                .expect("Error mapping")
        })
        .collect();

    // Count total number of alignments
    let total_alignments: usize = results.iter().map(|x| x.len()).sum();
    println!("Iteration complete, total alignments {}", total_alignments);

    Ok(())
}

examples/channels.rs (line 62)

fn map(
    target_file: impl AsRef<Path>,
    query_file: impl AsRef<Path>,
    threads: usize,
) -> Result<(), Box<dyn Error>> {
    // Aligner gets created using the build pattern.
    // Once .with_index is called, the aligner is set to "Built" and can no longer be changed.
    println!("Creating index");
    let aligner = Aligner::builder()
        .map_ont()
        .with_cigar()
        .with_index_threads(threads)
        .with_index(target_file, None)
        .expect("Unable to build index");

    println!("Index created");

    // Create a queue for work and for results
    let work_queue = Arc::new(ArrayQueue::<WorkQueue<WorkUnit>>::new(1024));
    let results_queue = Arc::new(ArrayQueue::<WorkQueue<WorkResult>>::new(1024));

    // I use a shutdown flag
    let shutdown = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));

    // Store join handles, it's just good practice to clean up threads
    let mut jh = Vec::new();

    let aligner = Arc::new(aligner);

    // Spin up the threads
    for _ in 0..threads {
        // Clone everything we will need...
        let work_queue = Arc::clone(&work_queue);
        let results_queue = Arc::clone(&results_queue);
        let shutdown = Arc::clone(&shutdown);
        let aligner = Arc::clone(&aligner);

        let handle =
            std::thread::spawn(move || worker(work_queue, results_queue, shutdown, aligner));

        jh.push(handle);
    }

    // Let's split this into another thread

    {
        let work_queue = Arc::clone(&work_queue);
        let shutdown = Arc::clone(&shutdown);
        let query_file = query_file.as_ref().to_path_buf();

        let handle = std::thread::spawn(move || {
            // Now that the threads are running, read the input file and push the work to the queue
            let mut reader: Box<dyn FastxReader> =
                parse_fastx_file(query_file).unwrap_or_else(|_| panic!("Can't find query FASTA file"));

            // I just do this in the main thread, but you can split threads
            let backoff = crossbeam::utils::Backoff::new();
            while let Some(Ok(record)) = reader.next() {
                let mut work = WorkQueue::Work((record.id().to_vec(), record.seq().to_vec()));
                while let Err(work_packet) = work_queue.push(work) {
                    work = work_packet; // Simple way to maintain ownership
                                        // If we have an error, it's 99% because the queue is full
                    backoff.snooze();
                }
            }

            // Set the shutdown flag
            shutdown.store(true, std::sync::atomic::Ordering::Relaxed);
        });

        jh.push(handle);
    }

    let mut num_alignments = 0;

    let backoff = crossbeam::utils::Backoff::new();
    loop {
        match results_queue.pop() {
            // This is where we processs mapping results as they come in...
            Some(WorkQueue::Result((record, alignments))) => {
                num_alignments += alignments.len();

            }
            Some(_) => unimplemented!("Unexpected result type"),
            None => {
                backoff.snooze();

                // If all join handles are finished, we can break
                if jh.iter().all(|h| h.is_finished()) {
                    break;
                }
                if backoff.is_completed() {
                    backoff.reset();
                    std::thread::sleep(Duration::from_millis(3));
                }
            }
        }
    }

    // Join all the threads
    for handle in jh {
        handle.join().expect("Unable to join thread");
    }

    println!("Total alignments: {}", num_alignments);

    Ok(())
}

pub fn set_index<P>( self, path: P, output: Option<&str>, ) -> Result<Aligner<Built>, &'static str>

where P: AsRef<Path>,

Sets the index, uses the builder pattern. Returns Aligner if successful.

pub fn with_seq(self, seq: &[u8]) -> Result<Aligner<Built>, &'static str>

Use a single sequence as the index. Sets the sequence ID to “N/A”. Can not be combined with with_index or set_index. Following the mappy implementation, this also sets mapopt.mid_occ to 1000.

let aligner = Aligner::builder().map_ont().with_seq(seq.as_bytes()).expect("Unable to build index");
let query = b"CGGCACCAGGTTAAAATCTGAGTGCTGCAATAGGCGATTACAGTACAGCACCCAGCCTCCG";
let hits = aligner.map(query, false, false, None, None, Some(b"Query Name"));
assert_eq!(hits.unwrap().len(), 1);

pub fn with_seq_and_id( self, seq: &[u8], id: &[u8], ) -> Result<Aligner<Built>, &'static str>

Use a single sequence as the index. Sets the sequence ID to “N/A”. Can not be combined with with_index or set_index. Following the mappy implementation, this also sets mapopt.mid_occ to 1000.

let aligner = Aligner::builder().map_ont().with_seq_and_id(seq.as_bytes(), id.as_bytes()).expect("Unable to build index");
let query = b"CGGCACCAGGTTAAAATCTGAGTGCTGCAATAGGCGATTACAGTACAGCACCCAGCCTCCG";
let hits = aligner.map(query, false, false, None, None, Some(b"Sample Query"));
assert_eq!(hits.as_ref().unwrap().len(), 1);
assert_eq!(hits.as_ref().unwrap()[0].target_name.as_ref().unwrap().as_str(), id);

pub fn with_seqs(self, seqs: &[Vec<u8>]) -> Result<Aligner<Built>, &'static str>

TODO: Does not work for more than 1 seq currently! Pass multiple sequences to build an index functionally. Following the mappy implementation, this also sets mapopt.mid_occ to 1000. Can not be combined with with_index or set_index. Sets the sequence IDs to “Unnamed Sequence n” where n is the sequence number.

pub fn with_seqs_and_ids( self, seqs: &[Vec<u8>], ids: &[Vec<u8>], ) -> Result<Aligner<Built>, &'static str>

TODO: Does not work for more than 1 seq currently! Pass multiple sequences and corresponding IDs to build an index functionally. Following the mappy implementation, this also sets mapopt.mid_occ to 1000.

pub fn additional_preset(self, preset: Preset) -> Self

Applies an additional preset to the aligner WARNING: This overwrites multiple other parameters. Make sure you know what you are doing

Presets should be called before any other options are set, as they change multiple options at once.

impl Aligner<Built>

pub fn n_seq(&self) -> u32

Returns the number of sequences in the index

pub fn get_seq<'aln>(&'aln self, i: usize) -> Option<&'aln mm_idx_seq_t>

Get sequences direct from the index

Returns a reference to the sequence at the given index Remainds valid as long as the aligner is valid

pub fn map( &self, seq: &[u8], cs: bool, md: bool, max_frag_len: Option<usize>, extra_flags: Option<&[u64]>, query_name: Option<&[u8]>, ) -> Result<Vec<Mapping>, &'static str>

Aligns a given sequence (as bytes) to the index associated with this aligner

Parameters: seq: Sequence to align cs: Whether to output CIGAR string MD: Whether to output MD tag max_frag_len: Maximum fragment length extra_flags: Extra flags to pass to minimap2 as Vec<u64> query_name: Name of the query sequence

Examples found in repository

examples/channels.rs (line 173)

fn worker(
    work_queue: Arc<ArrayQueue<WorkQueue<WorkUnit>>>,
    results_queue: Arc<ArrayQueue<WorkQueue<WorkResult>>>,
    shutdown: Arc<std::sync::atomic::AtomicBool>,
    aligner: Arc<Aligner<Built>>,
) {
    loop {
        // We use backoff to sleep when we don't have any work
        let backoff = crossbeam::utils::Backoff::new();

        match work_queue.pop() {
            Some(WorkQueue::Work(sequence)) => {
                let alignment = aligner
                    .map(&sequence.1, true, false, None, None, Some(&sequence.0))
                    .expect("Unable to align");

                // Return the original sequence, as well as the mappings
                // We have to do it this way because ownership
                let mut result = WorkQueue::Result((sequence, alignment));
                while let Err(result_packet) = results_queue.push(result) {
                    result = result_packet; // Simple way to maintain ownership
                                            // If we have an error, it's 99% because the queue is full
                    backoff.snooze();
                }
            }
            Some(_) => unimplemented!("Unexpected work type"),
            None => {
                backoff.snooze();

                // If we have the shutdown signal, we should exit
                if shutdown.load(std::sync::atomic::Ordering::Relaxed) && work_queue.is_empty() {
                    break;
                }
            }
        }
    }
}

examples/rayon.rs (line 70)

fn map(
    target_file: impl AsRef<Path>,
    query_file: impl AsRef<Path>,
    threads: usize,
) -> Result<(), Box<dyn Error>> {
    // Set the number of threads to use
    rayon::ThreadPoolBuilder::new()
        .num_threads(threads)
        .build_global()
        .expect("Unable to set number of threads");

    println!("Creating index");

    // Aligner gets created using the build pattern.
    // Once .with_index is called, the aligner is set to "Built" and can no longer be changed.
    let aligner = Aligner::builder()
        .map_ont()
        .with_cigar()
        .with_index_threads(threads) // Minimap2 uses it's own thread pool for index building
        .with_index(target_file, None)
        .expect("Unable to build index");

    println!("Index created");

    // Read in the query file
    let mut reader = parse_fastx_file(query_file)?;

    let mut queries: Vec<(Vec<u8>, Vec<u8>)> = Vec::new();
    while let Some(record) = reader.next() {
        let record = record.expect("Error reading record");
        queries.push((record.id().to_vec(), record.seq().to_vec()));
    }

    // Map the queries
    let results: Vec<Vec<Mapping>> = queries
        .par_iter()
        .map(|(id, seq)| {
            aligner
                .map(&seq, false, false, None, None, Some(&id))
                .expect("Error mapping")
        })
        .collect();

    // Count total number of alignments
    let total_alignments: usize = results.iter().map(|x| x.len()).sum();
    println!("Iteration complete, total alignments {}", total_alignments);

    Ok(())
}

pub fn map_file( &self, file: &str, cs: bool, md: bool, ) -> Result<Vec<Mapping>, &'static str>

Map entire file Detects if file is gzip or not and if it’s fastq/fasta or not Best for smaller files (all results are stored in an accumulated Vec!) What you probably want is to loop through the file yourself and use the map() function

TODO: Remove cs and md and make them options on the struct

pub fn has_index(&self) -> bool

Trait Implementations

impl<S: Clone + BuilderState> Clone for Aligner<S>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for Aligner<Unset>

Create a default aligner

fn default() -> Self

Returns the “default value” for a type.

impl From<&Aligner<Built>> for MMIndex

fn from(aligner: &Aligner<Built>) -> Self

Converts to this type from the input type.

impl Send for Aligner<Built>

impl Send for Aligner<PresetSet>

impl Send for Aligner<Unset>

impl Sync for Aligner<Built>

impl Sync for Aligner<PresetSet>

impl Sync for Aligner<Unset>