Scheduler.cpp

Go to the documentation of this file.

// Scheduler.cpp: implementation of the Scheduler class.
//
 
#include <sstream>
#include "Scheduler.h"
#include "../System/SystemModule.h"
#include "AnalysisInfoContainer.h"
#include "../Branch/BranchRecord.h"
#include "CommandControlCenter.h"
#include <boost/program_options.hpp>
#include <cstdlib>
#include "../Global/ConfigFingerprint.h"
#include <filesystem>
namespace fs = std::filesystem;
#include "VersionConfig.h"
#include <boost/serialization/export.hpp>
#include "../Global/SimulationContext.h"
// #include "..\ADSNetCltDlg.h"
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(Scheduler)
using namespace std;
 
extern std::string notify_ntfy_topic;
extern std::string notify_discord_webhook;
std::string auto_ntfy_topic(); // from Notification.cpp
 
namespace po = boost::program_options;
 
//extern SystemModule plant;
 
// #ifndef _CONSOLE
// extern CString theStrWorkingDir;
// // the following global variables are for network version only
// extern CADSNetCltDlg *theCltDlg;
 
// extern CEvent    g_eventPENode;
// extern CEvent    g_eventESNode;
// extern CEvent    g_eventClusterNode;
 
// #endif
 
inline char separator() {
#if defined _WIN32
  return '//';
#else
  return '/';
#endif
}
 
Scheduler::Scheduler() {
  resetScheduler();
}
 
Scheduler::~Scheduler() {
}
 
