Procedures.cpp

Go to the documentation of this file.

// Procedures.cpp: implementation of the Procedures class.
//
 
#include "Procedures.h"
#include "../Scheduler/Scheduler.h"
#include "../Scheduler/CommunicationPlace.h"
#include "../Branch/BranchRecord.h"
#include <boost/serialization/export.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include "../Global/SimulationContext.h"
BOOST_CLASS_EXPORT_IMPLEMENT(Procedures)
using namespace std;
 
 
// Construction/Destruction
 
Procedures::Procedures()
{
    step_transfer_time = 0.0;
    procedure_transfer_time = 0.0;
    normal_procedure_multiplier = 1.0;
    mental_procedure_multiplier = 1.0;
    abnormal_procedure_multiplier = 1.0;
    optimal_recovery_procedure_multiplier = 1.0;
    functional_recovery_procedure_multiplier = 1.0; 
    alarm_response_procedure_multiplier = 1.0;
    objective_step_multiplier = 1.0;
    prerequisite_step_multiplier = 1.0;
    monitoring_step_multiplier = 1.0;
    verification_step_multiplier = 1.0;
    diagnosis_step_multiplier = 1.0;
}
 
Procedures::~Procedures()
{
    this->clearProcedures();
}
void Procedures::initiationForSimulation(){
    // Idempotent: clients and the server load the procedure book at
    // startup (the shared master must exist before the first snapshot arrives
    // over the wire or from a checkpoint) and onFirstInit reaches here again
    // on the engine's normal path. The book is immutable configuration;
    // reloading would append a duplicate of every step.
    if (!procedure_step.empty()) return;
    this->readInfoFromFile();
};
typedef map<string, ProcedureStep *> ProcedureMAP;
void Procedures::setStepTransferTime(double x) {step_transfer_time = x;}
double Procedures::getStepTransferTime() {return step_transfer_time;}
void Procedures::setProcedureTransferTime(double x) {procedure_transfer_time = x;}
double Procedures::getProcedureTransferTime() {return procedure_transfer_time;}
double Procedures::getNormalProcedureMultiplier() {return normal_procedure_multiplier;}
double Procedures::getMentalProcedureMultiplier() {return mental_procedure_multiplier;}
double Procedures::getAbnormalProcedureMultiplier() {return abnormal_procedure_multiplier;}
double Procedures::getOptimalRecoveryProcedureMultiplier() {return optimal_recovery_procedure_multiplier;}
double Procedures::getFunctionalRecoveryProcedureMultipler() {return functional_recovery_procedure_multiplier;}
double Procedures::getAlarmResponseProcedureMultiplier() {return alarm_response_procedure_multiplier;}
double Procedures::getObjectiveStepMultiplier() {return objective_step_multiplier;}
double Procedures::getPrerequisiteStepMultiplier() {return prerequisite_step_multiplier;}
double Procedures::getMonitoringStepMultiplier() {return monitoring_step_multiplier;}
double Procedures::getVerificationStepMultiplier() {return verification_step_multiplier;}
double Procedures::getDiagnosisStepMultiplier() {return diagnosis_step_multiplier;}
void Procedures::setNormalProcedureMultiplier(double x) {normal_procedure_multiplier = x;}
void Procedures::setMentalProcedureMultiplier(double x) {mental_procedure_multiplier = x;}
void Procedures::setAbnormalProcedureMultiplier(double x) {abnormal_procedure_multiplier = x;}
void Procedures::setOptimalRecoveryProcedureMultiplier(double x) {optimal_recovery_procedure_multiplier = x;}
void Procedures::setFunctionalRecoveryProcedureMultipler(double x) {functional_recovery_procedure_multiplier = x;}
void Procedures::setAlarmResponseProcedureMultiplier(double x) {alarm_response_procedure_multiplier = x;}
void Procedures::setObjectiveStepMultiplier(double x) {objective_step_multiplier = x;}
void Procedures::setPrerequisiteStepMultiplier(double x) {prerequisite_step_multiplier = x;}
void Procedures::setMonitoringStepMultiplier(double x) {monitoring_step_multiplier = x;}
void Procedures::setVerificationStepMultiplier(double x) {verification_step_multiplier = x;}
void Procedures::setDiagnosisStepMultiplier(double x) {diagnosis_step_multiplier = x;}
void Procedures::readInfoFromFile(){
    string file_name, procedure_name, step_name, combined_name, str;
    int i, n_step;
    bool found_file, found_file1;
    ifstream fin;
    //
    file_name = g_sim.SScheduler.getEOPDirectory();
    file_name += "Procedures.txt";
    fin.open(file_name.c_str(), ios::in);
    if(!fin.is_open()){//the file contains the list of procedure steps cannot be found
        cout << "File: " << file_name <<  " cound not be found" << endl;
        ofstream fout("err messages.txt", ios::app);
        fout << r5pars_.timesno << "  File: " << file_name <<  " cound not be found\n";
        fout.close();
        r5pars_.terminateall = true;
        found_file = false;
        return;
    }
    else{
        found_file = true;
    }
    fin >> str >> step_transfer_time;
    fin >> str >> procedure_transfer_time;
    fin >> str >> normal_procedure_multiplier;
    fin >> str >> abnormal_procedure_multiplier;
    fin >> str >> alarm_response_procedure_multiplier;
    fin >> str >> optimal_recovery_procedure_multiplier;
    fin >> str >> functional_recovery_procedure_multiplier;
    fin >> str >> mental_procedure_multiplier;
    fin >> str >> verification_step_multiplier; 
    fin >> str >> monitoring_step_multiplier;
    fin >> str >> prerequisite_step_multiplier;
    fin >> str >> objective_step_multiplier; 
    fin >> str >> diagnosis_step_multiplier;
    fin >> str >> n_step;//coded procedure steps
    for (i = 0; i < n_step; i++){
        fin >> procedure_name >> step_name;
        auto pps_pt = make_unique<ProcedureStepInfo>();
        pps_pt->setProcedureName(procedure_name);
        pps_pt->setStepName(step_name);
        list_of_procedural_step.push_back(std::move(pps_pt));
    }
    fin.close();
    for(auto& pps : list_of_procedural_step){
        auto pstep_pt = make_unique<ProcedureStep>();
        found_file1 = pstep_pt->readInfoFromFile(pps->getProcedureName(), pps->getStepName());
        if(found_file1){
            combined_name = pstep_pt->getCurrentProcedureName();
            combined_name += pstep_pt->getCurrentStepName();
            procedure_map.insert(ProcedureMAP::value_type(combined_name, pstep_pt.get()));
        }
        else{
            found_file = found_file1;
        }
        procedure_step.push_back(std::move(pstep_pt));
    }
    if(!found_file){
        r5pars_.terminateall = true;
    }
}
void Procedures::copyProcedures(Procedures &_pt){
    string combined_name, step_name;
    procedure_transfer_time = _pt.getProcedureTransferTime();
    step_transfer_time = _pt.getStepTransferTime();
    normal_procedure_multiplier = _pt.getNormalProcedureMultiplier();
    mental_procedure_multiplier = _pt.getMentalProcedureMultiplier();
    abnormal_procedure_multiplier = _pt.getAbnormalProcedureMultiplier();
    optimal_recovery_procedure_multiplier = _pt.getOptimalRecoveryProcedureMultiplier();
    functional_recovery_procedure_multiplier = _pt.getFunctionalRecoveryProcedureMultipler();
    alarm_response_procedure_multiplier = _pt.getAlarmResponseProcedureMultiplier();
    objective_step_multiplier = _pt.getObjectiveStepMultiplier();
    prerequisite_step_multiplier = _pt.getPrerequisiteStepMultiplier();
    monitoring_step_multiplier = _pt.getMonitoringStepMultiplier();
    verification_step_multiplier = _pt.getVerificationStepMultiplier();
    diagnosis_step_multiplier = _pt.getDiagnosisStepMultiplier();
    for(auto& src : _pt.list_of_procedural_step){
        auto ptr = make_unique<ProcedureStepInfo>();
        ptr->copyProcedureStepInfo(*src);
        list_of_procedural_step.push_back(std::move(ptr));
    }
    for(auto& src : _pt.procedure_step){
        auto ptr = make_unique<ProcedureStep>();
        ptr->copyProcedureStep(*src);
        combined_name = ptr->getCurrentProcedureName();
        step_name = ptr->getCurrentStepName();
        combined_name += step_name;
        procedure_map.insert(ProcedureMAP::value_type(combined_name, ptr.get()));
        procedure_step.push_back(std::move(ptr));
    }
}
string Procedures::getEntryProcedureName(){
    string r_return = "NO_PROCEDURE";
    if(list_of_procedural_step.size() > 0){
        r_return = list_of_procedural_step[0]->getProcedureName();
    }
    return r_return;
}
string Procedures::getEntryStepName(){
    string r_return = "NO_STEP";
    if(list_of_procedural_step.size() > 0){
        r_return = list_of_procedural_step[0]->getStepName();
    }
    return r_return;
}
void Procedures::clearProcedures(){
    procedure_step.clear();
    list_of_procedural_step.clear();
    procedure_map.clear();
}
 
