clean slop

Author: glennhickey

src/gbwtgraph_helper.cpp

@@ -440,13 +440,11 @@ void cache_payloads(
         std::cerr << "Caching payloads" << std::endl;
     }
 
-    const handlegraph::HandleGraph* graph_ptr = (const handlegraph::HandleGraph*) &gbz.graph;
-
     gbz.graph.for_each_handle([&](const handle_t& handle) {
         nid_t node_id = gbz.graph.get_id(handle);
         ZipCode zipcode;
         pos_t pos = make_pos_t(node_id, false, 0);
-        zipcode.fill_in_zipcode_from_pos(distance_index, pos, true, graph_ptr);
+        zipcode.fill_in_zipcode_from_pos(distance_index, pos);
         payload_t payload = zipcode.get_payload_from_zip();
         if (payload == MIPayload::NO_CODE && oversized_zipcodes != nullptr) {
             // The zipcode is too large for the payload field.

src/minimizer_mapper.cpp

@@ -2048,8 +2048,7 @@ pair<vector<Alignment>, vector<Alignment>> MinimizerMapper::map_paired(Alignment
 
     // Fill this in with the indexes of pairs of alignments we will output
     // each alignment is stored as <fragment index, alignment index> into alignments
-    // fragment_index should be the same for both ends, unless one was rescued.
-    // Note that for a failed rescue, we still include the "pair" here that has one read unmapped.
+    // fragment_index should be the same for both ends, unless one was rescued
     vector<std::array<read_alignment_index_t, 2>> paired_alignments;
     paired_alignments.reserve(alignments.size());
 
@@ -2062,11 +2061,8 @@ pair<vector<Alignment>, vector<Alignment>> MinimizerMapper::map_paired(Alignment
     vector<std::array<vector<vector<size_t>>, 2>> alignment_groups(alignments.size());
 
     // Grab all the scores in order for MAPQ computation.
-    // These correspond 1 to 1 with paired_alignments.
     vector<double> paired_scores;
     paired_scores.reserve(alignments.size());
-    // Record the fragment distances, which are 1 to 1 with paired_alignments
-    // and feed into MAPQ capping. 
     vector<int64_t> fragment_distances;
     fragment_distances.reserve(alignments.size());
 
@@ -2206,6 +2202,7 @@ pair<vector<Alignment>, vector<Alignment>> MinimizerMapper::map_paired(Alignment
         unpaired_scores[r].reserve(unpaired_alignments.size());
     }
 
+
     array<vector<read_alignment_index_t>, 2> supplementaries;
     if (!unpaired_alignments.empty()) {
         //If we found some clusters that had no pair in a fragment cluster
@@ -2356,15 +2353,14 @@ pair<vector<Alignment>, vector<Alignment>> MinimizerMapper::map_paired(Alignment
                 attempt_rescue(mapped_aln, rescued_aln, minimizers_by_read[1 - index.read], index.read == 0);
 
                 bool properly_paired = false;
-                int64_t fragment_dist;
                 double score;
 
                 if (rescued_aln.path().mapping_size() != 0) {
                     //If we actually found an alignment
 
                     // Compute the distance
-                    fragment_dist = index.read == 0 ? distance_between(mapped_aln, rescued_aln) 
-                                                    : distance_between(rescued_aln, mapped_aln);
+                    int64_t fragment_dist = index.read == 0 ? distance_between(mapped_aln, rescued_aln) 
+                                                      : distance_between(rescued_aln, mapped_aln);
 
                     // Use it to make a pair score
                     score = score_alignment_pair(mapped_aln, rescued_aln, fragment_dist);
@@ -2377,13 +2373,13 @@ pair<vector<Alignment>, vector<Alignment>> MinimizerMapper::map_paired(Alignment
                     set_annotation(mapped_aln,  "fragment_length", distance_to_annotation(fragment_dist));
                     set_annotation(rescued_aln, "fragment_length", distance_to_annotation(fragment_dist));
 
+                    // Track it for the distribution
+                    fragment_distances.emplace_back(fragment_dist);
                 } else {
                     // If there's no rescue result, the score of the pair is the score of the one actually-aligned read
                     score = mapped_aln.score();
-                    // And the fragment distance is unreachable. But don't add an annotation for it.
-                    fragment_dist = std::numeric_limits<int64_t>::max();
                 }
-
+                
                 // Add the annotations that don't always need a fragment distance.
                 set_annotation(mapped_aln, "rescuer", true);
                 set_annotation(rescued_aln, "rescued", true);
@@ -2411,7 +2407,7 @@ pair<vector<Alignment>, vector<Alignment>> MinimizerMapper::map_paired(Alignment
                     paired_alignments.back().at(r).check_for_read_in(r, alignments);
                 }
 #endif
-                fragment_distances.emplace_back(fragment_dist);
+                
                 paired_scores.emplace_back(score);
                 pair_types.push_back(index.read == 0 ? rescued_from_first : rescued_from_second); 
                 better_cluster_count_by_pairs.emplace_back(better_cluster_count[mapped_index.fragment]);
@@ -2451,8 +2447,7 @@ pair<vector<Alignment>, vector<Alignment>> MinimizerMapper::map_paired(Alignment
         }
 
         if (find_supplementaries) {
-            supplementaries = std::move(identify_supplementary_alignments(alignments, paired_alignments, paired_scores,
-                                                                          fragment_distances, pair_types, better_cluster_count_by_pairs,
+            supplementaries = std::move(identify_supplementary_alignments(alignments, paired_alignments, paired_scores, pair_types, 
                                                                           unpaired_alignments, attempted_rescue_from, funnels));
         }
     }
@@ -2463,16 +2458,6 @@ pair<vector<Alignment>, vector<Alignment>> MinimizerMapper::map_paired(Alignment
             funnels[r].stage("winner");
         }
     }
-    
-    // Make sure we haven't dropped any parts of our multi-vector per-pair
-    // alignment data records.
-    //
-    // TODO: Remove the possibility to get this wrong by making these all
-    // members of a struct.
-    crash_unless(paired_scores.size() == paired_alignments.size());
-    crash_unless(fragment_distances.size() == paired_alignments.size());
-    crash_unless(pair_types.size() == paired_alignments.size());
-    crash_unless(better_cluster_count_by_pairs.size() == paired_alignments.size());
 
     // Fill this in with the alignments we will output.
     std::array<vector<Alignment>, 2> mappings;
@@ -3565,9 +3550,7 @@ array<vector<MinimizerMapper::read_alignment_index_t>, 2>
 MinimizerMapper::identify_supplementary_alignments(vector<std::array<vector<Alignment>, 2>>& alignments,
                                                    vector<std::array<read_alignment_index_t, 2>>& paired_alignments, 
                                                    vector<double>& paired_scores,
-                                                   vector<int64_t>& fragment_distances,
                                                    vector<MinimizerMapper::PairType>& pair_types,
-                                                   vector<size_t>& better_cluster_count_by_pairs,
                                                    const vector<alignment_index_t>& unpaired_alignments,
                                                    const vector<bool>& attempted_rescue_from,
                                                    array<Funnel, 2>& funnels) const {
@@ -3718,9 +3701,7 @@ MinimizerMapper::identify_supplementary_alignments(vector<std::array<vector<Alig
                     // Shift into the front of the vector
                     paired_alignments[i - s] = paired_alignments[i];
                     paired_scores[i - s] = paired_scores[i];
-                    fragment_distances[i - s] = fragment_distances[i];
                     pair_types[i - s] = pair_types[i];
-                    better_cluster_count_by_pairs[i - s] = better_cluster_count_by_pairs[s];
 
                 }
             }
@@ -3746,9 +3727,7 @@ MinimizerMapper::identify_supplementary_alignments(vector<std::array<vector<Alig
 
             paired_alignments.resize(paired_alignments.size() - s);
             paired_scores.resize(paired_alignments.size());
-            fragment_distances.resize(paired_alignments.size());
             pair_types.resize(paired_alignments.size());
-            better_cluster_count_by_pairs.resize(paired_alignments.size());
         }
         else {
             if (show_work) {

src/minimizer_mapper.hpp

@@ -993,9 +993,7 @@ class MinimizerMapper : public AlignerClient {
     array<vector<read_alignment_index_t>, 2> identify_supplementary_alignments(vector<std::array<vector<Alignment>, 2>>& alignments,
                                                                   vector<std::array<read_alignment_index_t, 2>>& paired_alignments, 
                                                                   vector<double>& paired_scores,
-                                                                  vector<int64_t>& fragment_distances,
                                                                   vector<PairType>& pair_types,
-                                                                  vector<size_t>& better_cluster_count_by_pairs,
                                                                   const vector<alignment_index_t>& unpaired_alignments,
                                                                   const vector<bool>& attempted_rescue_from,
                                                                   array<Funnel, 2>& funnels) const;

src/recombinator.cpp

@@ -1727,12 +1727,9 @@ gbwt::GBWT Recombinator::generate_haplotypes(const std::string& kff_file, const
     std::vector<std::vector<gbwt::size_type>> reference_paths(this->haplotypes.jobs());
     if (parameters.include_reference) {
         for (size_t i = 0; i < this->gbz.graph.named_paths.size(); i++) {
-            gbwt::size_type path_id = this->gbz.graph.named_paths[i].id;
-            std::string path_name = gbwtgraph::compose_path_name(
-                this->gbz.index, path_id, this->gbz.graph.named_paths[i].sense);
             size_t job_id = this->jobs_for_cached_paths[i];
             if (job_id < this->haplotypes.jobs()) {
-                reference_paths[job_id].push_back(path_id);
+                reference_paths[job_id].push_back(this->gbz.graph.named_paths[i].id);
             }
         }
     }

src/subcommand/depth_main.cpp

@@ -227,15 +227,14 @@ int main_depth(int argc, char** argv) {
                 subrange_t subrange;
                 string base_name = Paths::strip_subrange(path_name, &subrange);
                 base_path_set.insert(base_name);
-                // just take anything if no selection (excluding alt paths)
-                bool use_it = !Paths::is_alt(path_name) &&
-                              path_prefixes.empty() && ref_paths_input_set.empty();
+                // just take anything if no selection
+                bool use_it = !Paths::is_alt(path_name) && path_prefixes.empty() && ref_paths_input_set.empty();
 
                 // then look in the input paths -p
                 if (!use_it && ref_paths_input_set.count(base_name)) {
                     use_it = true;
                 }
-
+                
                 // then look in the prefixes
                 for (size_t i = 0; i < path_prefixes.size() && !use_it; ++i) {
                     if (path_name.substr(0, path_prefixes[i].length()) == path_prefixes[i]) {

src/subcommand/giraffe_main.cpp

@@ -688,10 +688,7 @@ void help_giraffe(char** argv, const BaseOptionGroup& parser, const std::map<std
              << "                                in the GR tag as a cs-style difference string" << endl
              << "  -n, --discard                 discard all output alignments (for profiling)" << endl
              << "      --output-basename NAME    write output to a GAM file with the given prefix" << endl
-             << "                                for each setting combination. Setting values for" << endl
-             << "                                many other options can be provided as ranges" << endl
-             << "                                in the format start[:end[:step]], with end"
-             << "                                being inclusive." << endl
+             << "                                for each setting combination" << endl
              << "      --report-name FILE        write a TSV of output file and mapping speed" << endl
              << "      --show-work               log how the mapper comes to its conclusions" << endl
              << "                                about mapping locations (use one read at a time)" << endl;

src/subcommand/stats_main.cpp

@@ -1196,8 +1196,7 @@ int main_stats(int argc, char** argv) {
                 }
                 vector<string> ref_path_names;
                 pp_graph->for_each_path_of_sample(snarl_sample, [&](path_handle_t path_handle) {
-                    string path_name = graph->get_path_name(path_handle);
-                    ref_path_names.push_back(path_name);
+                    ref_path_names.push_back(graph->get_path_name(path_handle));
                     extra_node_weight[graph->get_id(graph->get_handle_of_step(graph->path_begin(path_handle)))] += EXTRA_WEIGHT;
                     extra_node_weight[graph->get_id(graph->get_handle_of_step(graph->path_back(path_handle)))] += EXTRA_WEIGHT;
                 });

src/subcommand/surject_main.cpp

@@ -33,7 +33,7 @@ using namespace vg;
 using namespace vg::subcommand; 
 
 void help_surject(char** argv) {
-    cerr << "usage: " << argv[0] << " surject [options] <aln.gam> >[proj.gam]" << endl
+    cerr << "usage: " << argv[0] << " surject [options] <aln.gam> >[proj.cram]" << endl
          << "Transforms alignments to be relative to particular paths." << endl
          << endl
          << "options:" << endl
@@ -50,9 +50,9 @@ void help_surject(char** argv) {
          << "                            overlapping paths instead of just primary" << endl
          << "  -G, --gaf-input           input file is GAF instead of GAM" << endl
          << "  -m, --gamp-input          input file is GAMP instead of GAM" << endl
-         << "  -c, --cram-output         write CRAM instead of GAM to stdout" << endl
-         << "  -b, --bam-output          write BAM instead of GAM to stdout" << endl
-         << "  -s, --sam-output          write SAM instead of GAM to stdout" << endl
+         << "  -c, --cram-output         write CRAM to stdout" << endl
+         << "  -b, --bam-output          write BAM to stdout" << endl
+         << "  -s, --sam-output          write SAM to stdout" << endl
          << "  -u, --supplementary       divide into supplementary alignments as necessary" << endl
          << "  -l, --subpath-local       let the multipath mapping surjection produce local" << endl
          << "                            (rather than global) alignments" << endl

src/zip_code.cpp

@@ -8,8 +8,8 @@ using namespace std;
 // Make sure that the default / empty payload exists as a value that can be pointed to.
 constexpr std::pair<gbwtgraph::KmerEncoding::code_type, gbwtgraph::KmerEncoding::code_type> MIPayload::NO_CODE;
 
-void ZipCode::fill_in_zipcode_from_pos(const SnarlDistanceIndex& distance_index, const pos_t& pos, 
-                                       bool fill_in_decoder, const handlegraph::HandleGraph* graph_ptr) {
+void ZipCode::fill_in_zipcode_from_pos(const SnarlDistanceIndex& distance_index, const pos_t& pos, bool fill_in_decoder) {
+
     std::vector<net_handle_t> ancestors;
     net_handle_t current_handle = distance_index.get_node_net_handle(id(pos));
 
@@ -121,7 +121,7 @@ void ZipCode::fill_in_zipcode_from_pos(const SnarlDistanceIndex& distance_index,
                 }
                 return;
             }
-        } else if (distance_index.is_regular_snarl(current_ancestor, false, graph_ptr)) {
+        } else if (distance_index.is_regular_snarl(current_ancestor)) {
             snarl_code_t snarl_code = get_regular_snarl_code(current_ancestor, ancestors[i-1], distance_index); 
             zipcode.add_value(snarl_code.get_raw_code_type());
             zipcode.add_value(snarl_code.get_raw_prefix_sum_or_identifier());

src/zip_code.hpp

@@ -68,8 +68,7 @@ class ZipCode {
     public:
 
         //Fill in an empty zipcode given a position
-        void fill_in_zipcode_from_pos(const SnarlDistanceIndex& distance_index, const vg::pos_t& pos, 
-                                      bool fill_in_decoder = true, const handlegraph::HandleGraph* graph_ptr = nullptr);
+        void fill_in_zipcode_from_pos(const SnarlDistanceIndex& distance_index, const vg::pos_t& pos, bool fill_in_decoder = true);
 
         using code_type = gbwtgraph::KmerEncoding::code_type;
         typedef std::pair<code_type, code_type> payload_type;