void Scheduler::parseOptions(int argc, char* argv[]) {
    // ANSI escape codes for colors
    const std::string RED = "\033[31m";
    const std::string GREEN = "\033[32m";
    const std::string MAGENTA = "\033[35m";
    const std::string UNDERLINE = "\033[4m";
    const std::string RESET = "\033[0m";
 
    string str1;
    const std::string VERSION_STRING = "v" + std::to_string(ADSIDAC_VERSION_MAJOR) + "." + std::to_string(ADSIDAC_VERSION_MINOR) + "." + std::to_string(ADSIDAC_VERSION_PATCH);
 
    po::options_description desc("Allowed options");
    desc.add_options()
            ("help,h", "produce help message")
            ("version,v", "display version information")
            ("info,i", "display detailed information about the application")
            ("project-dir", po::value<std::string>()->required(), "set project directory")
            ("input-deck", po::value<std::string>()->required(), "set input deck file")
            ("solver", po::value<std::string>()->default_value("relap"), "solver backend: relap|0 (default) or mock|1 (REST API mock solver)")
            ("solver-port", po::value<int>()->default_value(9090), "mock solver port (default 9090)")
            ("solver-url", po::value<std::string>()->default_value(""), "override mock solver URL (e.g., http://remote-host:8080)")
            ("no-thermo-cache", po::bool_switch()->default_value(false), "disable thermodynamic table caching (reload from file every sequence)")
            ("no-memory-restart", po::bool_switch()->default_value(false), "disable in-memory restart (use file-based restart)")
            ("memory-limit", po::value<long>()->default_value(0), "RSS limit in MB for adaptive restart (0=unlimited)")
            ("compress-queue", po::bool_switch()->default_value(false), "LZ4-compress restart buffers on MPI server queue")
            ("aggregate-pe", po::bool_switch()->default_value(false), "write PE nodes as records in a single file per rank instead of one file each (default off: changes output layout)")
            ("viz-port", po::value<int>()->default_value(0), "Port for real-time DET visualization web server (MPI only, 0=disabled)")
            ("viz-outputs", po::value<std::string>()->default_value(""), "Output types streamed to viz server: events,es,all (requires --viz-port)")
            ("notify-ntfy", po::value<std::string>()->implicit_value("auto"), "Send ntfy.sh notification (auto-generates topic from hostname, or specify topic)")
            ("notify-discord", po::value<std::string>(), "Send completion notification to Discord webhook URL")
            ("checkpoint-dir", po::value<std::string>()->default_value(""), "directory for DET checkpoint files")
            ("checkpoint-interval", po::value<int>()->default_value(0), "checkpoint every N sequences (0=disabled)")
            ("checkpoint-stop", po::bool_switch()->default_value(false), "exit after writing checkpoint (for testing)")
            ("resume", po::value<std::string>()->default_value(""), "resume simulation from checkpoint file")
            ("truncation-time", po::value<double>()->default_value(0), "override truncation time from ZCtrlPar.txt (0=use file value)")
            ("occupancy-log", po::value<std::string>()->default_value(""), "MPI only: append server queue depth and busy-worker count to a CSV on every change (empty=disabled)")
            ("merge", po::value<std::string>()->default_value("now"), "MPI output merge mode: now (default, rename-based worker-parallel), serial (legacy rank-0 copy loop), or defer (end at tree completion, consolidate later with --merge-only)")
            ("merge-only", po::bool_switch()->default_value(false), "consolidate the per-rank outputs of a deferred (or interrupted) merge into Output/ and exit; run without mpirun")
            ("merge-threads", po::value<int>()->default_value(0), "thread pool size for --merge-only rank-directory moves (0 = min(8, hardware))")
            ("enable-rm-cycle", po::bool_switch()->default_value(false), "enable ReasonMachine snapshot/restore/serialize machinery (dormant cycle; see docs)");
 
    // Create a variables map
    po::variables_map vm;
    try {
        po::store(po::parse_command_line(argc, argv, desc), vm);
 
        if (vm.count("help")) {
            std::cout << desc << "\n";
            exit(0);
        }
 
        if (vm.count("version")) {
            std::cout << VERSION_STRING << std::endl;
            exit(0);
        }
 
        if (vm.count("info")) {
            std::cout << "ADS-IDAC\n" << std::endl;
            std::cout << "Accident Dynamics Simulator paired with the Information, Decision, and Action in a Crew" << std::endl;
            std::cout << VERSION_STRING << std::endl;
            std::cout << "Maintained by: Probabilistic Risk Assessment Group of NC State Nuclear Engineering" << std::endl;
            std::cout << "https://www.ne.ncsu.edu/prag/" << std::endl;
            exit(0);
        }
 
        // Read options from file, if exists
        std::ifstream ifs("ZiniADS.txt");
        if (ifs) {
            po::store(po::parse_config_file(ifs, desc), vm);
        }
 
        po::notify(vm);
    } catch (const po::error &e) {
        std::cerr << RED <<"ERROR: " << RESET << e.what() << RESET << std::endl;
        std::cerr << "Check " << GREEN << "./adsidac --help" << RESET <<std::endl;
        exit(1);
    }
 
    // Update class members with parsed values (resolve to absolute paths for MPI rank cd)
    project_directory = fs::absolute(vm["project-dir"].as<std::string>()).string();
    input_deck_file_directory_and_name = fs::absolute(vm["input-deck"].as<std::string>()).string();
 
    // Solver selection: --solver=relap|0|mock|1, --solver-port, --solver-url
    std::string solver_arg = vm["solver"].as<std::string>();
    solver_port_ = vm["solver-port"].as<int>();
    std::string explicit_url = vm["solver-url"].as<std::string>();
    if (solver_arg == "relap" || solver_arg == "0") {
        if (!explicit_url.empty()) {
            std::cerr << "ERROR: --solver-url cannot be used with --solver=relap\n";
            exit(1);
        }
        // solver_url stays empty → RelapSolver
    } else if (solver_arg == "mock" || solver_arg == "1") {
        if (!explicit_url.empty()) {
            g_sim.config.solver_url = explicit_url;
        } else {
            g_sim.config.solver_url = "http://localhost:" + std::to_string(solver_port_);
        }
    } else if (!explicit_url.empty()) {
        // Any other --solver value given together with --solver-url: the URL
        // selects the REST solver. (A bare --solver-url does not reach this
        // branch, because --solver defaults to "relap" and is rejected above.)
        g_sim.config.solver_url = explicit_url;
    } else {
        std::cerr << "ERROR: unknown solver '" << solver_arg << "'. Use relap|0 or mock|1\n";
        exit(1);
    }
 
    if (vm["no-thermo-cache"].as<bool>()) g_sim.config.thermo_cache_mode = 2;
    g_sim.config.memory_restart = !vm["no-memory-restart"].as<bool>();
    g_sim.config.memory_limit_mb = vm["memory-limit"].as<long>();
    if (!g_sim.config.memory_restart && g_sim.config.memory_limit_mb > 0 && !vm["memory-limit"].defaulted()) {
        std::cerr << "ERROR: --no-memory-restart and --memory-limit are mutually exclusive\n";
        exit(1);
    }
    if (g_sim.config.memory_restart) {
        // Use /dev/shm on Linux (tmpfs, zero disk I/O), fall back to /tmp elsewhere (macOS)
        if (fs::exists("/dev/shm"))
            g_sim.config.shm_prefix = "/dev/shm/adsidac_" + std::to_string(getpid()) + "_";
        else
            g_sim.config.shm_prefix = fs::temp_directory_path().string() + "/adsidac_" + std::to_string(getpid()) + "_";
        if (g_sim.config.memory_limit_mb > 0)
            std::cout << "Adaptive restart: memory when RSS < " << g_sim.config.memory_limit_mb << "MB, file otherwise" << std::endl;
    }
    g_sim.config.compress_queue = vm["compress-queue"].as<bool>();
    g_sim.config.aggregate_pe_output = vm["aggregate-pe"].as<bool>();
    g_sim.config.rm_cycle_enabled = vm["enable-rm-cycle"].as<bool>();
    viz_port_ = vm["viz-port"].as<int>();
    {
        std::string vo = vm["viz-outputs"].as<std::string>();
        if (!vo.empty()) {
            if (viz_port_ == 0) {
                std::cerr << "ERROR: --viz-outputs requires --viz-port to be set\n";
                exit(1);
            }
            std::istringstream iss(vo);
            std::string tok;
            while (std::getline(iss, tok, ',')) {
                if (tok == "all") { g_sim.config.viz_output_events = true; g_sim.config.viz_output_end_states = true; }
                else if (tok == "events") g_sim.config.viz_output_events = true;
                else if (tok == "es") g_sim.config.viz_output_end_states = true;
                else { std::cerr << "ERROR: unknown viz output type '" << tok << "'\n"; exit(1); }
            }
            std::cout << "Viz outputs:";
            if (g_sim.config.viz_output_events) std::cout << " events";
            if (g_sim.config.viz_output_end_states) std::cout << " end-states";
            std::cout << std::endl;
        }
    }
    if (vm.count("notify-ntfy")) {
        notify_ntfy_topic = vm["notify-ntfy"].as<std::string>();
        if (notify_ntfy_topic == "auto")
            notify_ntfy_topic = auto_ntfy_topic();
        std::cout << "Notifications: ntfy.sh/" << notify_ntfy_topic << std::endl;
    }
    if (vm.count("notify-discord"))
        notify_discord_webhook = vm["notify-discord"].as<std::string>();
 
    g_sim.config.checkpoint_dir = vm["checkpoint-dir"].as<std::string>();
    g_sim.config.checkpoint_interval = vm["checkpoint-interval"].as<int>();
    g_sim.config.checkpoint_stop = vm["checkpoint-stop"].as<bool>();
    g_sim.config.resume_file = vm["resume"].as<std::string>();
    // MPI ranks chdir into rank_N/ after option parsing, and the server loads
    // --resume after that chdir, so a relative path kept here would resolve
    // against the wrong directory. Both paths are made absolute against the
    // launch directory now.
    if (!g_sim.config.checkpoint_dir.empty())
        g_sim.config.checkpoint_dir = fs::absolute(g_sim.config.checkpoint_dir).string();
    if (!g_sim.config.resume_file.empty())
        g_sim.config.resume_file = fs::absolute(g_sim.config.resume_file).string();
    if (g_sim.config.checkpoint_interval > 0 && g_sim.config.checkpoint_dir.empty()) {
        std::cerr << "ERROR: --checkpoint-interval requires --checkpoint-dir\n";
        exit(1);
    }
    if (g_sim.config.checkpoint_stop && g_sim.config.checkpoint_interval == 0) {
        std::cerr << "ERROR: --checkpoint-stop requires --checkpoint-interval\n";
        exit(1);
    }
    if (!g_sim.config.checkpoint_dir.empty()) {
        fs::create_directories(g_sim.config.checkpoint_dir);
        std::cout << "Checkpoint: dir=" << g_sim.config.checkpoint_dir
                  << " interval=" << g_sim.config.checkpoint_interval
                  << (g_sim.config.checkpoint_stop ? " (stop after checkpoint)" : "") << std::endl;
    }
    if (!g_sim.config.resume_file.empty())
        std::cout << "Resuming from: " << g_sim.config.resume_file << std::endl;
    g_sim.config.truncation_time_override = vm["truncation-time"].as<double>();
    g_sim.config.occupancy_log = vm["occupancy-log"].as<std::string>();
    {
        const std::string mm = vm["merge"].as<std::string>();
        if (mm == "now") g_sim.config.merge_mode = 0;
        else if (mm == "serial") g_sim.config.merge_mode = 1;
        else if (mm == "defer") g_sim.config.merge_mode = 2;
        else {
            std::cerr << "ERROR: unknown merge mode '" << mm << "'. Use now, serial, or defer\n";
            exit(1);
        }
        g_sim.config.merge_only = vm["merge-only"].as<bool>();
        g_sim.config.merge_threads = vm["merge-threads"].as<int>();
        if (g_sim.config.merge_only
            && (!g_sim.config.resume_file.empty() || g_sim.config.checkpoint_interval > 0)) {
            std::cerr << "ERROR: --merge-only does not run a simulation; it cannot be combined "
                         "with --resume or checkpointing\n";
            exit(1);
        }
        // A deferred, unmerged Output/ means the rank dirs are the only complete
        // copy of the finished run; a resume would wipe them (Setup_Directories).
        if (!g_sim.config.resume_file.empty()
            && fs::exists(fs::path(project_directory) / "Output" / "MERGE_PENDING.txt")) {
            std::cerr << "ERROR: this project has a deferred, unmerged run "
                         "(Output/MERGE_PENDING.txt). Run --merge-only first; resuming now "
                         "would delete the rank directories that hold its outputs\n";
            exit(1);
        }
    }
 
    // Startup banner printed once from main (serial) or server (MPI)
 
 
    // Derive the output and input sub-directories from the project directory
    str1 = "/Output/";
    output_directory = project_directory;
    output_directory += str1;
//
    str1 = "/Output/ES/";
    es_directory = project_directory;
    es_directory += str1;
//
    str1 = "/Output/PE/";
    pe_directory = project_directory;
    pe_directory += str1;
//
    str1 = "/Output/KPS/";
    kps_directory = project_directory;
    kps_directory += str1;
//
    str1 = "/Input/Crew/Procedures/";
    eop_directory = project_directory;
    eop_directory += str1;
//
    str1 = "/Input/Crew/DecisionMaker/";
    ODM_directory = project_directory;
    ODM_directory += str1;
//
    str1 = "/Input/Crew/ActionTaker/";
    OAT_directory = project_directory;
    OAT_directory += str1;
//
    str1 = "/Input/Crew/Consultant/";
    OCT_directory = project_directory;
    OCT_directory += str1;
//
    str1 = "/Input/HardwareReliability/";
    hardware_reliability_directory = project_directory;
    hardware_reliability_directory += str1;
//
    str1 = "/Input/Indicators/";
    indicators_directory = project_directory;
    indicators_directory += str1;
//
    str1 = "/Input/Scheduler/";
    scheduler_directory = project_directory;
    scheduler_directory += str1;
//
    str1 = "/Input/System/";
    system_directory = project_directory;
    system_directory += str1;
//
    str1 = "/Input/SupportSystemsReliability/";
    support_systems_directory = project_directory;
    support_systems_directory += str1;
//
    if ((m_iMode == ConsoleMode::Console) || (m_iMode == ConsoleMode::NetServer)) {
        str1 = scheduler_directory;
        str1 += "ZCtrlPar.txt";
        ifstream fin1(str1.c_str(), ios::in);
        if (!fin1.is_open()) {
            cout << "File: " << str1 << " cound not be found" << endl;
            ofstream fout2("err messages.txt", ios::app);
            fout2 << r5pars_.timesno << "  File: " << str1
                  << " cound not be found\n";
            fout2.close();
            r5pars_.terminateall = true;
            return;
        } else {
            fin1 >> str1 >> str1 >> sequence_truncation_probabiliy >> str1
                 >> sequence_truncation_time;
            if (fin1.fail()) {
                // A failed extraction leaves 0.0 in both values, and a
                // truncation time of 0 would terminate every sequence at once
                // while still producing a plausible-looking DET, so a parse
                // failure is fatal.
                std::cout << "FATAL: malformed ZCtrlPar.txt — could not parse "
                          << "Truncation_probability / Truncation_time." << std::endl;
                std::exit(1);
            }
            fin1.close();
        }
    }
    // CLI override takes precedence over ZCtrlPar.txt
    if (g_sim.config.truncation_time_override > 0)
        sequence_truncation_time = g_sim.config.truncation_time_override;
}
 
 
void Scheduler::initiationForSimulation(ConsoleMode iMode) {
  m_iMode = iMode;
  r5pars_.tsimmode = static_cast<int>(iMode);
  string es_directory, str, str1, str2;
  //initiate fcctrl
  r5pars_.cnewrst = true;
  r5pars_.cgennode = false;
  r5pars_.csnostop = 0;
  r5pars_.dopltwrt = false;
//  R5PAR_mp_PAR_INIED = false;
  r5pars_.cnumsno = 0;
  r5pars_.timesno = -2.0;
 
  //The following file names need to be modified After GUI is integrated
  strcpy(r5pars_.carg1, "-i");
  strcpy(r5pars_.carg3, "-o");
  strcpy(r5pars_.carg5, "-r");
  if (iMode == ConsoleMode::Console) {
      // TODO Use individual folders for separete executions
    // Console version mode
//      strcpy(r5pars_.carg0, "relap5g");
    int alp = 1;
    while (!alp) {
      sleep(5);
    }
    strcpy(r5pars_.carg0, "relap5");
    strcpy(r5pars_.carg4, "out.o");
    // RELAP5's internal filename buffers are 80 characters and the carg arrays
    // are char[100]. A longer path would be truncated by RELAP5 or overflow
    // the shared struct, so paths above 80 characters are rejected here.
    constexpr size_t kMaxRelapPath = 80;
    if (g_sim.config.memory_restart) {
        std::string shm_restart = g_sim.config.shm_prefix + "restart.r";
        if (shm_restart.size() > kMaxRelapPath) {
            std::cout << "FATAL: restart path exceeds RELAP5's " << kMaxRelapPath
                      << "-character filename limit: " << shm_restart << std::endl;
            std::exit(1);
        }
        strcpy(r5pars_.carg6, shm_restart.c_str());
    } else {
        strcpy(r5pars_.carg6, "restart.r");
    }
    if (input_deck_file_directory_and_name.size() > kMaxRelapPath) {
        std::cout << "FATAL: input deck path is " << input_deck_file_directory_and_name.size()
                  << " characters, exceeding RELAP5's " << kMaxRelapPath
                  << "-character filename limit:\n       " << input_deck_file_directory_and_name
                  << "\n       Run from a shorter directory or pass a shorter relative path."
                  << std::endl;
        std::exit(1);
    }
    {
        std::ifstream deck_test(input_deck_file_directory_and_name);
        if (!deck_test.good()) {
            std::cout << "FATAL: input deck not found or unreadable: "
                      << input_deck_file_directory_and_name << std::endl;
            std::exit(1);
        }
    }
    strcpy(r5pars_.carg2, input_deck_file_directory_and_name.c_str());
  }
  //set file name length for FORTRAN use
  r5pars_.carg0len = (int) strlen(r5pars_.carg0);
  r5pars_.carg1len = (int) strlen(r5pars_.carg1);
  r5pars_.carg2len = (int) strlen(r5pars_.carg2);
  r5pars_.carg3len = (int) strlen(r5pars_.carg3);
  r5pars_.carg4len = (int) strlen(r5pars_.carg4);
  r5pars_.carg5len = (int) strlen(r5pars_.carg5);
  r5pars_.carg6len = (int) strlen(r5pars_.carg6);
  //
  // r5pars_.si_unit sets units for ADS-IDAC - True is SI, False is British
  r5pars_.si_unit = false;
  //
  r5pars_.sim_err = false;
  r5pars_.dopltwrt = false;
  r5pars_.only_once = false;
//  
//
  es_directory = this->getESDirectory();
  str = es_directory;
  str1 = es_directory;
  str2 = es_directory;
  str += "Scenario info.txt";
  str1 += "Procedure data.txt";
  str2 += "Scan data.txt";
  remove(str.c_str());
  remove(str1.c_str());
  remove(str2.c_str());
  remove("out.o");
  remove("restart.r");
  if (r5pars_.tsimmode == static_cast<int>(ConsoleMode::NetServer) || r5pars_.tsimmode == static_cast<int>(ConsoleMode::Console)) {
    remove("err messages.txt");
  }
  remove("dbg info.txt");
  remove("Scenario info.txt");
  remove("Procedure data.txt");
  // Digest the immutable configuration inputs. Checkpoints store this digest
  // and a resume refuses on mismatch: snapshots carry execution state only
  // and a resume reconstructs the configuration from these files, so they
  // must be the ones the checkpoint was written against. The printed line
  // also records which configuration produced the run.
  g_sim.config_fingerprint = adsidac::compute_config_fingerprint(
      this->getProjectDirectory(), input_deck_file_directory_and_name);
  std::cout << "[CONFIG] fingerprint=0x" << std::hex
            << g_sim.config_fingerprint << std::dec << std::endl;
}
void Scheduler::endSimulation() {
}
void Scheduler::readInfoFromFile(ConsoleMode iMode) {
  m_iMode = iMode;
  string str1;
  string str;
  project_directory = "";
  input_deck_file_directory_and_name = "";
  char ch;
  if ((m_iMode == ConsoleMode::Console) || (m_iMode == ConsoleMode::NetServer)) {
    // console mode or network server mode
    str1 = "ZiniADS.txt";
    ifstream fin(str1.c_str(), ios::in);
    if (!fin.is_open()) {
      cout << "File ZiniADS.txt cound not be found" << endl;
      ofstream fout("err messages.txt", ios::app);
      fout << r5pars_.timesno
           << "  File ZIniADS.txt cound not be found\n";
      fout.close();
      r5pars_.terminateall = true;
      return;
    } else {
      do { 
        ch = fin.get();
      } while (ch != '\n');
      do {
        ch = fin.get();
        if (ch != '\n')
          project_directory += ch;
      } while (ch != '\n');
      // Startup banner printed by caller (main or Server), not here
      do { 
        ch = fin.get();
      } while (ch != '\n');
      do {
        ch = fin.get();
        if (ch != '\n')
          input_deck_file_directory_and_name += ch;
      } while (ch != '\n');
      fin.close();
    }
  } else {
    // Network client mode
// #ifndef _CONSOLE
//      project_directory = theStrWorkingDir;
//      project_directory += "//ClientRun";
//      input_deck_file_directory_and_name = theStrWorkingDir;
//      input_deck_file_directory_and_name += "//ClientRun//indeck.i";
// #endif
  }
  str1 = "/Output/";
  output_directory = project_directory;
  output_directory += str1;
//
  str1 = "/Output/ES/";
  es_directory = project_directory;
  es_directory += str1;
//
  str1 = "/Output/PE/";
  pe_directory = project_directory;
  pe_directory += str1;
//
  str1 = "/Output/KPS/";
  kps_directory = project_directory;
  kps_directory += str1;
//  
  str1 = "/Input/Crew/Procedures/";
  eop_directory = project_directory;
  eop_directory += str1;
//
  str1 = "/Input/Crew/DecisionMaker/";
  ODM_directory = project_directory;
  ODM_directory += str1;
//  
  str1 = "/Input/Crew/ActionTaker/";
  OAT_directory = project_directory;
  OAT_directory += str1;
//  
  str1 = "/Input/Crew/Consultant/";
  OCT_directory = project_directory;
  OCT_directory += str1;
//  
  str1 = "/Input/HardwareReliability/";
  hardware_reliability_directory = project_directory;
  hardware_reliability_directory += str1;
//
  str1 = "/Input/Indicators/";
  indicators_directory = project_directory;
  indicators_directory += str1;
//
  str1 = "/Input/Scheduler/";
  scheduler_directory = project_directory;
  scheduler_directory += str1;
//
  str1 = "/Input/System/";
  system_directory = project_directory;
  system_directory += str1;
//
  str1 = "/Input/SupportSystemsReliability/";
  support_systems_directory = project_directory;
  support_systems_directory += str1;
//
  if ((m_iMode == ConsoleMode::Console) || (m_iMode == ConsoleMode::NetServer)) {
    str1 = scheduler_directory;
    str1 += "ZCtrlPar.txt";
    ifstream fin1(str1.c_str(), ios::in);
    if (!fin1.is_open()) {
      cout << "File: " << str1 << " cound not be found" << endl;
      ofstream fout2("err messages.txt", ios::app);
      fout2 << r5pars_.timesno << "  File: " << str1
            << " cound not be found\n";
      fout2.close();
      r5pars_.terminateall = true;
      return;
    } else {
      fin1 >> str1 >> str1 >> sequence_truncation_probabiliy >> str1
           >> sequence_truncation_time;
      if (fin1.fail()) {
        std::cout << "FATAL: malformed ZCtrlPar.txt — could not parse "
                  << "Truncation_probability / Truncation_time." << std::endl;
        std::exit(1);
      }
      fin1.close();
    }
  }
}
string Scheduler::getProjectDirectory() {
  return project_directory;
}
string Scheduler::getOutputDirectory() {
  return output_directory;
}
string Scheduler::getESDirectory() {
  return es_directory;
}
string Scheduler::getPEDirectory() {
  return pe_directory;
}
string Scheduler::getKPSDirectory() {
  return kps_directory;
}
string Scheduler::getInputDeckFileDirectoryAndName() {
  return input_deck_file_directory_and_name;
}
int Scheduler::getSolverPort() const {
  return solver_port_;
}
string Scheduler::getEOPDirectory() {
  return eop_directory;
}
string Scheduler::getODMDirectory() {
  return ODM_directory;
}
string Scheduler::getOATDirectory() {
  return OAT_directory;
}
string Scheduler::getOCTDirectory() {
  return OCT_directory;
}
string Scheduler::getHardwareReliabilityDirectory() {
  return hardware_reliability_directory;
}
string Scheduler::getIndicatorsDirectory() {
  return indicators_directory;
}
string Scheduler::getSchedulerDirectory() {
  return scheduler_directory;
}
string Scheduler::getSystemDirectory() {
  return system_directory;
}
string Scheduler::getSupportSystemsDirectory() {
  return support_systems_directory;
}
double Scheduler::getSequenceTruncationProbability() {
  return sequence_truncation_probabiliy;
}
double Scheduler::getSequenceTruncationTime() {
  return sequence_truncation_time;
}
void Scheduler::setProjectDirectory(string str) {
  project_directory = str;
}
void Scheduler::setOutputDirectory(string str) {
  output_directory = str;
}
void Scheduler::setESDirectory(string str) {
  es_directory = str;
}
void Scheduler::setPEDirectory(string str) {
  pe_directory = str;
}
void Scheduler::setKPSDirectory(string str) {
  kps_directory = str;
}
void Scheduler::setInputDeckFileDirectoryAndName(string str) {
  input_deck_file_directory_and_name = str;
}
void Scheduler::setEOPDirectory(string str) {
  eop_directory = str;
}
void Scheduler::setODMDirectory(string str) {
  ODM_directory = str;
}
void Scheduler::setOATDirectory(string str) {
  OAT_directory = str;
}
void Scheduler::setOCTDirectory(string str) {
  OCT_directory = str;
}
void Scheduler::setHardwareReliabilityDirectory(string str) {
  hardware_reliability_directory = str;
}
void Scheduler::setIndicatorsDirectory(string str) {
  indicators_directory = str;
}
void Scheduler::setSchedulerDirectory(string str) {
  scheduler_directory = str;
}
void Scheduler::setSystemDirectory(string str) {
  system_directory = str;
}
void Scheduler::setSupportSystemsDirectory(string str) {
  support_systems_directory = str;
}
bool Scheduler::checkForTerminatingCurrentSequence() {
  bool terminate_current_sequence = false;
  int branch_number;
  BranchEndState *es_pt;
  string str;
  vector<BranchEndState *>::reverse_iterator es_ritr;
  //
  //
  if (r5pars_.csnostop != 0) {
    terminate_current_sequence = true;
    g_sim.expected_abort = true;
  }
    //
  else if (g_sim.Branch_center.getRecentUnconditionalBranchProbability()
      < sequence_truncation_probabiliy) {
    es_pt = new BranchEndState();
    str = "Sequence probability reached truncation value: ";
    es_pt->setConsequenceDescription(str);
    es_pt->setTypeOfConsequence(Consequence::ProbTruncated);
    g_sim.Branch_center.addAnEndState(es_pt);
    std::ostringstream streamObj;
    streamObj << g_sim.Branch_center.getRecentUnconditionalBranchProbability();
    str += streamObj.str();
    branch_number = g_sim.Branch_center.getIDOfMotherBranch();
    //branch_number = Branch_center.getIDOfRecentGeneratedBranch();
    //
    g_sim.Command_handler.displayInformation(str);
    g_sim.Aux_info.addRecord(str, branch_number);
    //
    terminate_current_sequence = true;
    g_sim.expected_abort = true;
    //
    r5pars_.csnostop = 4;
    //
  } else if (r5pars_.timesno > sequence_truncation_time) {
    es_pt = new BranchEndState();
    es_pt->setTypeOfConsequence(Consequence::TimeTruncated);
    str = "Sequence reached simulation truncation time";
    es_pt->setConsequenceDescription(str);
    g_sim.Branch_center.addAnEndState(es_pt);
    terminate_current_sequence = true;
    //
    branch_number = g_sim.Branch_center.getIDOfMotherBranch();
    //branch_number = Branch_center.getIDOfRecentGeneratedBranch();
    g_sim.Command_handler.displayInformation(str);
    g_sim.Aux_info.addRecord(str, branch_number);
    //
    g_sim.expected_abort = true;
    r5pars_.csnostop = 4;
  } else if (sequence_terminated_by_alarm) {
    es_pt = new BranchEndState();
    es_pt->setTypeOfConsequence(Consequence::EndseqAlarm);
    es_pt->setConsequenceDescription(info_of_sequence_terminated_by_alarm);
    g_sim.Branch_center.addAnEndState(es_pt);
    //
    branch_number = g_sim.Branch_center.getIDOfMotherBranch();
    //branch_number = Branch_center.getIDOfRecentGeneratedBranch();
    g_sim.Command_handler.displayInformation(
        info_of_sequence_terminated_by_alarm);
    g_sim.Aux_info.addRecord(info_of_sequence_terminated_by_alarm, branch_number);
    //
    terminate_current_sequence = true;
    sequence_terminated_by_alarm = false;
    g_sim.expected_abort = true;
    r5pars_.csnostop = 5;
  } else if (sequence_terminated_by_non_response_action) {
    es_pt = new BranchEndState();
    es_pt->setTypeOfConsequence(Consequence::NonResponseAction);
    es_pt->setConsequenceDescription(
        info_sequence_terminated_by_non_response_action);
    g_sim.Branch_center.addAnEndState(es_pt);
    //
    branch_number = g_sim.Branch_center.getIDOfMotherBranch();
    //branch_number = Branch_center.getIDOfRecentGeneratedBranch();
    g_sim.Command_handler.displayInformation(
        info_sequence_terminated_by_non_response_action);
    g_sim.Aux_info.addRecord(info_sequence_terminated_by_non_response_action,
                       branch_number);
    //
    terminate_current_sequence = true;
    sequence_terminated_by_non_response_action = false;
    g_sim.expected_abort = true;
    r5pars_.csnostop = 5;
  } else if (r5pars_.sim_err) {
    es_pt = new BranchEndState();
    es_pt->setTypeOfConsequence(g_sim.Branch_center.getTempTypeOfConsequence());
    es_pt->setConsequenceDescription(g_sim.Branch_center.getTempESMessage());
    g_sim.Branch_center.addAnEndState(es_pt);
    terminate_current_sequence = true;
    g_sim.expected_abort = true;
    r5pars_.csnostop = 6;
  } else {
  }
  return terminate_current_sequence;
}
void Scheduler::setODMActionTimeMultiplier(double x) {
  ODM_action_time_multiplier = x;
}
double Scheduler::getODMActionTimeMultiplier() {
  return ODM_action_time_multiplier;
}
void Scheduler::setOATActionTimeMultiplier(double x) {
  OAT_action_time_multiplier = x;
}
double Scheduler::getOATActionTimeMultiplier() {
  return OAT_action_time_multiplier;
}
void Scheduler::setOCTActionTimeMultiplier(double x) {
  OCT_action_time_multiplier = x;
}
double Scheduler::getOCTActionTimeMultiplier() {
  return OCT_action_time_multiplier;
}
 
