From 976236f15c792fdd0d123fc2c4002ab05399709b Mon Sep 17 00:00:00 2001 From: Adam Novak Date: Fri, 7 Feb 2025 08:20:38 -0800 Subject: [PATCH] Report link graph lengths and split graph transition length limit to add limit for read length --- src/algorithms/chain_items.cpp | 23 ++++++-- src/algorithms/chain_items.hpp | 19 +++++-- src/minimizer_mapper.hpp | 36 ++++++++---- src/minimizer_mapper_from_chains.cpp | 50 +++++++++-------- src/subcommand/giraffe_main.cpp | 84 ++++++++++++++++++---------- src/unittest/minimizer_mapper.cpp | 2 +- 6 files changed, 137 insertions(+), 77 deletions(-) diff --git a/src/algorithms/chain_items.cpp b/src/algorithms/chain_items.cpp index d62cf5a076..d1fc9400cb 100644 --- a/src/algorithms/chain_items.cpp +++ b/src/algorithms/chain_items.cpp @@ -191,7 +191,11 @@ transition_iterator lookback_transition_iterator(size_t max_lookback_bases, return iterator; } -transition_iterator zip_tree_transition_iterator(const std::vector& seeds, const ZipCodeTree& zip_code_tree, size_t max_lookback_bases) { +transition_iterator zip_tree_transition_iterator(const std::vector& seeds, + const ZipCodeTree& zip_code_tree, + size_t max_graph_lookback_bases, + size_t max_read_lookback_bases) { + // TODO: Remove seeds because we only bring it here for debugging and it complicates the dependency relationships return [&seeds, &zip_code_tree, max_lookback_bases](const VectorView& to_chain, const SnarlDistanceIndex& distance_index, @@ -236,6 +240,14 @@ transition_iterator zip_tree_transition_iterator(const std::vector max_read_lookback_bases) { + // Too far in read to consider +#ifdef debug_transition + std::cerr << "\tToo far apart in read (" << read_distance << "/" << max_read_lookback_bases << ")." << std::endl; +#endif + return; + } + if (source_anchor.read_exclusion_end() > dest_anchor.read_exclusion_start()) { // The actual core anchor part is reachable in the read, but we cut these down from overlapping minimizers. #ifdef debug_transition @@ -313,12 +325,12 @@ transition_iterator zip_tree_transition_iterator(const std::vectorsecond << std::endl; #endif - for (ZipCodeTree::reverse_iterator source = zip_code_tree.look_back(dest, max_lookback_bases); source != zip_code_tree.rend(); ++source) { + for (ZipCodeTree::reverse_iterator source = zip_code_tree.look_back(dest, max_graph_lookback_bases); source != zip_code_tree.rend(); ++source) { // For each source seed right to left ZipCodeTree::seed_result_t source_seed = *source; #ifdef debug_transition - std::cerr << "\tSource seed S" << source_seed.seed << " " << seeds[source_seed.seed].pos << (source_seed.is_reverse ? "rev" : "") << " at distance " << source_seed.distance << "/" << max_lookback_bases; + std::cerr << "\tSource seed S" << source_seed.seed << " " << seeds[source_seed.seed].pos << (source_seed.is_reverse ? "rev" : "") << " at distance " << source_seed.distance << "/" << max_graph_lookback_bases; #endif if (!source_seed.is_reverse && !dest_seed.is_reverse) { @@ -343,7 +355,7 @@ transition_iterator zip_tree_transition_iterator(const std::vector& a, const std::tuple& b) { // Return true if a's destination seed is before b's in the read, and false otherwise. return to_chain[get<1>(a)].read_start() < to_chain[get<1>(b)].read_start(); diff --git a/src/algorithms/chain_items.hpp b/src/algorithms/chain_items.hpp index 77b299c5bd..625da523da 100644 --- a/src/algorithms/chain_items.hpp +++ b/src/algorithms/chain_items.hpp @@ -308,9 +308,16 @@ transition_iterator lookback_transition_iterator(size_t max_lookback_bases, size_t lookback_item_hard_cap); /** - * Return a transition iterator that uses zip code tree iteration to select traversals. + * Return a transition iterator that uses zip code tree iteration to select + * traversals. + * + * Enumerates transitions under the max graph lookback bases, and filters them + * by the max read lookback bases. */ -transition_iterator zip_tree_transition_iterator(const std::vector& seeds, const ZipCodeTree& zip_code_tree, size_t max_lookback_bases); +transition_iterator zip_tree_transition_iterator(const std::vector& seeds, + const ZipCodeTree& zip_code_tree, + size_t max_graph_lookback_bases, + size_t max_read_lookback_bases); /** * Fill in the given DP table for the explored chain scores ending with each @@ -323,11 +330,11 @@ transition_iterator zip_tree_transition_iterator(const std::vector::max(); + size_t fragment_max_read_lookback_bases = default_fragment_max_read_lookback_bases; + /// How many bases should we look back in the read when making fragments, per base of read length? + static constexpr double default_fragment_max_read_lookback_bases_per_base = 1.0; + double fragment_max_read_lookback_bases_per_base = default_fragment_max_read_lookback_bases_per_base; /// How many fragments should we try and make when fragmenting something? static constexpr size_t default_max_fragments = std::numeric_limits::max(); size_t max_fragments = default_max_fragments; @@ -322,12 +328,18 @@ class MinimizerMapper : public AlignerClient { static constexpr size_t default_max_direct_to_chain = 0; size_t max_direct_to_chain = default_max_direct_to_chain; - /// How many bases should we look back when chaining? - static constexpr size_t default_max_lookback_bases = 3000; - size_t max_lookback_bases = default_max_lookback_bases; - /// How many bases should we look back when chaining, per base of read length? - static constexpr double default_max_lookback_bases_per_base = 0.3; - double max_lookback_bases_per_base = default_max_lookback_bases_per_base; + /// How many bases should we look back in the graph when chaining? + static constexpr size_t default_max_graph_lookback_bases = 3000; + size_t max_graph_lookback_bases = default_max_graph_lookback_bases; + /// How many bases should we look back in the graph when chaining, per base of read length? + static constexpr double default_max_graph_lookback_bases_per_base = 0.3; + double max_graph_lookback_bases_per_base = default_max_graph_lookback_bases_per_base; + /// How many bases should we look back in the read when chaining? + static constexpr size_t default_max_read_lookback_bases = std::numeric_limits::max(); + size_t max_read_lookback_bases = default_max_read_lookback_bases; + /// How many bases should we look back in the read when chaining, per base of read length? + static constexpr double default_max_read_lookback_bases_per_base = 1.0; + double max_read_lookback_bases_per_base = default_max_read_lookback_bases_per_base; /// How much of a bonus should we give to each item in /// fragmenting/chaining? diff --git a/src/minimizer_mapper_from_chains.cpp b/src/minimizer_mapper_from_chains.cpp index bed8359f51..4366e94643 100644 --- a/src/minimizer_mapper_from_chains.cpp +++ b/src/minimizer_mapper_from_chains.cpp @@ -1433,14 +1433,16 @@ void MinimizerMapper::do_fragmenting_on_trees(Alignment& aln, const ZipCodeFores // Compute lookback and indel limits based on read length. // Important since seed density goes down on longer reads. - size_t lookback_limit = std::max(this->fragment_max_lookback_bases, (size_t)(this->fragment_max_lookback_bases_per_base * aln.sequence().size())); + size_t graph_lookback_limit = std::max(this->fragment_max_graph_lookback_bases, (size_t)(this->fragment_max_graph_lookback_bases_per_base * aln.sequence().size())); + size_t read_lookback_limit = std::max(this->fragment_max_read_lookback_bases, (size_t)(this->fragment_max_read_lookback_bases_per_base * aln.sequence().size())); size_t indel_limit = std::max(this->fragment_max_indel_bases, (size_t)(this->fragment_max_indel_bases_per_base * aln.sequence().size())); // Find fragments over the seeds in the zip code tree algorithms::transition_iterator for_each_transition = algorithms::zip_tree_transition_iterator( seeds, zip_code_forest.trees[item_num], - lookback_limit + graph_lookback_limit, + read_lookback_limit ); // Make a view of the anchors we will fragment over VectorView anchor_view {anchors_to_fragment, anchor_indexes}; @@ -1896,14 +1898,16 @@ void MinimizerMapper::do_chaining_on_fragments(Alignment& aln, const ZipCodeFore // Compute lookback and indel limits based on read length. // Important since seed density goes down on longer reads. - size_t lookback_limit = std::max(this->max_lookback_bases, (size_t)(this->max_lookback_bases_per_base * aln.sequence().size())); + size_t graph_lookback_limit = std::max(this->max_graph_lookback_bases, (size_t)(this->max_graph_lookback_bases_per_base * aln.sequence().size())); + size_t read_lookback_limit = std::max(this->max_read_lookback_bases, (size_t)(this->max_read_lookback_bases_per_base * aln.sequence().size())); size_t indel_limit = std::max(this->max_indel_bases, (size_t)(this->max_indel_bases_per_base * aln.sequence().size())); // Chain up the fragments algorithms::transition_iterator for_each_transition = algorithms::zip_tree_transition_iterator( seeds, zip_code_forest.trees[tree_num], - lookback_limit + graph_lookback_limit, + read_lookback_limit ); std::vector>> chain_results = algorithms::find_best_chains( fragment_view, @@ -3101,19 +3105,19 @@ Alignment MinimizerMapper::find_chain_alignment( size_t link_start = (*here).read_end(); size_t link_length = (*next).read_start() - link_start; string linking_bases = aln.sequence().substr(link_start, link_length); - size_t graph_length = algorithms::get_graph_distance(*here, *next, *distance_index, gbwt_graph); + size_t graph_dist = algorithms::get_graph_distance(*here, *next, *distance_index, gbwt_graph); #ifdef debug_chain_alignment if (show_work) { #pragma omp critical (cerr) { cerr << log_name() << "Need to align graph from " << (*here).graph_end() << " to " << (*next).graph_start() - << " separated by " << graph_length << " bp and sequence \"" << linking_bases << "\"" << endl; + << " separated by ~" << graph_dist << " bp and sequence \"" << linking_bases << "\"" << endl; } } #endif - if (link_length == 0 && graph_length == 0) { + if (link_length == 0 && graph_dist == 0) { // These items abut in the read and the graph, so we assume we can just connect them. // WFAExtender::connect() can't handle an empty read sequence, and // our fallback method to align just against the graph can't handle @@ -3159,7 +3163,7 @@ Alignment MinimizerMapper::find_chain_alignment( if (!link_alignment) { // We couldn't align. - if (graph_length == 0) { + if (graph_dist == 0) { // We had read sequence but no graph sequence. // Try falling back to a pure insertion. // TODO: We can be leaving the GBWT's space here! @@ -3178,7 +3182,7 @@ Alignment MinimizerMapper::find_chain_alignment( } else if (link_alignment.length != linking_bases.size()) { // We could align, but we didn't get the alignment we expected. This shouldn't happen for a middle piece that can't softclip. stringstream ss; - ss << "Aligning anchored link " << linking_bases << " (" << linking_bases.size() << " bp) from " << left_anchor << " - " << (*next).graph_start() << " against graph distance " << graph_length << " produced wrong-length alignment "; + ss << "Aligning anchored link " << linking_bases << " (" << linking_bases.size() << " bp) from " << left_anchor << " - " << (*next).graph_start() << " against graph distance " << graph_dist << " produced wrong-length alignment "; link_alignment.print(ss); throw ChainAlignmentFailedError(ss.str()); } else { @@ -3188,6 +3192,10 @@ Alignment MinimizerMapper::find_chain_alignment( } } + // We will measure the graph distance on the link path actually found, for work-showing. + // This gets filled from either the WFA alignment we have already, or the BGA alignment we are about to compute. + size_t link_graph_path_length; + if (link_alignment) { // We found a link alignment @@ -3213,6 +3221,7 @@ Alignment MinimizerMapper::find_chain_alignment( } } #endif + link_graph_path_length = path_from_length(link_path); append_path(composed_path, std::move(link_path)); } composed_score += link_alignment.score; @@ -3224,7 +3233,7 @@ Alignment MinimizerMapper::find_chain_alignment( // This would be too long for the middle aligner(s) to handle and might overflow a score somewhere. #pragma omp critical (cerr) { - cerr << "warning[MinimizerMapper::find_chain_alignment]: Refusing to align " << link_length << " bp connection between chain items " << to_chain.backing_index(*here_it) << " and " << to_chain.backing_index(*next_it) << " which are " << graph_length << " apart at " << (*here).graph_end() << " and " << (*next).graph_start() << " in " << aln.name() << " to avoid overflow, creating " << (aln.sequence().size() - (*here).read_end()) << " bp right tail" << endl; + cerr << "warning[MinimizerMapper::find_chain_alignment]: Refusing to align " << link_length << " bp connection between chain items " << to_chain.backing_index(*here_it) << " and " << to_chain.backing_index(*next_it) << " which are " << graph_dist << " apart at " << (*here).graph_end() << " and " << (*next).graph_start() << " in " << aln.name() << " to avoid overflow, creating " << (aln.sequence().size() - (*here).read_end()) << " bp right tail" << endl; } // Just jump to right tail break; @@ -3235,7 +3244,7 @@ Alignment MinimizerMapper::find_chain_alignment( // long of a sequence to find a connecting path. #pragma omp critical (cerr) { - cerr << "warning[MinimizerMapper::find_chain_alignment]: Falling back to non-GBWT alignment of " << link_length << " bp connection between chain items " << to_chain.backing_index(*here_it) << " and " << to_chain.backing_index(*next_it) << " which are " << graph_length << " apart at " << (*here).graph_end() << " and " << (*next).graph_start() << " in " << aln.name() << endl; + cerr << "warning[MinimizerMapper::find_chain_alignment]: Falling back to non-GBWT alignment of " << link_length << " bp connection between chain items " << to_chain.backing_index(*here_it) << " and " << to_chain.backing_index(*next_it) << " which are " << graph_dist << " apart at " << (*here).graph_end() << " and " << (*next).graph_start() << " in " << aln.name() << endl; } #endif @@ -3246,7 +3255,7 @@ Alignment MinimizerMapper::find_chain_alignment( } // Guess how long of a graph path we ought to allow in the alignment. size_t max_gap_length = std::min(this->max_middle_gap, longest_detectable_gap_in_range(aln, aln.sequence().begin() + link_start, aln.sequence().begin() + link_start + link_length, this->get_regular_aligner())); - size_t path_length = std::max(graph_length, link_length); + size_t path_length = std::max(graph_dist, link_length); if (stats) { start_time = std::chrono::high_resolution_clock::now(); } @@ -3266,7 +3275,7 @@ Alignment MinimizerMapper::find_chain_alignment( // TODO: Should we let the exceptions propagate up to here instead? #pragma omp critical (cerr) { - cerr << "warning[MinimizerMapper::find_chain_alignment]: BGA alignment too big for " << link_length << " bp connection between chain items " << to_chain.backing_index(*here_it) << " and " << to_chain.backing_index(*next_it) << " which are " << graph_length << " apart at " << (*here).graph_end() << " and " << (*next).graph_start() << " in " << aln.name() << endl; + cerr << "warning[MinimizerMapper::find_chain_alignment]: BGA alignment too big for " << link_length << " bp connection between chain items " << to_chain.backing_index(*here_it) << " and " << to_chain.backing_index(*next_it) << " which are " << graph_dist << " apart at " << (*here).graph_end() << " and " << (*next).graph_start() << " in " << aln.name() << endl; } // Just jump to right tail @@ -3276,22 +3285,17 @@ Alignment MinimizerMapper::find_chain_alignment( // Otherwise we actually have a link alignment result. link_alignment_source = "align_sequence_between"; - if (show_work) { - #pragma omp critical (cerr) - { - cerr << log_name() << "Add link of length " << path_to_length(link_aln.path()) << " with score of " << link_aln.score() << endl; - } - } - // Then tack that path and score on - append_path(composed_path, link_aln.path()); + Path link_path(link_aln.path()); + link_graph_path_length = path_from_length(link_path); + append_path(composed_path, std::move(link_path)); composed_score += link_aln.score(); } if (show_work) { #pragma omp critical (cerr) { - cerr << log_name() << "Aligned and added link of " << link_length << " via " << link_alignment_source << std::endl; + cerr << log_name() << "Aligned and added link of " << link_length << " bp read and " << link_graph_path_length << " bp graph via " << link_alignment_source << " with score of " << link_aln.score() << std::endl; } } @@ -3327,7 +3331,7 @@ Alignment MinimizerMapper::find_chain_alignment( here_alignment.check_lengths(gbwt_graph); // Do the final GaplessExtension itself (may be the first) - append_path(composed_path, here_alignment.to_path(this->gbwt_graph, aln.sequence())); + append_path(composed_path, here_alignment.to_path(this->gbwt_graph, aln.sequence())); composed_score += here_alignment.score; } diff --git a/src/subcommand/giraffe_main.cpp b/src/subcommand/giraffe_main.cpp index 05a204fdf8..9557600ecd 100644 --- a/src/subcommand/giraffe_main.cpp +++ b/src/subcommand/giraffe_main.cpp @@ -381,16 +381,28 @@ static std::unique_ptr get_options() { "do gapless extension to seeds in a tree before fragmenting if the read length is less than this" ); chaining_opts.add_range( - "fragment-max-lookback-bases", - &MinimizerMapper::fragment_max_lookback_bases, - MinimizerMapper::default_fragment_max_lookback_bases, - "maximum distance to look back when making fragments" + "fragment-max-graph-lookback-bases", + &MinimizerMapper::fragment_max_graph_lookback_bases, + MinimizerMapper::default_fragment_max_graph_lookback_bases, + "maximum distance to look back in the graph when making fragments" ); chaining_opts.add_range( - "fragment-max-lookback-bases-per-base", - &MinimizerMapper::fragment_max_lookback_bases_per_base, - MinimizerMapper::default_fragment_max_lookback_bases_per_base, - "maximum distance to look back when making fragments, per base" + "fragment-max-graph-lookback-bases-per-base", + &MinimizerMapper::fragment_max_graph_lookback_bases_per_base, + MinimizerMapper::default_fragment_max_graph_lookback_bases_per_base, + "maximum distance to look back in the graph when making fragments, per base" + ); + chaining_opts.add_range( + "fragment-max-read-lookback-bases", + &MinimizerMapper::fragment_max_read_lookback_bases, + MinimizerMapper::default_fragment_max_read_lookback_bases, + "maximum distance to look back in the read when making fragments" + ); + chaining_opts.add_range( + "fragment-max-read-lookback-bases-per-base", + &MinimizerMapper::fragment_max_read_lookback_bases_per_base, + MinimizerMapper::default_fragment_max_read_lookback_bases_per_base, + "maximum distance to look back in the read when making fragments, per base" ); chaining_opts.add_range( "max-fragments", @@ -465,16 +477,28 @@ static std::unique_ptr get_options() { int_is_nonnegative ); chaining_opts.add_range( - "max-lookback-bases", - &MinimizerMapper::max_lookback_bases, - MinimizerMapper::default_max_lookback_bases, - "maximum distance to look back when chaining" + "max-graph-lookback-bases", + &MinimizerMapper::max_graph_lookback_bases, + MinimizerMapper::default_max_graph_lookback_bases, + "maximum distance to look back in the graph when chaining" + ); + chaining_opts.add_range( + "max-graph-lookback-bases-per-base", + &MinimizerMapper::max_graph_lookback_bases_per_base, + MinimizerMapper::default_max_graph_lookback_bases_per_base, + "maximum distance to look back in the graph when chaining, per read base" + ); + chaining_opts.add_range( + "max-read-lookback-bases", + &MinimizerMapper::max_read_lookback_bases, + MinimizerMapper::default_max_read_lookback_bases, + "maximum distance to look back in the read when chaining" ); chaining_opts.add_range( - "max-lookback-bases-per-base", - &MinimizerMapper::max_lookback_bases_per_base, - MinimizerMapper::default_max_lookback_bases_per_base, - "maximum distance to look back when chaining, per read base" + "max-read-lookback-bases-per-base", + &MinimizerMapper::max_read_lookback_bases_per_base, + MinimizerMapper::default_max_read_lookback_bases_per_base, + "maximum distance to look back in the read when chaining, per read base" ); chaining_opts.add_range( "max-indel-bases", @@ -919,8 +943,8 @@ int main_giraffe(int argc, char** argv) { .add_entry("zipcode-tree-scale", 2.0) .add_entry("min-to-fragment", 2) .add_entry("max-to-fragment", 15) - .add_entry("fragment-max-lookback-bases", 500) - .add_entry("fragment-max-lookback-bases-per-base", 0.025) + .add_entry("fragment-max-graph-lookback-bases", 500) + .add_entry("fragment-max-graph-lookback-bases-per-base", 0.025) .add_entry("max-fragments", 15000) .add_entry("fragment-max-indel-bases", 15000) .add_entry("fragment-max-indel-bases-per-base", 0.1) @@ -931,8 +955,8 @@ int main_giraffe(int argc, char** argv) { .add_entry("fragment-set-score-threshold", 70.0) .add_entry("min-chaining-problems", 6) .add_entry("max-chaining-problems", std::numeric_limits::max()) - .add_entry("max-lookback-bases", 20000) - .add_entry("max-lookback-bases-per-base", 0.10501002120802233) + .add_entry("max-graph-lookback-bases", 20000) + .add_entry("max-graph-lookback-bases-per-base", 0.10501002120802233) .add_entry("max-indel-bases", 5000) .add_entry("max-indel-bases-per-base", 2.45) .add_entry("item-bonus", 20) @@ -981,8 +1005,8 @@ int main_giraffe(int argc, char** argv) { .add_entry("gapless-extension-limit", 0) .add_entry("min-to-fragment", 2) .add_entry("max-to-fragment", 15) - .add_entry("fragment-max-lookback-bases", 500) - .add_entry("fragment-max-lookback-bases-per-base", 0.025) + .add_entry("fragment-max-graph-lookback-bases", 500) + .add_entry("fragment-max-graph-lookback-bases-per-base", 0.025) .add_entry("max-fragments", 15000) .add_entry("fragment-max-indel-bases", 15000) .add_entry("fragment-max-indel-bases-per-base", 0.1) @@ -993,8 +1017,8 @@ int main_giraffe(int argc, char** argv) { .add_entry("fragment-set-score-threshold", 70) .add_entry("min-chaining-problems", 6) .add_entry("max-chaining-problems", std::numeric_limits::max()) - .add_entry("max-lookback-bases", 20000) - .add_entry("max-lookback-bases-per-base", 0.10501002120802233) + .add_entry("max-graph-lookback-bases", 20000) + .add_entry("max-graph-lookback-bases-per-base", 0.10501002120802233) .add_entry("max-indel-bases", 5000) .add_entry("max-indel-bases-per-base", 2.45) .add_entry("item-bonus", 20) @@ -1046,8 +1070,8 @@ int main_giraffe(int argc, char** argv) { // And fragment them .add_entry("fragment-gap-scale", 4.75) .add_entry("gap-scale", 2.2) - .add_entry("fragment-max-lookback-bases", 300) - .add_entry("fragment-max-lookback-bases-per-base", 0) + .add_entry("fragment-max-graph-lookback-bases", 300) + .add_entry("fragment-max-graph-lookback-bases-per-base", 0) .add_entry("fragment-max-indel-bases", 3000) .add_entry("fragment-max-indel-bases-per-base", 0) // And take those to chains @@ -1057,8 +1081,8 @@ int main_giraffe(int argc, char** argv) { .add_entry("fragment-set-score-threshold", std::numeric_limits::max()) .add_entry("min-chaining-problems", 7) .add_entry("max-chaining-problems", std::numeric_limits::max()) - .add_entry("max-lookback-bases", 1000) - .add_entry("max-lookback-bases-per-base", 0) + .add_entry("max-graph-lookback-bases", 1000) + .add_entry("max-graph-lookback-bases-per-base", 0) .add_entry("max-indel-bases", 1600) .add_entry("max-indel-bases-per-base", 0) .add_entry("chain-score-threshold", 100.0) @@ -1088,14 +1112,14 @@ int main_giraffe(int argc, char** argv) { .add_entry("mapq-score-scale", 1.0) .add_entry("min-to-fragment", 2) .add_entry("max-to-fragment", 10) - .add_entry("fragment-max-lookback-bases-per-base", 0) + .add_entry("fragment-max-graph-lookback-bases-per-base", 0) .add_entry("fragment-max-indel-bases-per-base", 0) .add_entry("fragment-score-fraction", 0.8) .add_entry("fragment-min-score", 0) .add_entry("fragment-set-score-threshold", std::numeric_limits::max()) .add_entry("min-chaining-problems", 1) .add_entry("max-chaining-problems", std::numeric_limits::max()) - .add_entry("max-lookback-bases-per-base", 0) + .add_entry("max-graph-lookback-bases-per-base", 0) .add_entry("max-indel-bases-per-base", 0) .add_entry("min-chains", 4) .add_entry("max-chains-per-tree", 5) diff --git a/src/unittest/minimizer_mapper.cpp b/src/unittest/minimizer_mapper.cpp index 9b71315587..d6309380f4 100644 --- a/src/unittest/minimizer_mapper.cpp +++ b/src/unittest/minimizer_mapper.cpp @@ -930,7 +930,7 @@ TEST_CASE("MinimizerMapper can make correct anchors from minimizers and their zi std::unordered_map, std::pair> all_transitions; // Set up to get all the transitions between anchors in the zip code tree - auto transition_iterator = algorithms::zip_tree_transition_iterator(seeds, zip_forest.trees.at(0), std::numeric_limits::max()); + auto transition_iterator = algorithms::zip_tree_transition_iterator(seeds, zip_forest.trees.at(0), std::numeric_limits::max(), std::numeric_limits::max()); // And get them transition_iterator(anchors, distance_index, graph, std::numeric_limits::max(), [&](size_t from_anchor, size_t to_anchor, size_t read_distance, size_t graph_distance) { // And for each of them, remember them