Minimac4
Loading...
Searching...
No Matches
prog_args.hpp
Go to the documentation of this file.
1#ifndef MINIMAC4_PROG_ARGS_HPP
2#define MINIMAC4_PROG_ARGS_HPP
3
4#include "getopt_wrapper.hpp"
5
6#include <savvy/reader.hpp>
7
8#include <string>
9#include <vector>
10#include <unordered_set>
11#include <cstdint>
12#include <cstdlib>
13#include <fstream>
14#include <iterator>
15
23{
24private:
25 std::string ref_path_;
26 std::string tar_path_;
27 std::string map_path_;
28 std::string out_path_ = "/dev/stdout";
29 std::string temp_prefix_;
30 std::string prefix_;
31 std::string emp_out_path_;
32 std::string sites_out_path_;
33 savvy::file::format out_format_ = savvy::file::format::sav;
34 std::uint8_t out_compression_ = 6;
35 std::vector<std::string> fmt_fields_ = {"HDS"};
36 std::unordered_set<std::string> sample_ids_;
37 savvy::genomic_region reg_ = {""};
38 std::size_t temp_buffer_ = 200;
39 std::size_t min_block_size_ = 10;
40 std::size_t max_block_size_ = 0xFFFF;
41 std::size_t slope_unit_ = 10;
42 std::int64_t chunk_size_ = 20000000;
43 std::int64_t overlap_ = 3000000;
44 std::int16_t threads_ = 1;
45 float decay_ = 0.f;
46 float min_r2_ = -1.f;
47 float min_ratio_ = 1e-4f;
48 float prob_threshold_ = 0.01f;
49 float prob_threshold_s1_ = -1.f;
50 float diff_threshold_ = 0.01f;
51 float min_recom_ = 1e-5f;
52 float error_param_ = 0.01f;
53 bool all_typed_sites_ = false;
54 bool update_m3vcf_ = false;
55 bool compress_reference_ = false;
56 bool pass_only_ = false;
57 bool meta_ = false;
58 bool fail_min_ratio_ = true;
59 bool help_ = false;
60 bool version_ = false;
61
62public:
64 bool help_is_set() const { return help_; }
65
67 bool version_is_set() const { return version_; }
68
70 const std::string& ref_path() const { return ref_path_; }
71
73 const std::string& tar_path() const { return tar_path_; }
74
76 const std::string& map_path() const { return map_path_; }
77
79 const std::string& out_path() const { return out_path_; }
80
82 const std::string& emp_out_path() const { return emp_out_path_; }
83
85 const std::string& sites_out_path() const { return sites_out_path_; }
86
88 const std::string& temp_prefix() const { return temp_prefix_; }
89
91 savvy::file::format out_format() const { return out_format_; }
92
94 std::uint8_t out_compression() const { return out_compression_; }
95
97 const std::vector<std::string>& fmt_fields() const { return fmt_fields_; }
98
100 const std::unordered_set<std::string>& sample_ids() const { return sample_ids_; }
101
103 const savvy::genomic_region& region() const { return reg_; }
104
106 std::int64_t chunk_size() const { return chunk_size_; }
107
109 std::int64_t overlap() const { return overlap_; }
110
112 std::int16_t threads() const { return threads_; }
113
115 std::size_t temp_buffer() const { return temp_buffer_ ; }
116
118 std::size_t min_block_size() const { return min_block_size_; }
119
121 std::size_t max_block_size() const { return max_block_size_; }
122
124 std::size_t slope_unit() const { return slope_unit_; }
125
127 float decay() const { return decay_; }
128
130 float min_r2() const { return min_r2_; }
131
133 float min_ratio() const { return min_ratio_; }
134
136 float prob_threshold() const { return prob_threshold_; }
137
139 float prob_threshold_s1() const { return prob_threshold_s1_; }
140
142 float diff_threshold() const { return diff_threshold_; }
143
145 float min_recom() const { return min_recom_; }
146
148 float error_param() const { return error_param_; }
149
151 bool all_typed_sites() const { return all_typed_sites_; }
152
154 bool update_m3vcf() const { return update_m3vcf_; }
155
157 bool compress_reference() const { return compress_reference_; }
158
160 bool pass_only() const { return pass_only_; }
161
163 bool fail_min_ratio() const { return fail_min_ratio_; }
164
222 "Usage: minimac4 [opts ...] <reference.msav> <target.{sav,bcf,vcf.gz}>\n"
223 " minimac4 [opts ...] --update-m3vcf <reference.m3vcf.gz>\n"
224 " minimac4 [opts ...] --compress-reference <reference.{sav,bcf,vcf.gz}>",
225 {
226 {"all-typed-sites", no_argument, 0, 'a', "Include in the output sites that exist only in target VCF"},
227 {"temp-buffer", required_argument, 0, 'b', "Number of samples to impute before writing to temporary files (default: 200)"},
228 {"chunk", required_argument, 0, 'c', "Maximum chunk length in base pairs to impute at once (default: 20000000"},
229 {"empirical-output", required_argument, 0, 'e', "Output path for empirical dosages"},
230 {"help", no_argument, 0, 'h', "Print usage"},
231 {"format", required_argument, 0, 'f', "Comma-separated list of format fields to generate (GT, HDS, DS, GP, or SD; default: HDS)"},
232 {"map", required_argument, 0, 'm', "Genetic map file"},
233 {"output", required_argument, 0, 'o', "Output path (default: /dev/stdout)"},
234 {"output-format", required_argument, 0, 'O', "Default output file format used for ambiguous filenames (bcf, sav, vcf.gz, ubcf, usav, or vcf; default: sav)"},
235 //{"pass-only", no_argument, 0, 'p', "Only imports variants with FILTER column set to PASS"},
236 {"region", required_argument, 0, 'r', "Genomic region to impute"},
237 {"sites", required_argument, 0, 's', "Output path for sites-only file"},
238 {"threads", required_argument, 0, 't', "Number of threads (default: 1)"},
239 {"version", no_argument, 0, 'v', "Print version"},
240 {"overlap", required_argument, 0, 'w', "Size (in base pairs) of overlap before and after impute region to use as input to HMM (default: 3000000)"},
241 {"decay", required_argument, 0, '\x02', "Decay rate for dosages in flanking regions (default: disabled with 0)"},
242 {"min-r2", required_argument, 0, '\x02', "Minimum estimated r-square for output variants"},
243 {"min-ratio", required_argument, 0, '\x02', "Minimum ratio of number of target sites to reference sites (default: 1e-4)"},
244 {"min-ratio-behavior", required_argument, 0, '\x02', "Behavior for when --min-ratio is not met (\"skip\" or \"fail\"; default: fail)"}, // maybe add "warn"
245 {"match-error", required_argument, 0, '\x02', "Error parameter for HMM match probabilities (default: 0.01)"},
246 {"min-recom", required_argument, 0, '\x02', "Minimum recombination probability (default: 1e-5)"},
247 {"prob-threshold", required_argument, 0, '\x02', "Probability threshold used for template selection"},
248 {"prob-threshold-s1", required_argument, 0, '\x02', "Probability threshold used for template selection in original state space"},
249 {"diff-threshold", required_argument, 0, '\x02', "Probability diff threshold used in template selection"},
250 {"sample-ids", required_argument, 0, '\x02', "Comma-separated list of sample IDs to subset from reference panel"},
251 {"sample-ids-file", required_argument, 0, '\x02', "Text file containing sample IDs to subset from reference panel (one ID per line)"},
252 {"temp-prefix", required_argument, 0, '\x02', "Prefix path for temporary output files (default: ${TMPDIR}/m4_)"},
253 {"update-m3vcf", no_argument, 0, '\x01', "Converts M3VCF to MVCF (default output: /dev/stdout)"},
254 {"compress-reference", no_argument, 0, '\x01', "Compresses VCF to MVCF (default output: /dev/stdout)"},
255 {"min-block-size", required_argument, 0, '\x02', "Minimium block size for unique haplotype compression (default: 10)"},
256 {"max-block-size", required_argument, 0, '\x02', "Maximum block size for unique haplotype compression (default: 65535)"},
257 {"slope-unit", required_argument, 0, '\x02', "Parameter for unique haplotype compression heuristic (default: 10)"},
258 // vvvv deprecated vvvv //
259 {"allTypedSites", no_argument, 0, '\x01', nullptr},
260 {"rsid", no_argument, 0, '\x01', nullptr},
261 //{"passOnly", no_argument, 0, '\x01', nullptr},
262 {"meta", no_argument, 0, '\x01', nullptr},
263 {"noPhoneHome", no_argument, 0, '\x01', nullptr},
264 {"referenceEstimates", no_argument, 0, '\x01', nullptr},
265 {"haps", required_argument, 0, '\x02', nullptr},
266 {"refHaps", required_argument, 0, '\x02', nullptr},
267 {"prefix", required_argument, 0, '\x02', nullptr},
268 {"mapFile", required_argument, 0, '\x02', nullptr},
269 {"chr", required_argument, 0, '\x02', nullptr},
270 {"start", required_argument, 0, '\x02', nullptr},
271 {"end", required_argument, 0, '\x02', nullptr},
272 {"window", required_argument, 0, '\x02', nullptr},
273 {"ChunkOverlapMb", required_argument, 0, '\x02', nullptr},
274 {"ChunkLengthMb", required_argument, 0, '\x02', nullptr},
275 {"cpus", required_argument, 0, '\x02', nullptr},
276 {"minRatio", required_argument, 0, '\x02', nullptr}
277 })
278 {
279 }
280
328 bool parse(int argc, char** argv)
329 {
330 int long_index = 0;
331 int opt;
332 while ((opt = getopt_long(argc, argv, short_opt_string_.c_str(), long_options_.data(), &long_index)) != -1)
333 {
334 char copt = char(opt & 0xFF);
335 switch (copt)
336 {
337 case 'a':
338 all_typed_sites_ = true;
339 break;
340 case 'b':
341 temp_buffer_ = std::size_t(std::atoll(optarg ? optarg : ""));
342 break;
343 case 'c':
344 chunk_size_ = std::atoll(optarg ? optarg : "");
345 break;
346 case 'e':
347 emp_out_path_ = optarg ? optarg : "";
348 break;
349 case 'h':
350 help_ = true;
351 return true;
352 case 'f':
353 {
354 fmt_fields_ = split_string_to_vector(optarg ? optarg : "", ',');
355 std::unordered_set<std::string> allowed = {"GT", "GP", "DS", "HDS", "SD"};
356 for (auto it = fmt_fields_.begin(); it != fmt_fields_.end(); ++it)
357 {
358 if (allowed.find(*it) == allowed.end())
359 return std::cerr << "Error: Invalid --format option (" << *it << ")\n", false;
360 }
361 break;
362 }
363 case 'm':
364 map_path_ = optarg ? optarg : "";
365 break;
366 case 'o':
367 out_path_ = optarg ? optarg : "";
368 break;
369 case 'O':
370 {
371 using fmt = savvy::file::format;
372 std::string ot = optarg ? optarg : "";
373 if (ot == "vcf")
374 {
375 out_format_ = fmt::vcf;
376 out_compression_ = 0;
377 }
378 else if (ot == "vcf.gz")
379 {
380 out_format_ = fmt::vcf;
381 }
382 else if (ot == "bcf")
383 {
384 out_format_ = fmt::bcf;
385 }
386 else if (ot == "ubcf")
387 {
388 out_format_ = fmt::bcf;
389 out_compression_ = 0;
390 }
391 else if (ot == "sav")
392 {
393 out_format_ = fmt::sav;
394 }
395 else if (ot == "usav")
396 {
397 out_format_ = fmt::sav;
398 out_compression_ = 0;
399 }
400 else
401 {
402 std::cerr << "Invalid --output-format: " << ot << std::endl;
403 return false;
404 }
405 break;
406 }
407 case 'p':
408 pass_only_ = true;
409 break;
410 case 'r':
411 reg_ = string_to_region(optarg ? optarg : "");
412 break;
413 case 's':
414 sites_out_path_ = optarg ? optarg : "";
415 break;
416 case 't':
417 threads_ = atoi(optarg ? optarg : "");
418 break;
419 case 'v':
420 version_ = true;
421 return true;
422 case 'w':
423 overlap_ = std::atoll(optarg ? optarg : "");
424 break;
425 case '\x01':
426 if (std::string(long_options_[long_index].name) == "update-m3vcf")
427 {
428 update_m3vcf_ = true;
429 break;
430 }
431 else if (std::string(long_options_[long_index].name) == "compress-reference")
432 {
433 compress_reference_ = true;
434 break;
435 }
436 else if (std::string(long_options_[long_index].name) == "allTypedSites")
437 {
438 std::cerr << "Warning: --allTypedSites is deprecated in favor of --all-typed-sites\n";
439 all_typed_sites_ = true;
440 break;
441 }
442 else if (std::string(long_options_[long_index].name) == "rsid")
443 {
444 std::cerr << "Warning: --rsid is deprecated (on by default)\n";
445 break;
446 }
447 else if (std::string(long_options_[long_index].name) == "passOnly")
448 {
449 std::cerr << "Warning: --passOnly is deprecated in favor of --pass-only\n";
450 pass_only_ = true;
451 break;
452 }
453 else if (std::string(long_options_[long_index].name) == "meta")
454 {
455 std::cerr << "Warning: --meta is deprecated in favor of --empirical-output\n";
456 meta_ = true;
457 break;
458 }
459 else if (std::string(long_options_[long_index].name) == "noPhoneHome")
460 {
461 std::cerr << "Warning: --noPhoneHome is deprecated and ignored\n";
462 break;
463 }
464 else if (std::string(long_options_[long_index].name) == "referenceEstimates")
465 {
466 std::cerr << "Warning: --referenceEstimates is deprecated and ignored\n";
467 break;
468 }
469 // else pass through to default
470 case '\x02':
471 {
472 std::string long_opt_str = std::string(long_options_[long_index].name);
473 if (long_opt_str == "decay")
474 {
475 decay_ = std::atof(optarg ? optarg : "");
476 break;
477 }
478 else if (long_opt_str == "min-r2")
479 {
480 min_r2_ = std::atof(optarg ? optarg : "");
481 break;
482 }
483 else if (long_opt_str == "min-ratio")
484 {
485 min_ratio_ = std::min(1., std::max(0., std::atof(optarg ? optarg : "")));
486 break;
487 }
488 else if (long_opt_str == "min-ratio-behavior")
489 {
490 fail_min_ratio_ = std::string(optarg ? optarg : "") == "fail";
491 break;
492 }
493 else if (long_opt_str == "match-error")
494 {
495 error_param_ = std::min(0.5, std::max(0., std::atof(optarg ? optarg : "")));
496 break;
497 }
498 else if (long_opt_str == "min-recom")
499 {
500 min_recom_ = std::min(0.5, std::max(0., std::atof(optarg ? optarg : "")));
501 break;
502 }
503 else if (long_opt_str == "prob-threshold")
504 {
505 prob_threshold_ = std::min(1., std::max(0., std::atof(optarg ? optarg : "")));
506 break;
507 }
508 else if (long_opt_str == "prob-threshold-s1")
509 {
510 prob_threshold_s1_ = std::min(1., std::atof(optarg ? optarg : ""));
511 break;
512 }
513 else if (long_opt_str == "temp-prefix")
514 {
515 temp_prefix_ = optarg ? optarg : "";
516 break;
517 }
518 else if (long_opt_str == "diff-threshold")
519 {
520 diff_threshold_ = std::max(0., std::atof(optarg ? optarg : ""));
521 break;
522 }
523 else if (long_opt_str == "sample-ids")
524 {
525 auto tmp_ids = split_string_to_vector(optarg ? optarg : "", ',');
526 sample_ids_.insert(tmp_ids.begin(), tmp_ids.end());
527 break;
528 }
529 else if (long_opt_str == "sample-ids-file")
530 {
531 std::ifstream ifs(optarg ? optarg : "");
532 sample_ids_.insert(std::istream_iterator<std::string>(ifs), std::istream_iterator<std::string>());
533 break;
534 }
535 else if (long_opt_str == "min-block-size")
536 {
537 min_ratio_ = std::max(1ll, std::atoll(optarg ? optarg : ""));
538 break;
539 }
540 else if (long_opt_str == "max-block-size")
541 {
542 min_ratio_ = std::max(1ll, std::atoll(optarg ? optarg : ""));
543 break;
544 }
545 else if (long_opt_str == "slope-unit")
546 {
547 min_ratio_ = std::max(1ll, std::atoll(optarg ? optarg : ""));
548 break;
549 }
550 else if (long_opt_str == "haps")
551 {
552 std::cerr << "Warning: --haps is deprecated\n";
553 tar_path_ = optarg ? optarg : "";
554 break;
555 }
556 else if (long_opt_str == "refHaps")
557 {
558 std::cerr << "Warning: --refHaps is deprecated\n";
559 ref_path_ = optarg ? optarg : "";
560 break;
561 }
562 else if (long_opt_str == "chr")
563 {
564 std::cerr << "Warning: --chr is deprecated in favor of --region\n";
565 reg_ = savvy::genomic_region(optarg ? optarg : "", reg_.from(), reg_.to());
566 break;
567 }
568 else if (long_opt_str == "start")
569 {
570 std::cerr << "Warning: --start is deprecated in favor of --region\n";
571 reg_ = savvy::genomic_region(reg_.chromosome(), std::atoll(optarg ? optarg : ""), reg_.to());
572 break;
573 }
574 else if (long_opt_str == "end")
575 {
576 std::cerr << "Warning: --end is deprecated in favor of --region\n";
577 reg_ = savvy::genomic_region(reg_.chromosome(), reg_.from(), std::atoll(optarg ? optarg : ""));
578 break;
579 }
580 else if (long_opt_str == "prefix")
581 {
582 std::cerr << "Warning: --prefix is deprecated in favor of --output, --empirical-output, and --sites\n";
583 prefix_ = optarg ? optarg : "";
584 out_format_ = savvy::file::format::vcf; // Default to VCF when --prefix is used in order to be consistent with previous behavior.
585 out_compression_ = 6;
586 break;
587 }
588 else if (long_opt_str == "mapFile")
589 {
590 std::cerr << "Warning: --mapFile is deprecated in favor of --map\n";
591 map_path_ = optarg ? optarg : "";
592 break;
593 }
594 else if (long_opt_str == "window")
595 {
596 std::cerr << "Warning: --window is deprecated in favor of --overlap\n";
597 overlap_ = std::atoll(optarg ? optarg : "");
598 break;
599 }
600 else if (long_opt_str == "ChunkLengthMb")
601 {
602 std::cerr << "Warning: --ChunkLengthMb is deprecated in favor of --chunk\n";
603 chunk_size_ = std::atoll(optarg ? optarg : "") * 1000000;
604 break;
605 }
606 else if (long_opt_str == "ChunkOverlapMb")
607 {
608 std::cerr << "Warning: --ChunkOverlapMb is deprecated in favor of --overlap\n";
609 overlap_ = std::atoll(optarg ? optarg : "") * 1000000;
610 break;
611 }
612 else if (long_opt_str == "cpus")
613 {
614 std::cerr << "Warning: --cpus is deprecated in favor of --threads\n";
615 threads_ = atoi(optarg ? optarg : "");
616 break;
617 }
618 else if (long_opt_str == "minRatio")
619 {
620 std::cerr << "Warning: --minRatio is deprecated in favor of --min-ratio\n";
621 min_ratio_ = std::atof(optarg ? optarg : "");
622 break;
623 }
624 // else pass through to default
625 }
626 default:
627 return false;
628 }
629 }
630
631 int remaining_arg_count = argc - optind;
632
633 if (remaining_arg_count == 2)
634 {
635 ref_path_ = argv[optind];
636 tar_path_ = argv[optind + 1];
637 }
638 else if ((update_m3vcf_ || compress_reference_) && remaining_arg_count == 1)
639 {
640 ref_path_ = argv[optind];
641 }
642 else if (remaining_arg_count < 2)
643 {
644 if (ref_path_.empty() || tar_path_.empty())
645 {
646 std::cerr << "Too few arguments\n";
647 return false;
648 }
649 }
650 else
651 {
652 std::cerr << "Too many arguments\n";
653 return false;
654 }
655
656 if (!prefix_.empty())
657 {
658 std::string suffix = "sav";
659 if (out_format_ == savvy::file::format::bcf)
660 suffix = "bcf";
661 else if (out_format_ == savvy::file::format::vcf)
662 {
663 suffix = "vcf";
664 if (out_compression_)
665 suffix += ".gz";
666 }
667
668 out_path_ = prefix_ + ".dose." + suffix;
669 sites_out_path_ = prefix_ + ".sites." + suffix;
670 if (meta_)
671 emp_out_path_ = prefix_ + ".empiricalDose." + suffix;
672 }
673
674 if (temp_prefix_.empty())
675 {
676 char* tmpdir = std::getenv("TMPDIR");
677 if (tmpdir && strlen(tmpdir))
678 {
679 std::string p(tmpdir);
680 if (p.back() != '/')
681 p += '/';
682 temp_prefix_ = p + "m4_";
683 }
684 else
685 {
686 temp_prefix_ = "/tmp/m4_";
687 }
688 }
689
690 if (!emp_out_path_.empty() && std::find(fmt_fields_.begin(), fmt_fields_.end(), "HDS") == fmt_fields_.end())
691 fmt_fields_.emplace_back("HDS");
692
693 return true;
694 }
695private:
722 savvy::genomic_region string_to_region(const std::string& s)
723 {
724 const std::size_t colon_pos = s.find(':');
725 if (colon_pos == std::string::npos)
726 {
727 return savvy::genomic_region(s);
728 }
729 else
730 {
731 std::string chr = s.substr(0, colon_pos);
732 const std::size_t hyphen_pos = s.find('-', colon_pos + 1);
733 if (hyphen_pos == std::string::npos)
734 {
735 std::string slocus = s.substr(colon_pos + 1);
736 std::uint64_t ilocus = std::uint64_t(std::atoll(slocus.c_str()));
737 return savvy::genomic_region(chr, ilocus, ilocus);
738 }
739 else
740 {
741 std::string sbeg = s.substr(colon_pos + 1, hyphen_pos - chr.size() - 1);
742 std::string send = s.substr(hyphen_pos + 1);
743 if (send.empty())
744 {
745 return savvy::genomic_region(chr, std::uint64_t(std::atoll(sbeg.c_str())));
746 }
747 else
748 {
749 return savvy::genomic_region(chr, std::uint64_t(std::atoll(sbeg.c_str())), std::uint64_t(std::atoll(send.c_str())));
750 }
751 }
752 }
753 }
754
777 std::vector<std::string> split_string_to_vector(const char* in, char delim)
778 {
779 std::vector<std::string> ret;
780 const char* d = nullptr;
781 std::string token;
782 const char* s = in;
783 const char*const e = in + strlen(in);
784 while ((d = std::find(s, e, delim)) != e)
785 {
786 ret.emplace_back(std::string(s, d));
787 s = d ? d + 1 : d;
788 }
789 ret.emplace_back(std::string(s,d));
790 return ret;
791 }
792};
793
794#endif // MINIMAC4_PROG_ARGS_HPP
std::string short_opt_string_
Concatenated short option string.
Definition getopt_wrapper.hpp:116
getopt_wrapper(std::string usage_str, std::vector< option_with_desc > long_opts)
Constructs a getopt_wrapper object for parsing command-line options.
Definition getopt_wrapper.hpp:151
std::vector< option > long_options_
Storage of long options for getopt parsing.
Definition getopt_wrapper.hpp:90
const std::string & out_path() const
Definition prog_args.hpp:79
std::uint8_t out_compression() const
Definition prog_args.hpp:94
savvy::file::format out_format() const
Definition prog_args.hpp:91
bool update_m3vcf() const
Definition prog_args.hpp:154
const std::string & temp_prefix() const
Definition prog_args.hpp:88
std::int16_t threads() const
Definition prog_args.hpp:112
const std::string & emp_out_path() const
Definition prog_args.hpp:82
const std::string & ref_path() const
Definition prog_args.hpp:70
float prob_threshold_s1() const
Definition prog_args.hpp:139
bool help_is_set() const
Definition prog_args.hpp:64
const savvy::genomic_region & region() const
Definition prog_args.hpp:103
bool parse(int argc, char **argv)
Parse command-line arguments for minimac4.
Definition prog_args.hpp:328
const std::string & map_path() const
Definition prog_args.hpp:76
bool pass_only() const
Definition prog_args.hpp:160
float min_r2() const
Definition prog_args.hpp:130
const std::vector< std::string > & fmt_fields() const
Definition prog_args.hpp:97
const std::unordered_set< std::string > & sample_ids() const
Definition prog_args.hpp:100
std::int64_t chunk_size() const
Definition prog_args.hpp:106
bool compress_reference() const
Definition prog_args.hpp:157
std::size_t slope_unit() const
Definition prog_args.hpp:124
float diff_threshold() const
Definition prog_args.hpp:142
float min_recom() const
Definition prog_args.hpp:145
float prob_threshold() const
Definition prog_args.hpp:136
std::size_t max_block_size() const
Definition prog_args.hpp:121
float error_param() const
Definition prog_args.hpp:148
bool version_is_set() const
Definition prog_args.hpp:67
float decay() const
Definition prog_args.hpp:127
std::size_t min_block_size() const
Definition prog_args.hpp:118
const std::string & sites_out_path() const
Definition prog_args.hpp:85
std::int64_t overlap() const
Definition prog_args.hpp:109
bool fail_min_ratio() const
Definition prog_args.hpp:163
const std::string & tar_path() const
Definition prog_args.hpp:73
std::size_t temp_buffer() const
Definition prog_args.hpp:115
float min_ratio() const
Definition prog_args.hpp:133
bool all_typed_sites() const
Definition prog_args.hpp:151
prog_args()
Construct program arguments parser for minimac4.
Definition prog_args.hpp:220