Remove references to reconstructor.

Author: Parsoa

main.cpp

@@ -22,7 +22,7 @@
 
 #include "caller.hpp"
 #include "assembler.hpp"
-#include "reconstructor.hpp"
+#include "smoother.hpp"
 
 #ifdef LOCAL_BUILD
 #include "finder.hpp"
@@ -68,7 +68,7 @@ void print_help() {
     cerr << "\tAssmble SFS into superstrings:" << endl ;
     cerr << "\t\tSVDSS assemble --workdir /path/to/.sfs/files --batches /number/of/SFS/batches" << endl ;
     cerr << "\tReconstruct sample:" << endl ;
-    cerr << "\t\tSVDSS reconstruct --workdir /output/file/direcotry --bam /path/to/input/bam/file --reference /path/to/reference/genome/fasta" << endl ;
+    cerr << "\t\tSVDSS smooth --workdir /output/file/direcotry --bam /path/to/input/bam/file --reference /path/to/reference/genome/fasta" << endl ;
     cerr << "\tCall SVs:" << endl ;
     cerr << "\t\tSVDSS call --workdir /path/to/assembled/.sfs/files --bam /path/to/input/bam/file --reference /path/to/reference/genome/fasta" << endl ;
     cerr << "\t\tOptional arguments: " << endl ;
@@ -102,9 +102,9 @@ int main(int argc, char** argv) {
     } else if (strcmp(argv[1], "assemble") == 0) {
         auto assembler = new Assembler() ;
         assembler->run() ;
-    } else if (strcmp(argv[1], "reconstruct") == 0) {
-        auto reconstructor = new Reconstructor() ;
-        reconstructor->run() ;
+    } else if (strcmp(argv[1], "smooth") == 0) {
+        auto smoother = new Smoother() ;
+        smoother->run() ;
     } else {
         print_help() ;
     }

ping_pong.cpp

@@ -56,9 +56,9 @@ bool PingPong::backward_search(rld_t *index, const uint8_t *P, int p2) {
     return sai.x[2] != 0 ;
 }
 
-// This will be very fast for reconstructed reads
-// However non-reconstructed reads are going to produce loads of crappy SFS, unless we filter them
-void PingPong::ping_pong_search(rld_t *index, uint8_t* P, int l, std::vector<sfs_type_t>& solutions, bool isreconstructed, bam1_t* aln) {
+// This will be very fast for smoothed reads
+// However non-smoothed reads are going to produce loads of crappy SFS, unless we filter them
+void PingPong::ping_pong_search(rld_t *index, uint8_t* P, int l, std::vector<sfs_type_t>& solutions, bool is_smoothed, bam1_t* aln) {
     //cout << bam_get_qname(aln) << endl ;
     rldintv_t sai ;
     int begin = l - 1 ;
@@ -204,18 +204,18 @@ batch_type_t PingPong::process_batch(rld_t* index, int p, int i) {
     } else {
         for (int j = 0; j < read_seqs[p][i].size(); j++) {
             char *qname = bam_get_qname(bam_entries[p][i][j]) ;
-            bool isreconstructed = reconstructed_reads.find(qname) != reconstructed_reads.end() ;
+            bool is_smoothed = smoothed_reads.find(qname) != smoothed_reads.end() ;
             if (config->putative) {
                 if (ignored_reads.find(qname) != ignored_reads.end()) {
                     continue ;
                 }
-                // was not ignored, so either it's reconstructed or not:
-                if (!isreconstructed) {
+                // was not ignored, so either it's smoothed or not:
+                if (!is_smoothed) {
                     continue ;
                 }
             }
-            //cout << qname << " " << isreconstructed << endl ;
-            ping_pong_search(index, read_seqs[p][i][j], read_seq_lengths[p][i][j], solutions[qname], isreconstructed, bam_entries[p][i][j]) ;
+            //cout << qname << " " << is_smoothed << endl ;
+            ping_pong_search(index, read_seqs[p][i][j], read_seq_lengths[p][i][j], solutions[qname], is_smoothed, bam_entries[p][i][j]) ;
         }
     }
     return solutions ;
@@ -280,7 +280,7 @@ int PingPong::search() {
     }
     if (config->putative) {
         lprint({"Putative SFS extraction enabled."}) ;
-        load_reconstructed_read_ids() ;
+        load_smoothed_read_ids() ;
     }
     // allocate all necessary stuff 
     int p = 0 ;
@@ -412,8 +412,8 @@ int PingPong::search() {
     return u ;
 }
 
-void PingPong::load_reconstructed_read_ids() {
-    lprint({"Loading reconstructed read ids.."}) ;
+void PingPong::load_smoothed_read_ids() {
+    lprint({"Loading smoothed read ids.."}) ;
     ifstream ignore_file(config->workdir + "/ignored_reads.txt") ;
     if (ignore_file.is_open()) {
         string read_name;
@@ -422,16 +422,16 @@ void PingPong::load_reconstructed_read_ids() {
         }
         ignore_file.close() ;
     }
-    ifstream in_file(config->workdir + "/reconstructed_reads.txt") ;
+    ifstream in_file(config->workdir + "/smoothed_reads.txt") ;
     if (in_file.is_open()) {
         string read_name;
         while (getline(in_file, read_name)) {
-            reconstructed_reads[read_name] = true ;
+            smoothed_reads[read_name] = true ;
         }
         in_file.close() ;
     }
     lprint({"Loaded", to_string(ignored_reads.size()), "ignored read ids."}) ;
-    lprint({"Loaded", to_string(reconstructed_reads.size()), "reconstructed read ids."}) ;
+    lprint({"Loaded", to_string(smoothed_reads.size()), "smoothed read ids."}) ;
 }
 
 // ============================================================================= \\

ping_pong.hpp

@@ -93,9 +93,9 @@ class PingPong {
     samFile *bam_file ;
     bam_hdr_t *bam_header ;
 
-    unordered_map<string, bool> reconstructed_reads ;
+    unordered_map<string, bool> smoothed_reads ;
     unordered_map<string, bool> ignored_reads ;
-    void load_reconstructed_read_ids() ;
+    void load_smoothed_read_ids() ;
 
     std::vector<std::vector<std::vector<int>>> read_seq_lengths ;
     std::vector<std::vector<std::vector<int>>> read_seq_max_lengths ;
@@ -105,7 +105,7 @@ class PingPong {
     bool load_batch_bam(int threads, int batch_size, int p) ;
     bool load_batch_fastq(int threads, int batch_size, int p) ;
     batch_type_t process_batch(rld_t* index, int p, int i) ;
-    void ping_pong_search(rld_t *index, uint8_t* seq, int l, std::vector<sfs_type_t>& solutions, bool isreconstructed, bam1_t*) ;
+    void ping_pong_search(rld_t *index, uint8_t* seq, int l, std::vector<sfs_type_t>& solutions, bool is_smoothed, bam1_t*) ;
     void output_batch(int) ;
 
     std::vector<std::vector<batch_type_t>> batches ;

reconstructor.cpp smoother.cpp

@@ -1,4 +1,4 @@
-#include "reconstructor.hpp"
+#include "smoother.hpp"
 
 using namespace std ;
 
@@ -80,7 +80,7 @@ void rebuild_bam_entry(bam1_t* alignment, char* seq, uint8_t* qual, vector<pair<
     free(aux) ;
 }
 
-void Reconstructor::reconstruct_read(bam1_t* alignment, char* read_seq, string chrom, int _i, int _j, int _k) {
+void Smoother::smooth_read(bam1_t* alignment, char* read_seq, string chrom, int _i, int _j, int _k) {
     auto cigar_offsets = decode_cigar(alignment) ;
     int l = 0 ;
     // try and filter unintenresting reads early on
@@ -213,11 +213,11 @@ void Reconstructor::reconstruct_read(bam1_t* alignment, char* read_seq, string c
         ignored_reads[omp_get_thread_num() - 2].push_back(qname) ;
         return ;
     }
-    reconstructed_reads[omp_get_thread_num() - 2].push_back(qname) ;
+    smoothed_reads[omp_get_thread_num() - 2].push_back(qname) ;
     rebuild_bam_entry(alignment, new_seq, new_qual, new_cigar) ;
 }
 
-void Reconstructor::process_batch(vector<bam1_t*> bam_entries, int p, int i) {
+void Smoother::process_batch(vector<bam1_t*> bam_entries, int p, int i) {
     bam1_t* alignment ;
     for (int b = 0; b < bam_entries.size(); b++) {
         alignment = bam_entries[b] ;
@@ -238,20 +238,20 @@ void Reconstructor::process_batch(vector<bam1_t*> bam_entries, int p, int i) {
         if (chromosome_seqs.find(chrom) == chromosome_seqs.end()) {
             continue ;
         }
-        reconstruct_read(alignment, read_seqs[p][i][b], chrom, p, i, b) ;
+        smooth_read(alignment, read_seqs[p][i][b], chrom, p, i, b) ;
     }
 }
 
 // BAM writing based on https://www.biostars.org/p/181580/
-void Reconstructor::run() {
+void Smoother::run() {
     config = Configuration::getInstance() ;
     load_chromosomes(config->reference) ;
     // parse arguments
     bam_file = hts_open(config->bam.c_str(), "r") ;
     bam_index = sam_index_load(bam_file, config->bam.c_str()) ;
     bam_header = sam_hdr_read(bam_file) ; //read header
     bgzf_mt(bam_file->fp.bgzf, 8, 1) ;
-    auto out_bam_path = config->workdir + (config->selective ? "/reconstructed.selective.bam" : "/reconstructed.bam") ;
+    auto out_bam_path = config->workdir + (config->selective ? "/smoothed.selective.bam" : "/smoothed.bam") ;
     out_bam_file = hts_open(out_bam_path.c_str(), "wb") ;
     bgzf_mt(out_bam_file->fp.bgzf, 8, 1) ;
     int r = sam_hdr_write(out_bam_file, bam_header) ;
@@ -292,7 +292,7 @@ void Reconstructor::run() {
     load_batch_bam(config->threads, batch_size, 1) ;
     int p = 1 ;
     ignored_reads.resize(config->threads) ;
-    reconstructed_reads.resize(config->threads) ;
+    smoothed_reads.resize(config->threads) ;
     time_t t ;
     time(&t) ;
     bool should_load = true ;
@@ -376,22 +376,22 @@ void Reconstructor::run() {
     lprint({"Done."});
     sam_close(bam_file) ;
     sam_close(out_bam_file) ;
-    dump_reconstructed_read_ids() ;
+    dump_smoothed_read_ids() ;
     lprint({"Loaded", to_string(reads_processed), "reads."});
     lprint({"Wrote", to_string(reads_written), "reads."});
 }
 
-void Reconstructor::dump_reconstructed_read_ids() {
-    lprint({"Dumping reconstructed read ids.."}) ;
-    ofstream qname_file(config->workdir + "/reconstructed_reads.txt") ;
+void Smoother::dump_smoothed_read_ids() {
+    lprint({"Dumping smoothed read ids.."}) ;
+    ofstream qname_file(config->workdir + "/smoothed_reads.txt") ;
     if (qname_file.is_open()) {
         for (int i = 0; i < config->threads; i++) {
-            for (const auto& qname: reconstructed_reads[i]) {
+            for (const auto& qname: smoothed_reads[i]) {
                 qname_file << qname << endl ;
             }
         }
     } else {
-        lprint({"Error openning reconstructed_reads.txt."}, 2) ;
+        lprint({"Error openning smoothed_reads.txt."}, 2) ;
     }
     qname_file.close() ;
     ofstream ignore_file(config->workdir + "/ignored_reads.txt") ;
@@ -407,7 +407,7 @@ void Reconstructor::dump_reconstructed_read_ids() {
     }
 }
 
-bool Reconstructor::load_batch_bam(int threads, int batch_size, int p) {
+bool Smoother::load_batch_bam(int threads, int batch_size, int p) {
     int n = 0 ;
     int i = 0 ;
     int m = 0 ;

reconstructor.hpp smoother.hpp

@@ -27,7 +27,7 @@ using namespace std ;
 
 #define bam_set_seqi(s,i,b) ((s)[(i)>>1] = ((s)[(i)>>1] & (0xf0 >> ((~(i)&1)<<2))) | ((b)<<((~(i)&1)<<2)))
 
-class Reconstructor {
+class Smoother {
 
 public:
 
@@ -38,7 +38,7 @@ class Reconstructor {
     // output BAM file
     samFile* out_bam_file ;
     // <time < batch < reads > > >
-    std::vector<std::vector<std::string>> reconstructed_reads ;
+    std::vector<std::vector<std::string>> smoothed_reads ;
     std::vector<std::vector<std::string>> ignored_reads ;
     std::vector<std::vector<std::vector<bam1_t*>>> bam_entries ;
 
@@ -51,7 +51,7 @@ class Reconstructor {
     void run() ;
     bool load_batch_bam(int threads, int batch_size, int p) ;
     void process_batch(std::vector<bam1_t*> bam_entries, int , int) ;
-    void reconstruct_read(bam1_t* alignment, char* read_seq, std::string chrom, int, int, int) ;
+    void smooth_read(bam1_t* alignment, char* read_seq, std::string chrom, int, int, int) ;
 
     Configuration* config ;
 
@@ -64,7 +64,7 @@ class Reconstructor {
     int num_ignored_reads = 0 ;
     int reads_processed = 0 ;
 
-    void dump_reconstructed_read_ids() ;
+    void dump_smoothed_read_ids() ;
 };
 
 #endif