void Scheduler::setSequenceTerminatedByAlarm(bool bg) {
  sequence_terminated_by_alarm = bg;
}
bool Scheduler::getSequenceTerminatedByAlarm() {
  return sequence_terminated_by_alarm;
}
void Scheduler::setSequenceTerminatedByNonResponseAction(bool bg) {
  sequence_terminated_by_non_response_action = bg;
}
bool Scheduler::getSequenceTerminatedByNonResponseAction() {
  return sequence_terminated_by_non_response_action;
}
 
void Scheduler::setInfoOfSequenceTerminatedByAlarm(string str) {
  info_of_sequence_terminated_by_alarm = str;
}
string Scheduler::getInfoOfSequenceTerminatedByAlarm() {
  return info_of_sequence_terminated_by_alarm;
}
void Scheduler::setInfoSequenceTerminatedByNonResponseAction(string str) {
  info_sequence_terminated_by_non_response_action = str;
}
string Scheduler::getInfoSequenceTerminatedByNonResponseAction() {
  return info_sequence_terminated_by_non_response_action;
}
 
void Scheduler::saveSchedulerToFile(ofstream &fout) {
  int i_sequence_terminated_by_alarm = 0;
  int i_sequence_terminated_by_non_response_action = 0;
  if (sequence_terminated_by_alarm)
    i_sequence_terminated_by_alarm = 1;
  if (sequence_terminated_by_non_response_action)
    i_sequence_terminated_by_non_response_action = 1;
  fout << "Scheduler\n" << project_directory << '\n' << output_directory
       << '\n' << es_directory << '\n' << pe_directory << '\n'
       << kps_directory << '\n' << input_deck_file_directory_and_name
       << '\n' << eop_directory << '\n' << ODM_directory << '\n'
       << OAT_directory << '\n' << OCT_directory << '\n'
       << hardware_reliability_directory << '\n' << indicators_directory
       << '\n' << scheduler_directory << '\n' << system_directory << '\n'
       << support_systems_directory << '\n'
       << sequence_truncation_probabiliy << ' ' << sequence_truncation_time
       << '\n' << OAT_action_time_multiplier << ' '
       << ODM_action_time_multiplier << ' ' << OCT_action_time_multiplier
       << '\n' << info_of_sequence_terminated_by_alarm << ' '
       << i_sequence_terminated_by_alarm << ' '
       << info_sequence_terminated_by_non_response_action << ' '
       << i_sequence_terminated_by_non_response_action << ' '
       << file_name_NodeMultiProcessor << '\n' << file_name_indeck << '\n'
       << file_name_restart << '\n' << file_name_ES << '\n' << static_cast<int>(m_iMode)
       << '\n';
}
void Scheduler::retrieveSchedulerFromFile(ifstream &fin) {
  int i_sequence_terminated_by_alarm = 0;
  int i_sequence_terminated_by_non_response_action = 0;
  string str;
 
  fin >> str;
  if (str != "Scheduler") {
    ofstream fout("err messages.txt", ios::app);
    cout
        << "Scheduler::retrieveSchedulerFromFile File retrieval error in previous function"
        << endl;
    fout << r5pars_.timesno
         << "  Scheduler::retrieveSchedulerFromFile retrieval error in previous function\n";
    fout.close();
    r5pars_.sim_err = true;
    g_sim.Branch_center.setTempESMessage(
        "Scheduler::retrieveSchedulerFromFile Prior error");
    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    return;
  }
 
  fin >> project_directory >> output_directory >> es_directory >> pe_directory
      >> kps_directory >> input_deck_file_directory_and_name
      >> eop_directory >> ODM_directory >> OAT_directory >> OCT_directory
      >> hardware_reliability_directory >> indicators_directory
      >> scheduler_directory >> system_directory
      >> support_systems_directory
      >> sequence_truncation_probabiliy >> sequence_truncation_time
      >> OAT_action_time_multiplier >> ODM_action_time_multiplier
      >> OCT_action_time_multiplier
      >> info_of_sequence_terminated_by_alarm
      >> i_sequence_terminated_by_alarm
      >> info_sequence_terminated_by_non_response_action
      >> i_sequence_terminated_by_non_response_action
      >> file_name_NodeMultiProcessor >> file_name_indeck
      >> file_name_restart >> file_name_ES;
  { int iMode_val; fin >> iMode_val; m_iMode = static_cast<ConsoleMode>(iMode_val); }
 
  if (i_sequence_terminated_by_alarm == 0) {
    sequence_terminated_by_alarm = false;
  } else {
    sequence_terminated_by_alarm = true;
  }
 
  if (i_sequence_terminated_by_non_response_action == 0) {
    sequence_terminated_by_non_response_action = false;
  } else {
    sequence_terminated_by_non_response_action = true;
  }
 
}
void Scheduler::copyScheduler(Scheduler &_ss) {
  project_directory = _ss.getProjectDirectory();
  output_directory = _ss.getOutputDirectory();
  es_directory = _ss.getESDirectory();
  pe_directory = _ss.getPEDirectory();
  kps_directory = _ss.getKPSDirectory();
  input_deck_file_directory_and_name = _ss.getInputDeckFileDirectoryAndName();
  eop_directory = _ss.getEOPDirectory();
  ODM_directory = _ss.getODMDirectory();
  OAT_directory = _ss.getOATDirectory();
  OCT_directory = _ss.getOCTDirectory();
  hardware_reliability_directory = _ss.getHardwareReliabilityDirectory();
  indicators_directory = _ss.getIndicatorsDirectory();
  scheduler_directory = _ss.getSchedulerDirectory();
  system_directory = _ss.getSystemDirectory();
  support_systems_directory = _ss.getSupportSystemsDirectory();
  sequence_truncation_probabiliy = _ss.getSequenceTruncationProbability();
  sequence_truncation_time = _ss.getSequenceTruncationTime();
  OAT_action_time_multiplier = _ss.getOATActionTimeMultiplier();
  ODM_action_time_multiplier = _ss.getODMActionTimeMultiplier();
  OCT_action_time_multiplier = _ss.getOCTActionTimeMultiplier();
  sequence_terminated_by_alarm = _ss.getSequenceTerminatedByAlarm();
  sequence_terminated_by_non_response_action =
      _ss.getSequenceTerminatedByNonResponseAction();
  info_of_sequence_terminated_by_alarm =
      _ss.getInfoOfSequenceTerminatedByAlarm();
  info_sequence_terminated_by_non_response_action =
      _ss.getInfoSequenceTerminatedByNonResponseAction();
  file_name_NodeMultiProcessor = _ss.getFileNameNodeMultiProcessor();
  file_name_indeck = _ss.getFileNameIndeck();
  file_name_restart = _ss.getFileNameRestart();
  file_name_ES = _ss.getFileNameES();
  m_iMode = _ss.getMiMode();
}
void Scheduler::setFileNameNodeMultiProcessor(string str) {
  file_name_NodeMultiProcessor = str;
}
void Scheduler::setFileNameIndeck(string str) {
  file_name_indeck = str;
}
void Scheduler::setFileNameRestart(string str) {
  file_name_restart = str;
}
void Scheduler::setFileNameES(string str) {
  file_name_ES = str;
}
string Scheduler::getFileNameNodeMultiProcessor() {
  return file_name_NodeMultiProcessor;
}
string Scheduler::getFileNameIndeck() {
  return file_name_indeck;
}
string Scheduler::getFileNameRestart() {
  return file_name_restart;
}
string Scheduler::getFileNameES() {
  return file_name_ES;
}
void Scheduler::resetScheduler() {
  ODM_action_time_multiplier = 1.0;
  OAT_action_time_multiplier = 1.0;
  OCT_action_time_multiplier = 1.0;
  sequence_terminated_by_alarm = false;
  sequence_terminated_by_non_response_action = false;
  info_of_sequence_terminated_by_alarm = "NONE";
  info_sequence_terminated_by_non_response_action = "NONE";
  project_directory = "NONE";
  output_directory = "NONE";
  es_directory = "NONE";
  pe_directory = "NONE";
  kps_directory = "NONE";
  input_deck_file_directory_and_name = "NONE";
  eop_directory = "NONE";
  ODM_directory = "NONE";
  OAT_directory = "NONE";
  OCT_directory = "NONE";
  hardware_reliability_directory = "NONE";
  indicators_directory = "NONE";
  scheduler_directory = "NONE";
  system_directory = "NONE";
  support_systems_directory = "NONE";
  sequence_truncation_probabiliy = 0.0;
  sequence_truncation_time = 0.0;
  file_name_NodeMultiProcessor = "NONE";
  file_name_indeck = "NONE";
  file_name_restart = "NONE";
  file_name_ES = "NONE";
  m_iMode = ConsoleMode::Console;
}
void Scheduler::setMiMode(ConsoleMode n) {
  m_iMode = n;
}
ConsoleMode Scheduler::getMiMode() {
  return m_iMode;
}
 
// #ifndef _CONSOLE
 
// int Scheduler::getClusterNodeSequenceFromSrv() const
// {
//  ::SendMessage(theCltDlg->GetSafeHwnd(),WM_CLUSTERREQUEST,0,0);
//  ::WaitForSingleObject(g_eventClusterNode,INFINITE);
//  g_eventClusterNode.ResetEvent();
 
//  return theCltDlg->m_iClusterNodeSequence;
// }
 
// int Scheduler::getPENodeSequenceFromSrv() const
// {
//  ::SendMessage(theCltDlg->GetSafeHwnd(),WM_PEREQUEST,0,0);
//  ::WaitForSingleObject(g_eventPENode,INFINITE);
//  g_eventPENode.ResetEvent();
 
//  return theCltDlg->m_iPENodeSequence;
// }
 
// int Scheduler::getESNodeSequenceFromSrv() const
// {
//  ::SendMessage(theCltDlg->GetSafeHwnd(),WM_ESREQUEST,0,0);
//  ::WaitForSingleObject(g_eventESNode,INFINITE);
//  g_eventESNode.ResetEvent();
 
//  return theCltDlg->m_iESNodeSequence;
// }
 
// #endif