void Procedures::clearProceduresForRestart(){
    procedure_step.clear();
    procedure_map.clear();
}
void Procedures::copyProceduresToRestartInfoForRestart(Procedures &_pt){
    procedure_transfer_time = _pt.getProcedureTransferTime();
    step_transfer_time = _pt.getStepTransferTime();
    normal_procedure_multiplier = _pt.getNormalProcedureMultiplier();
    mental_procedure_multiplier = _pt.getMentalProcedureMultiplier();
    abnormal_procedure_multiplier = _pt.getAbnormalProcedureMultiplier();
    optimal_recovery_procedure_multiplier = _pt.getOptimalRecoveryProcedureMultiplier();
    functional_recovery_procedure_multiplier = _pt.getFunctionalRecoveryProcedureMultipler();
    alarm_response_procedure_multiplier = _pt.getAlarmResponseProcedureMultiplier();
    objective_step_multiplier = _pt.getObjectiveStepMultiplier();
    prerequisite_step_multiplier = _pt.getPrerequisiteStepMultiplier();
    monitoring_step_multiplier = _pt.getMonitoringStepMultiplier();
    verification_step_multiplier = _pt.getVerificationStepMultiplier();
    diagnosis_step_multiplier = _pt.getDiagnosisStepMultiplier();
    for(auto& src : _pt.procedure_step){
        auto ptr = make_unique<ProcedureStep>();
        ptr->copyProcedureStep(*src);
        procedure_step.push_back(std::move(ptr));
    }
}
void Procedures::copyProceduresFromRestartInfoForRestart(Procedures &_pt){
    string combined_name, step_name;
    procedure_transfer_time = _pt.getProcedureTransferTime();
    step_transfer_time = _pt.getStepTransferTime();
    normal_procedure_multiplier = _pt.getNormalProcedureMultiplier();
    mental_procedure_multiplier = _pt.getMentalProcedureMultiplier();
    abnormal_procedure_multiplier = _pt.getAbnormalProcedureMultiplier();
    optimal_recovery_procedure_multiplier = _pt.getOptimalRecoveryProcedureMultiplier();
    functional_recovery_procedure_multiplier = _pt.getFunctionalRecoveryProcedureMultipler();
    alarm_response_procedure_multiplier = _pt.getAlarmResponseProcedureMultiplier();
    objective_step_multiplier = _pt.getObjectiveStepMultiplier();
    prerequisite_step_multiplier = _pt.getPrerequisiteStepMultiplier();
    monitoring_step_multiplier = _pt.getMonitoringStepMultiplier();
    verification_step_multiplier = _pt.getVerificationStepMultiplier();
    diagnosis_step_multiplier = _pt.getDiagnosisStepMultiplier();
    for(auto& src : _pt.procedure_step){
        auto ptr = make_unique<ProcedureStep>();
        ptr->copyProcedureStep(*src);
        combined_name = ptr->getCurrentProcedureName();
        step_name = ptr->getCurrentStepName();
        combined_name += step_name;
        procedure_map.insert(ProcedureMAP::value_type(combined_name, ptr.get()));
        procedure_step.push_back(std::move(ptr));
    }
}
void Procedures::seedFromMaster(const Procedures& master){
    // State overlay: rebuild definitions and structure from the process-local
    // master before the state stream is applied on top. Deep copy: the
    // snapshot remains a private object; only the ARCHIVE carries no
    // configuration. The copy is total (config + the master's current state)
    // and load() then overwrites every state leaf from the stream.
    clearProcedures();
    copyProceduresFromRestartInfoForRestart(const_cast<Procedures&>(master));
}
void Procedures::saveProceduresToFile(ofstream &fout){
    int i, num;
    num = this->procedure_step.size();
    fout << procedure_transfer_time                     << ' '
         << step_transfer_time                          << ' '
         << normal_procedure_multiplier                 << ' '
         << mental_procedure_multiplier                 << ' ' 
         << abnormal_procedure_multiplier               << ' '
         << optimal_recovery_procedure_multiplier       << ' '
         << functional_recovery_procedure_multiplier    << ' '
         << alarm_response_procedure_multiplier         << ' ' 
         << objective_step_multiplier                   << ' '
         << prerequisite_step_multiplier                << ' '
         << monitoring_step_multiplier                  << ' '
         << verification_step_multiplier                << ' '
         << diagnosis_step_multiplier                   << '\n';
    fout << "Procedures\n" << num << '\n';
    for(i = 0; i < num; i++){
        this->procedure_step.at(i)->saveProcedureStepToFile(fout);
    }
    num = this->list_of_procedural_step.size();
    fout << '\n' << num << '\n';
    for(i = 0; i < num; i++){
        this->list_of_procedural_step.at(i)->saveProcedureStepInfoToFile(fout);
    }
}
void Procedures::retrieveProceduresFromFile(ifstream &fin){
    int i, num;
    string combined_name, str;
    fin >> procedure_transfer_time 
        >> step_transfer_time
        >> normal_procedure_multiplier 
        >> mental_procedure_multiplier 
        >> abnormal_procedure_multiplier
        >> optimal_recovery_procedure_multiplier
        >> functional_recovery_procedure_multiplier
        >> alarm_response_procedure_multiplier 
        >> objective_step_multiplier 
        >> prerequisite_step_multiplier 
        >> monitoring_step_multiplier 
        >> verification_step_multiplier 
        >> diagnosis_step_multiplier;
    fin >> str >> num;
    if (str != "Procedures"){
        ofstream fout("err messages.txt", ios::app);
        cout << "Procedures::retrieveProceduresFromFile retrieval errir in previous function" << endl;
        fout << r5pars_.timesno << "  Procedures::retrieveProceduresFromFile retrieval errir in previous function\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("Procedures::retrieveProceduresFromFile Prior err.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
        return;
    }
 
    for(i = 0; i < num; i++){
        auto procedure_step_pt = make_unique<ProcedureStep>();
        procedure_step_pt->retrieveProcedureStepFromFile(fin);
        combined_name = procedure_step_pt->getCurrentProcedureName();
        combined_name += procedure_step_pt->getCurrentStepName();
        procedure_map.insert(ProcedureMAP::value_type(combined_name, procedure_step_pt.get()));
        this->procedure_step.push_back(std::move(procedure_step_pt));
    }
    fin >> num;
    for(i = 0; i < num; i++){
        auto list_of_procedural_step_pt = make_unique<ProcedureStepInfo>();
        list_of_procedural_step_pt->retrieveProcedureStepInfoFromFile(fin);
        this->list_of_procedural_step.push_back(std::move(list_of_procedural_step_pt));
    }
}