Change sfs_solution_t to use maps.

Author: Parsoa

aggregator.cpp

@@ -30,7 +30,7 @@ void Aggregator::find_high_abundance_sequences() {
             if (_sequences[j].find(hash) == _sequences[j].end()) {
                 _sequences[j][hash] = 0 ;
             }
-            _sequences[j][hash] += std::stoi(tokens[4]) ;
+            _sequences[j][hash] += 1 ; // std::stoi(tokens[4]) ; it's always 1
         }
         txt_file.close() ;
     }
@@ -78,16 +78,16 @@ void Aggregator::load_sequences() {
         while (std::getline(txt_file, line)) {
             istringstream iss(line) ;
             vector<string> tokens{istream_iterator<string>{iss}, istream_iterator<string>{}} ;
-            string canon = canonicalize(tokens[1]) ;
             if (read == "*") {
                 read = tokens[0] ;
             }
+            string canon = canonicalize(tokens[1]) ;
             int hash = std::hash<std::string>()(canon) ;
             if (sequence_index.find(hash) != sequence_index.end()) {
                 if (_sequences[j].find(canon) == _sequences[j].end()) {
                     _sequences[j][canon] = 0 ;
                 }
-                _sequences[j][canon] += std::stoi(tokens[4]) ;
+                _sequences[j][canon] += 1 ; //std::stoi(tokens[4]) ;
                 _read_ids[j][canon][read] = 1 ;
             }
         }
@@ -102,6 +102,7 @@ void Aggregator::load_sequences() {
             }
             sequences[it->first] += it->second ;
             read_ids[it->first].insert(_read_ids[j][it->first].begin(), _read_ids[j][it->first].end()) ;
+            assert(sequences[it->first] == read_ids[it->first].size()) ;
         }
         _sequences[j].clear() ;
     }

ping_pong.cpp

@@ -53,7 +53,7 @@ bool PingPong::backward_search(rld_t *index, const uint8_t *P, int p2) {
     return sai.x[2] != 0 ;
 }
 
-void PingPong::ping_pong_search(rld_t *index, fastq_entry_t fqe, std::vector<sfs_solution_t>& solutions) {
+void PingPong::ping_pong_search(rld_t *index, const fastq_entry_t& fqe, std::vector<sfs_solution_t>& solutions) {
     int l = fqe.seq.size() ;
     if (l <= 10) {
         return ;
@@ -101,18 +101,9 @@ void PingPong::ping_pong_search(rld_t *index, fastq_entry_t fqe, std::vector<sfs
         DEBUG(cerr << "Mismatch " << int2char[P[end]] << " (" << end << "). fmatches: " << fmatches << endl ;)
         // add solution
         DEBUG(cerr << "Adding [" << begin << ", " << end << "]." << endl ;)
-        int acc_len = end - begin + 1 ;
         int sfs_len = end - begin + 1 ;
-        //if (config->min_string_length > 0) {
-        //    sfs_len = acc_len > config->min_string_length ? acc_len : config->min_string_length ;
-        //    if (begin + sfs_len >= l - 1) {
-        //        sfs_len = acc_len ;
-        //    }
-        //    assert(sfs_len == config->min_string_length || sfs_len == acc_len) ;
-        //    DEBUG(cerr << "Adjusted length to " << sfs_len << "." << endl ;)
-        //}
+        int acc_len = end - begin + 1 ;
         DEBUG(cerr << "Adjusted length from " << acc_len << " to " << sfs_len << "." << endl ;)
-
         // CHECKMERGE
         solutions.push_back(sfs_solution_t{begin, sfs_len, fqe.seq.substr(begin, sfs_len)});
         // if (!check_solution(index, fqe.seq.substr(begin, sfs_len))) {
@@ -200,10 +191,10 @@ bool PingPong::load_batch_fastq(int threads, int batch_size, int p) {
     return n != 0 ? true : false ;
 }
 
-batch_type_t PingPong::process_batch(rld_t* index, vector<fastq_entry_t> fastq_entries) {
+batch_type_t PingPong::process_batch(rld_t* index, const vector<fastq_entry_t>& fastq_entries) {
     batch_type_t solutions ;
     // store read id once for all strings to save space, is it worth it?
-    for (const auto fastq_entry: fastq_entries) {
+    for (const auto &fastq_entry: fastq_entries) {
         ping_pong_search(index, fastq_entry, solutions[fastq_entry.head]) ;
     }
     return solutions ;

ping_pong.hpp

@@ -65,7 +65,7 @@ static unsigned char seq_nt6_table[128] = {
     5, 5, 5, 5,  4, 5, 5, 5,  5, 5, 5, 5,  5, 5, 5, 5
 } ;
 
-typedef std::unordered_map<std::string, std::vector<sfs_solution_t>> batch_type_t; 
+typedef std::map<std::string, std::vector<sfs_solution_t>> batch_type_t; 
 
 static const std::vector<std::string> int2char ({"$", "A", "C", "G", "T", "N"}) ;
 
@@ -99,13 +99,13 @@ class PingPong {
     bool load_batch_fastq(int threads, int batch_size, int p) ;
 
     //batch_type_t search_solutions ;
-    batch_type_t process_batch(rld_t* index, std::vector<fastq_entry_t> fastq_entries) ;
+    batch_type_t process_batch(rld_t* index, const std::vector<fastq_entry_t>& fastq_entries) ;
     std::vector<std::vector<batch_type_t>> batches ;
     void output_batch(int) ;
 
     bool check_solution(rld_t* index, std::string S) ;
     bool backward_search(rld_t *index, const uint8_t *P, int p2) ;
-    void ping_pong_search(rld_t *index, fastq_entry_t fqe, std::vector<sfs_solution_t>&) ;
+    void ping_pong_search(rld_t *index, const fastq_entry_t &fqe, std::vector<sfs_solution_t>&) ;
     fastq_entry_t get_solution(fastq_entry_t fqe, int s, int l) ;
 
     Configuration* config ;