Added advanced settings and usability

Author: feeka

include/cycle_finder.h

@@ -9,6 +9,7 @@
 #include <stack>
 #include <omp.h>
 #include "path_writer.h"
+#include "settings.h"
 #include <unordered_set>
 //#include "progressbar.hpp"
 #include <list>
@@ -23,15 +24,15 @@ using namespace std;
 
 class CycleFinder {
     private:
-        uint8_t maximal_length;
-        uint8_t minimal_length;
+        // Use Settings to configure CycleFinder globally
+        Settings& settings;
         static constexpr size_t MAX_EDGE_COUNT = 4;
-        SDBG& sdbg;
-        
+        // Use SDBG pointer from settings everywhere instead of storing a separate reference
+        //SDBG& sdbg;
         uint16_t cluster_bounds;
         vector<bool> visited;
         vector<bool> look_up_table;
-        int threads_count;
+        // thread count obtained from settings
 
         //#### DEVELOPER FUNCTIONS ####
         void _WriteStartNodesToFile(const map<int, vector<uint64_t>, greater<int>>& start_nodes_chunked, const std::string& filename);
@@ -53,8 +54,8 @@ class CycleFinder {
         //#### HELPER FUNCTIONS FOR DLS ####
 
     public:
-        string genome_name;
-        CycleFinder(SDBG& sdbg, int length_bound, int minimal_length, string genome_name,int threads_count);
+        // genome/cycles folder available via settings
+        CycleFinder(Settings& settings);
         //write a getter for results
         unordered_map<uint64_t, vector<vector<uint64_t>>> results;
 

include/phage_curator.h

@@ -50,6 +50,8 @@ class PhageCurator {
     std::vector<std::vector<uint64_t>> BeamSearchPathsAvoiding(uint64_t start, int lower, int higher, const std::set<uint64_t>& forbidden, int beam_width, double min_mult, double max_mult, std::function<void(const std::vector<uint64_t>&)> path_callback = nullptr);
     std::map<std::string,vector<string>> FindQualityPathsBeamSearchFromGroupedPaths(int min_length, int max_length, const std::string& filename, int beam_width);
     std::string ComputeConsensusForCurrentGroup(vector<string> sequences);
+    std::vector<vector<uint64_t>> GetTopPathsFromBeamPaths(const std::vector<std::vector<uint64_t>>& beam_paths,int max,int min,size_t top_n);
+
 };
 
 #endif // PHAGE_CURATOR_H

include/settings.h

@@ -4,31 +4,53 @@
 #include <iostream>
 #include <string>
 #include <map>
+#include <vector>
 #include <thread>
 #include <filesystem>
 #include <chrono>
 #include <iomanip>
 #include <sstream>
+#include <algorithm>
+#include <stdexcept>
+#include <cctype>
+#include "sdbg/sdbg.h"
+#include <fstream>
 
 using namespace std;
 namespace fs = std::filesystem;
 
 struct Settings {
-    std::string input_files;
-    double ram = 0.0; // In gigabytes
-    size_t threads = 0;
-    std::string output_folder = "out";
-    std::string graph_folder;
-    std::string cycles_folder;
-    std::string output_file;
+    std::string input_files; // Path to the input files
+    double ram = 0.0; // Maximum RAM usage in gigabytes
+    size_t threads = 0; // Number of threads to use
+    std::string output_folder; // Output directory path. Empty until chosen by CLI or settings file.
+    std::string graph_folder; // Folder for graph data
+    std::string cycles_folder; // Folder for cycle data
+    std::string output_file; // Path to the main output file
+    // Sdbg
+
+    struct CycleFinderSettings {
+        uint64_t threshold_multiplicity = 20; // Minimum multiplicity threshold
+        bool low_abundance = true; // Flag to enable low abundance mode
+        int cycle_max_length = 77; // Maximum length of a cycle
+        int cycle_min_length = 27; // Minimum length of a cycle
+    } cycle_finder_settings;
+    struct DNASequenceSettings {
+        int spacer_min_length = 23; // Minimum length of a spacer
+        int spacer_max_length = 50; // Maximum length of a spacer
+        int repeat_min_length = 23; // Minimum length of a repeat
+        int repeat_max_length = 50; // Maximum length of a repeat
+    } dna_sequence_settings;
+
+    SDBG* sdbg = nullptr; // Pointer to the SDBG graph
 
     Settings() {
-        // Generate timestamp for folder structure
-        string timestamp = get_timestamp();
-        output_folder = "" + timestamp;
-        graph_folder = output_folder + "/graph";
-        cycles_folder = output_folder + "/cycles";
-        output_file = output_folder + "/CRISPR_Arrays.txt";
+        // Defaults are intentionally empty so parse_arguments can apply
+        // a timestamp-based default only if neither CLI nor settings file specify the output folder.
+        output_folder = "";
+        graph_folder = "";
+        cycles_folder = "";
+        output_file = "";
     }
 
     // Generate timestamp in YYYY-MM-DD_HH-MM-SS format
@@ -91,6 +113,110 @@ struct Settings {
         }
         return erroneous_properties;
     }
+
+    // Read settings values from a simple key=value file. Lines starting with # or // are ignored.
+    // Keys mirror struct property names; examples:
+    // input_files=/path/a.fa /path/b.fa
+    // ram=4G
+    // threads=4
+    // cycle_max_length=77
+    // cycle_min_length=27
+    // threshold_multiplicity=20
+    // low_abundance=true
+    bool LoadFromFile(const std::string& path) {
+        std::ifstream file(path);
+        if (!file.is_open()) {
+            std::cerr << "Could not open settings file: " << path << std::endl;
+            return false;
+        }
+        std::string line;
+        auto trim = [](std::string s) {
+            // trim in place
+            const char* ws = " \t\n\r\f\v";
+            s.erase(0, s.find_first_not_of(ws));
+            s.erase(s.find_last_not_of(ws) + 1);
+            return s;
+        };
+        while (std::getline(file, line)) {
+            // Remove comments
+            size_t posc = line.find('#');
+            if (posc != std::string::npos) line = line.substr(0, posc);
+            size_t pos2 = line.find("//");
+            if (pos2 != std::string::npos) line = line.substr(0, pos2);
+            string s = trim(line);
+            if (s.empty()) continue;
+            size_t eq = s.find('=');
+            if (eq == std::string::npos) continue;
+            string key = trim(s.substr(0, eq));
+            string val = trim(s.substr(eq + 1));
+
+            // Interpret known keys
+            if (key == "input_files") {
+                // allow space/comma/semicolon-separated file list; normalize to single-space separated
+                vector<string> tokens;
+                string cur;
+                for (char c : val) {
+                    if (c == ',' || c == ';') c = ' ';
+                    if (!isspace(static_cast<unsigned char>(c))) {
+                        cur.push_back(c);
+                    } else {
+                        if (!cur.empty()) {
+                            tokens.push_back(cur);
+                            cur.clear();
+                        }
+                    }
+                }
+                if (!cur.empty()) tokens.push_back(cur);
+                // join with single space so older code (SDBGBuild) gets consistent formatting
+                this->input_files.clear();
+                for (size_t i = 0; i < tokens.size(); ++i) {
+                    this->input_files += tokens[i];
+                    if (i + 1 < tokens.size()) this->input_files += " ";
+                }
+            } else if (key == "ram") {
+                // reuse same parsing as CLI: accept B/K/M/G suffix
+                try {
+                    double value = 0.0;
+                    char unit = 'G';
+                    size_t p = val.find_first_not_of("0123456789.");
+                    if (p != std::string::npos) {
+                        value = stod(val.substr(0, p));
+                        unit = toupper(val[p]);
+                    } else {
+                        value = stod(val);
+                    }
+                    switch (unit) {
+                        case 'B': this->ram = value / (1024.0 * 1024.0 * 1024.0); break;
+                        case 'K': this->ram = value / (1024.0 * 1024.0); break;
+                        case 'M': this->ram = value / 1024.0; break;
+                        case 'G': this->ram = value; break;
+                        default: throw runtime_error("Invalid RAM unit in settings file: " + val);
+                    }
+                } catch (...) {
+                    std::cerr << "Warning: could not parse RAM value '" << val << "' in settings file" << std::endl;
+                }
+            } else if (key == "threads") {
+                try { this->threads = stoul(val); } catch (...) { }
+            } else if (key == "output_folder") { this->output_folder = val; }
+            else if (key == "graph_folder") { this->graph_folder = val; }
+            else if (key == "cycles_folder") { this->cycles_folder = val; }
+            else if (key == "output_file") { this->output_file = val; }
+            else if (key == "cycle_max_length") { this->cycle_finder_settings.cycle_max_length = stoi(val); }
+            else if (key == "cycle_min_length") { this->cycle_finder_settings.cycle_min_length = stoi(val); }
+            else if (key == "threshold_multiplicity") { this->cycle_finder_settings.threshold_multiplicity = stoull(val); }
+            else if (key == "low_abundance") {
+                std::transform(val.begin(), val.end(), val.begin(), ::tolower);
+                this->cycle_finder_settings.low_abundance = (val == "true" || val == "1" || val == "yes");
+            }
+            else if (key == "spacer_min_length") { this->dna_sequence_settings.spacer_min_length = stoi(val); }
+            else if (key == "spacer_max_length") { this->dna_sequence_settings.spacer_max_length = stoi(val); }
+            else if (key == "repeat_min_length") { this->dna_sequence_settings.repeat_min_length = stoi(val); }
+            else if (key == "repeat_max_length") { this->dna_sequence_settings.repeat_max_length = stoi(val); }
+            // unknown keys are ignored for forward-compatibility
+        }
+        file.close();
+        return true;
+    }
 };
 
-#endif
+#endif // SETTINGS_H

readme.md

@@ -130,6 +130,32 @@ The tool creates the following directory structure inside the specified output f
 
 ---
 
+### ⚙️ Settings file support
+
+Create a simple key=value text file (one setting per line) and pass it with `--settings /path/to/file`.
+
+The program reads values from this file unless you override them with CLI flags. If you change the file, run the program again — new values will be used.
+
+Example of ```settings.txt``` (must include `input_files`):
+```
+# MUST INCLUDE
+input_files=/data/sample_folder/1.fastq /data/sample_folder/2.fastq.fastq
+ram=128G
+threads=26
+output_folder=results/run_2025-11-19
+# OPTIONAL
+cycle_max_length=77
+cycle_min_length=27
+threshold_multiplicity=20
+low_abundance=true
+```
+
+Notes:
+- `input_files` accepts one or two paths; entries may be separated by spaces, commas, or semicolons.
+- Terminal values will override the ```settings.txt```. For example for simplicity you can use the ```settings.txt``` file and change only ```-i``` parameter.
+
+---
+
 #### Requirements
 
 - C++17 compiler