packages/engine/scram/src/settings.h

Builder for settings.
Namespaces

Name
scram
scram::core
Classes

	Name
class	scram::core::Settings <br>Builder for analysis settings.
Source code

cpp
/*
 * Copyright (C) 2014-2018 Olzhas Rakhimov
 * Copyright (C) 2023 OpenPRA ORG Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


#pragma once

#include "model.h"

#include <algorithm>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <stdexcept>

#include <string_view>
#include <string>
#include <vector>

namespace scram::core {

enum class Algorithm : std::uint8_t { kBdd = 0, kZbdd, kMocus };

const char* const kAlgorithmToString[] = { "bdd", "zbdd", "mocus" };

enum class Approximation : std::uint8_t { kNone = 0, kRareEvent, kMcub };

const char* const kApproximationToString[] = { "none", "rare-event", "mcub" };

class Settings {
 public:
  [[nodiscard]] Algorithm algorithm() const { return algorithm_; }

  Settings& algorithm(Algorithm value) ;

  Settings& algorithm(std::string_view value);

  [[nodiscard]] Approximation approximation() const { return approximation_; }

  Settings& approximation(Approximation value);
  Settings& approximation(std::string_view value);

  [[nodiscard]] bool prime_implicants() const { return prime_implicants_; }

  Settings& prime_implicants(bool flag);

  [[nodiscard]] int limit_order() const { return limit_order_; }

  Settings& limit_order(int order);

  [[nodiscard]] double cut_off() const { return cut_off_; }

  Settings& cut_off(double prob);

  [[nodiscard]] int num_quantiles() const { return num_quantiles_; }

  Settings& num_quantiles(int n);

  [[nodiscard]] int num_bins() const { return num_bins_; }

  Settings& num_bins(int n);

  [[nodiscard]] int num_trials() const { return num_trials_; }

  Settings& num_trials(int n);

  [[nodiscard]] int seed() const { return seed_; }

  Settings& seed(int s);

  [[nodiscard]] double mission_time() const { return mission_time_; }

  Settings& mission_time(double time);

  [[nodiscard]] double time_step() const { return time_step_; }

  Settings& time_step(double time);

  [[nodiscard]] bool probability_analysis() const { return probability_analysis_; }

  Settings& probability_analysis(bool flag) {
    if (!importance_analysis_ && !uncertainty_analysis_ &&
        !safety_integrity_levels_) {
      probability_analysis_ = flag;
    }
    return *this;
  }

  Settings& skip_products(bool flag) {
    skip_products_ = flag;
    return *this;
  }

  [[nodiscard]] bool skip_products() const { return skip_products_; }

  [[nodiscard]] bool bit_pack_cut_sets() const { return bit_pack_cut_sets_; }

  Settings& bit_pack_cut_sets(bool flag) {
    bit_pack_cut_sets_ = flag;
    return *this;
  }

  [[nodiscard]] bool requires_products() const {
    if (adaptive_)
      return true;

    // Non-BDD algorithms inherently require cut sets for quantification.
    if (algorithm_ != Algorithm::kBdd)
      return true;

    // For BDD: products are ONLY required when explicitly requested via prime_implicants
    // or when other analyses depend on them.
    if (prime_implicants_ || importance_analysis_ || uncertainty_analysis_)
      return true;

#ifndef NDEBUG
    // Developer debug printing of products requires enumeration.
    if (print)
      return true;
#endif

    // Approximations rely on cut sets.
    if (approximation_ != Approximation::kNone)
      return true;

    // Otherwise, BDD can compute probabilities directly without products.
    return false;
  }

  [[nodiscard]] bool safety_integrity_levels() const { return safety_integrity_levels_; }

  Settings& safety_integrity_levels(bool flag);

  [[nodiscard]] bool importance_analysis() const { return importance_analysis_; }

  Settings& importance_analysis(bool flag) {
    importance_analysis_ = flag;
    if (importance_analysis_)
      probability_analysis_ = true;
    return *this;
  }

  [[nodiscard]] bool uncertainty_analysis() const { return uncertainty_analysis_; }

  Settings& uncertainty_analysis(bool flag) {
    uncertainty_analysis_ = flag;
    if (uncertainty_analysis_)
      probability_analysis_ = true;
    return *this;
  }

  [[nodiscard]] bool ccf_analysis() const { return ccf_analysis_; }

  Settings& ccf_analysis(bool flag) { ccf_analysis_ = flag; return *this; }

  [[nodiscard]] bool adaptive() const { return adaptive_; }

  Settings& adaptive(bool flag) { adaptive_ = flag; return *this; }

  [[nodiscard]] bool expand_atleast_gates() const { return expand_atleast_gates_; }
  [[nodiscard]] bool expand_xor_gates() const { return expand_xor_gates_; }
  [[nodiscard]] bool keep_null_gates() const { return keep_null_gates_; }
  [[nodiscard]] int compilation_level() const { return compilation_level_; }

  Settings& expand_xor_gates(const bool on) { expand_xor_gates_ = on; return *this; }
  Settings& expand_atleast_gates(const bool on) { expand_atleast_gates_ = on; return *this; }
  Settings& keep_null_gates(const bool on) { keep_null_gates_ = on; return *this; }
  Settings& compilation_level(const int level) { compilation_level_ = std::clamp(level, 0, 8); return *this; }

  [[nodiscard]] const std::vector<std::string>& input_files() const { return input_files_; }

  Settings& input_files(const std::vector<std::string>& files) {
    input_files_ = files;
    return *this;
  }

  [[nodiscard]] mef::Model* model() const { return model_; }

  Settings& model(mef::Model *model) {
      model_ = model;
      return *this;
  }

  bool preprocessor = false;  
  bool print = false;  

 private:
  Algorithm algorithm_ = Algorithm::kBdd;                  
  Approximation approximation_ = Approximation::kNone ; 
  bool probability_analysis_ = false;                 
  bool safety_integrity_levels_ = false;              
  bool importance_analysis_ = false;                  
  bool uncertainty_analysis_ = false;                 
  bool ccf_analysis_ = false;                         
  bool prime_implicants_ = false;                     
  bool skip_products_ = false;                        
  bool bit_pack_cut_sets_ = false;                    
  bool adaptive_ = false;                             
  int limit_order_ = 20;                              
  int seed_ = 372;                                    
  int num_trials_ = 1000;                             
  int num_quantiles_ = 20;                            
  int num_bins_ = 20;                                 
  double mission_time_ = 8760;                        
  double time_step_ = 0;                              
  double cut_off_ = 1e-20;                             

  // Graph Compilation Options
  bool keep_null_gates_ = false;
  bool expand_atleast_gates_ = false;
  bool expand_xor_gates_ = false;
  int compilation_level_ = 2;

  // A copy of the final list of MEF input files passed on the command-line.  Read-only access is provided via the getter above.
  std::vector<std::string> input_files_;

  mef::Model* model_ = nullptr;
};

}  // namespace scram::core
Updated on 2026-01-09 at 21:59:13 +0000
packages/engine/scram/src/settings.h ​

Namespaces ​

Classes ​

Source code ​

packages/engine/scram/src/settings.h

Namespaces

Classes

Source code
