ProcedureStep.cpp

Go to the documentation of this file.

// ProcedureStep.cpp: implementation of the ProcedureStep class.
//
 
#include "ProcedureStep.h"
#include "../Scheduler/Scheduler.h"
#include "../Global/fmodule.h"
#include "../ControlPanel/ControlPanel.h"
#include "../Branch/BranchRecord.h"
#include "../Branch/BranchExpectedMentalBelief.h"
#include "../Crew/OperatorDM.h"
#include "Procedures.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(ProcedureStep)
using namespace std;
 
 
// Construction/Destruction
 
ProcedureStep::ProcedureStep()
{
    branch_control_flag = 0;
    current_procedure_name = "NONE";
    current_step_name = "NONE";
    next_procedure_name = "NONE";
    next_step_name = "NONE";;
    description = "NONE";
    procedure_step_characteristics = sim::None;
    procedure_step_complexity = sim::None;
    procedure_type = sim::None;
}
 
ProcedureStep::~ProcedureStep()
{
    this->clear();
}
void ProcedureStep::setCurrentProcedureName(string str){current_procedure_name = str;}
void ProcedureStep::setCurrentStepName(string str){current_step_name = str;}
void ProcedureStep::setNextProcedureName(string str){next_procedure_name = str;}
void ProcedureStep::setNextStepName(string str){next_step_name = str;}
void ProcedureStep::setProcedureStepCharacteristics(int n) {procedure_step_characteristics = n;}
void ProcedureStep::setProcedureStepComplexity(double x) {procedure_step_complexity = x;}
void ProcedureStep::setProcedureType(int n) {procedure_type =n;}
string ProcedureStep::getCurrentProcedureName(){return current_procedure_name;}
string ProcedureStep::getCurrentStepName(){return current_step_name;}
string ProcedureStep::getNextProcedureName(){return next_procedure_name;}
string ProcedureStep::getNextStepName(){return next_step_name;}
int ProcedureStep::getProcedureStepCharacteristics() {return procedure_step_characteristics;}
double ProcedureStep::getProcedureStepComplexity() {return procedure_step_complexity;}
int ProcedureStep::getProcedureType() {return procedure_type;}
 
void ProcedureStep::clear(){
    procedure_step_unit.clear();
}
void ProcedureStep::setDescription(string str){description = str;}
string ProcedureStep::getDescription(){return description;}
bool ProcedureStep::readInfoFromFile(string _procedure_name, string _step_name){
    string file_directory_and_name, str, sub_str;
    bool found_file;
    int i, n_procedure_step_unit;
    double x_temp;
    int num_quotation = 0;
    file_directory_and_name = g_sim.SScheduler.getEOPDirectory();
    file_directory_and_name += "ZProcedure_";
    file_directory_and_name += _procedure_name;
    file_directory_and_name += '_';
    file_directory_and_name += _step_name;
    file_directory_and_name += ".txt";
    ifstream fin;
    fin.open(file_directory_and_name.c_str(), ios::in);
    if(!fin.is_open()){
        cout << "File: " << file_directory_and_name <<  " cound not be found" << endl;
        ofstream fout("err messages.txt", ios::app);
        fout << r5pars_.timesno << "  File: " << file_directory_and_name <<  " cound not be found\n";
        fout.close();
        found_file = false;
    }
    else{
        found_file = true;
    }
    if(!found_file){
        return found_file;
    }
    fin >> current_procedure_name >> current_step_name;
    // ensure that input file procedure/step name matches procedure.txt description
    if (current_procedure_name != _procedure_name || current_step_name != _step_name) {
        ofstream fout("err messages.txt", ios::app);
        cout << "ProcedureStep::readInfoFromFile File: " << _procedure_name << ' ' << _step_name << " input file has incorrect procedure or step name" << endl;
        fout << r5pars_.timesno << "  ProcedureStep::readInfoFromFile File: " << _procedure_name << ' ' << _step_name << " input file has incorrect procedure or step name\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("ProcedureStep::readInfoFromFile err.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    }
    this->readDescriptionFromFile(fin);
    if(fin.eof()){
        ofstream fout("err messages.txt", ios::app);
        cout << "ProcedureStep::readInfoFromFile File: " << _procedure_name << ' ' << _step_name << " has incorrect quotation mark." << endl;
        fout << r5pars_.timesno << "  ProcedureStep::readInfoFromFile File: " << _procedure_name << ' ' << _step_name << " has incorrect quotation mark.\n";
        fout.close();
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("ProcedureStep::readInfoFromFile err.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    }
 
    fin >> procedure_type  
        >> procedure_step_characteristics 
        >> procedure_step_complexity
        >> x_temp 
        >> n_procedure_step_unit;
    for(i = 0; i < n_procedure_step_unit; i++){
        auto ps_pt = make_unique<ProcedureStepUnit>();
        if(ps_pt->readInfofromFile(fin) == false)
        {
            cout << "check " << this->current_procedure_name << " " << this->current_step_name;
        }
        procedure_step_unit.push_back(std::move(ps_pt));
    }
    fin >> next_procedure_name >> next_step_name;
    fin.close();
    return found_file;
}
void ProcedureStep::readDescriptionFromFile(ifstream &fin){
    char ch =  ' ';
    while (ch != '"' && !fin.eof()){
        fin.get(ch);}
    if(ch == '"') description = ch;
    do{
        fin.get(ch);
        description += ch;
    }while(ch != '"' && !fin.eof());
}
void ProcedureStep::copyProcedureStep(ProcedureStep &_psp){
    StateOfActivation::copyStateOfActivation((StateOfActivation &) _psp);
    current_procedure_name = _psp.getCurrentProcedureName();
    current_step_name = _psp.getCurrentStepName();
    next_procedure_name = _psp.getNextProcedureName();
    next_step_name = _psp.getNextStepName();
    branch_control_flag = _psp.getBranchControlFlag();
    description = _psp.getDescription();
    procedure_step_characteristics = _psp.getProcedureStepCharacteristics();
    procedure_step_complexity = _psp.getProcedureStepComplexity();
    procedure_type = _psp.getProcedureType();
    for(auto& src : _psp.procedure_step_unit){
        auto ptr = make_unique<ProcedureStepUnit>();
        ptr->copyProcedureStepUnit(*src);
        procedure_step_unit.push_back(std::move(ptr));
    }
}
 
 
bool ProcedureStep::oneThroughProcessForProcedureStep(Operator &_operator, double _skip_action_threshold, double _skip_non_response_threshold, bool _skip, ShortTermMemory &_stm){
    BranchProcedureStep *b_procedure_pt;
    bool next_is_a_mental_procedure = false;
    bool this_is_a_mental_procedure = false;
    bool branch_generated = false;
    bool found_ps_unit = false;
    double time;
    double static_HEP_multiplier;
    string str, message;
    int branch_number;
    decltype(procedure_step_unit)::iterator ps_unit_itr;
    ProcedureStepUnit *ps_unit_pt = 0;
    int state_of_activation;
/*  switch (_operator.getTypeOfOperator()) {
    case sim::Operator::ODM:
        _skip_action_threshold = g_sim.Decision_Maker.getSkipActionThreshold();
        _skip_non_response_threshold = g_sim.Decision_Maker.getSkipNonResponseThreshold();
        _skip = g_sim.Decision_Maker.getSkipProcedureStep();
        _stm = g_sim.Decision_Maker.memory;
        break;
    case sim::Operator::OAT:
        _skip_action_threshold = g_sim.Action_Taker.getSkipActionThreshold();
        _skip_non_response_threshold = g_sim.Action_Taker.getSkipNonResponseThreshold();
        _skip = g_sim.Action_Taker.getSkipProcedureStep();
        _stm = g_sim.Action_Taker.memory;
        break;
    default:
        break;
    }
*/
    //identify the procedure_step_unit to work
    ps_unit_itr = this->procedure_step_unit.begin();
    while(ps_unit_itr != this->procedure_step_unit.end() && !found_ps_unit){
        state_of_activation = (*ps_unit_itr)->getStateOfActivation();
        if(state_of_activation == sim::None || state_of_activation == sim::State::Active){
            found_ps_unit = true;
            ps_unit_pt = ps_unit_itr->get();
        }
        ps_unit_itr++;
    }
    if (ps_unit_pt != 0){
        if(ps_unit_pt->getStateOfAction() == sim::None){
            ps_unit_pt->setStateOfActivation(sim::State::Active);
            if(ps_unit_pt->getTypeOfAction() == sim::Branch::ProcedureTransfer){
                this->resetStateOfActivation();
                _stm.perceived_info.setStateOfAProcedureStep(current_procedure_name, current_step_name, sim::State::Succeed);
                b_procedure_pt = new BranchProcedureStep();
                b_procedure_pt->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());//(sender, receiver)
                // set time for procedure step transfer
                if (current_procedure_name == next_procedure_name) {
                    time = g_sim.All_procedure.getStepTransferTime();
                } else {
                    time = g_sim.All_procedure.getProcedureTransferTime();
                }
                b_procedure_pt->setTimerAndProbability(time, 1.0 - _operator.hfe_bbn.getProcedureStepFailureProbability());//(remaining time, probability)
                b_procedure_pt->setProcedureName(next_procedure_name);
                b_procedure_pt->setStepName(next_step_name);
                b_procedure_pt->setLastProcedureName(current_procedure_name);
                b_procedure_pt->setLastStepName(current_step_name);
                b_procedure_pt->setTypeOfPauseActivity(sim::Strategy::FollowProcedure);
                g_sim.Branch_center.addProcedureStep(_operator.getTypeOfOperator(), b_procedure_pt);
                branch_generated = true;
                return branch_generated;
            }
            else{
                //
                static_HEP_multiplier = this->calculateProcedureStepStaticHEPMultiplier();
                //
                branch_generated = ps_unit_pt->executeAction(_operator, _stm, sim::Strategy::FollowProcedure, this->getDescription(),
                    this->getCurrentProcedureName(), this->getCurrentStepName(), _skip_action_threshold,
                    static_HEP_multiplier);
            }
        }
        else if(ps_unit_pt->getNumberOfANDExpectation() <= 0){//simple action no expectation
            if (_skip) {
                ps_unit_pt->setStateOfActivation(sim::State::Skip);
                str= "Procedure: Skipped Step Action";
                branch_number = g_sim.Branch_center.getIDOfRecentGeneratedBranch();
                g_sim.Command_handler.displayInformation(str);
                g_sim.Aux_info.addRecord(str,branch_number);
            }
            else {
                ps_unit_pt->setStateOfActivation(sim::State::Succeed);
            }
        }
        else if(_skip && ps_unit_pt->getStateOfExpectation() == sim::None){ // skipped step - bypass expectations & non response action
            ps_unit_pt->setStateOfActivation(sim::State::Skip);
            str= "Procedure: Skipped Step Action";
            branch_number = g_sim.Branch_center.getIDOfRecentGeneratedBranch();
            g_sim.Command_handler.displayInformation(str);
            g_sim.Aux_info.addRecord(str,branch_number);
        }
        else if(ps_unit_pt->getStateOfExpectation() == sim::State::Active){
            branch_generated = ps_unit_pt->executeExpectation(_operator, _stm, sim::Strategy::FollowProcedure);
        }
        else if (ps_unit_pt->getStateOfExpectation() == sim::None){
            ps_unit_pt->setStateOfExpectation(sim::State::Active);
            branch_generated = ps_unit_pt->executeExpectation(_operator, _stm, sim::Strategy::FollowProcedure);
        }
        else if (ps_unit_pt->getStateOfExpectation() == sim::State::Failed && ps_unit_pt->hasNonResponseAction())
        {
            if(ps_unit_pt->getStateOfNonResponseAction() == sim::None){
                ps_unit_pt->setStateOfNonResponseAction(sim::State::Active);
                //
                static_HEP_multiplier = this->calculateProcedureStepStaticHEPMultiplier();
                //
                branch_generated = ps_unit_pt->executeNonResponseAction(_operator, _stm, sim::Strategy::FollowProcedure, this->getCurrentProcedureName(), this->getCurrentStepName(),_skip_non_response_threshold, static_HEP_multiplier);
            }
            else {
                if(_skip) {
                    str= "Procedure: Skipped Non-Response Action";
                    branch_number = g_sim.Branch_center.getIDOfRecentGeneratedBranch();
                    g_sim.Command_handler.displayInformation(str);
                    g_sim.Aux_info.addRecord(str,branch_number);
                }
                ps_unit_pt->setStateOfActivation(sim::State::Succeed);
            }
        }
        else if (ps_unit_pt->getStateOfExpectation() == sim::State::Failed && ps_unit_pt->getTypeOfNonResponseAction() == sim::ControlAction::Stop)
        {
            message  = "Sequence_terminated_by_non-response_action_(STOP):_Procedure:_";
            message += this->getCurrentProcedureName();
            message += " - Step: ";
            message += this->getCurrentStepName();
            g_sim.SScheduler.setSequenceTerminatedByNonResponseAction(true);
            g_sim.SScheduler.setInfoSequenceTerminatedByNonResponseAction(message);
        }
        else{
            ps_unit_pt->setStateOfActivation(sim::State::Succeed);
        }
    }
    else{//complete this procedure
        _stm.perceived_info.setStateOfAProcedureStep(current_procedure_name, current_step_name, sim::State::Succeed);
        this->resetStateOfActivation();
        // 
        if (next_procedure_name != "NONE" && next_procedure_name != "None") {
            b_procedure_pt = new BranchProcedureStep();
            b_procedure_pt->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());//(sender, receiver)
            // set time for procedure step transfer
            if (current_procedure_name == next_procedure_name) {
                time = g_sim.All_procedure.getStepTransferTime();
            } else {
                time = g_sim.All_procedure.getProcedureTransferTime();
            }
            b_procedure_pt->setTimerAndProbability(time, 1.0 - _operator.hfe_bbn.getProcedureStepFailureProbability());//(remaining time, probability)
            b_procedure_pt->setProcedureName(next_procedure_name);
            b_procedure_pt->setStepName(next_step_name);
            b_procedure_pt->setLastProcedureName(current_procedure_name);
            b_procedure_pt->setLastStepName(current_step_name);
            b_procedure_pt->setTypeOfPauseActivity(sim::Strategy::FollowProcedure);
            //
            g_sim.Branch_center.addProcedureStep(_operator.getTypeOfOperator(), b_procedure_pt);
            branch_generated = true;
        }
        else {
            // branch will not be generated when procedure is complete - need to update hard wired diagnosis 
            // for completed procedure
            switch (_operator.getTypeOfOperator()) {
            case sim::Operator::ODM:
                g_sim.Decision_Maker.knowledge_base.KBcheckHardWiredMatchForProcedureActivity(current_procedure_name, sim::State::Done);
                break;
            case sim::Operator::OAT:
                g_sim.Action_Taker.knowledge_base.KBcheckHardWiredMatchForProcedureActivity(current_procedure_name,sim::State::Done);
                break;
            default:
                break;
            }
        }
    }
    return branch_generated;
}
void ProcedureStep::resetStateOfActivation(){
    this->setStateOfActivation(sim::None);
    vector<unique_ptr<ExpectationORUnit>>::iterator expectation_itr;
    vector<unique_ptr<ExpectationElement>>::iterator expectation_OR_itr;
    decltype(procedure_step_unit)::iterator procedure_step_unit_itr;
    for (procedure_step_unit_itr = procedure_step_unit.begin(); procedure_step_unit_itr != procedure_step_unit.end(); procedure_step_unit_itr++){
        (*procedure_step_unit_itr)->setStateOfActivation(sim::None);
        (*procedure_step_unit_itr)->setStateOfAction(sim::None);
        (*procedure_step_unit_itr)->setStateOfExpectation(sim::None);
        (*procedure_step_unit_itr)->setStateOfNonResponseAction(sim::None);
        //reset expectation state of activation
        for(expectation_itr = (*procedure_step_unit_itr)->expectation.begin();expectation_itr!=(*procedure_step_unit_itr)->expectation.end();expectation_itr++){
            (*expectation_itr)->setStateOfActivation(sim::None);
            for(expectation_OR_itr = (*expectation_itr)->expectation_OR.begin(); expectation_OR_itr != (*expectation_itr)->expectation_OR.end(); expectation_OR_itr++){
                (*expectation_OR_itr)->setStateOfExpectation(sim::None);
            }
        }
        //
    }
}
bool ProcedureStep::oneThroughProcessForInstinctiveResponseProcedure(Operator &_operator, double _skip_action_threshold, double _skip_non_response_threshold, bool _skip, ShortTermMemory &_stm){
    bool next_is_a_mental_procedure = false;
    bool next_is_a_functional_recovery_guideline = false;
    bool this_is_a_mental_procedure = false;
    bool branch_generated = false;
    bool found_ps_unit = false;
    bool command_action = false;
    double static_HEP_multiplier;
    string str, sub_str, active_procedure_name, active_step_name, active_combined_name;
    int branch_number;
    int entry = sim::Strategy::InstinctiveResponse;
    int action_type = sim::None;
    decltype(procedure_step_unit)::iterator ps_unit_itr;
    map<string, ProcedureStep *>::iterator procedure_map_itr;
    ProcedureStepUnit *ps_unit_pt = 0;
    int state_of_activation;
    //
    //identify the procedure_step_unit to work
    ps_unit_itr = this->procedure_step_unit.begin();
    while(ps_unit_itr != this->procedure_step_unit.end() && !found_ps_unit){
        state_of_activation = (*ps_unit_itr)->getStateOfActivation();
        if(state_of_activation == sim::None || state_of_activation == sim::State::Active){
            found_ps_unit = true;
            ps_unit_pt = ps_unit_itr->get();
        }
        ps_unit_itr++;
    }
    if (ps_unit_pt != 0){
        // determine if next procedure step is a mental procedure
        if(next_procedure_name.size() > 5){
            sub_str = next_procedure_name.substr(0,5);
            if (sub_str == "MPBG_"){
                next_is_a_mental_procedure = true;
            }
        }
        //
        // determine if next procedure step is a functional recovery guideline
        if(next_procedure_name.size() > 4){
            sub_str = next_procedure_name.substr(0,4);
            if (sub_str == "FRG_"){
                next_is_a_functional_recovery_guideline = true;
            }
        }
        //
        action_type = ps_unit_pt->getTypeOfAction();
        if (action_type == sim::Action::Action   || action_type == sim::State::Control         ||
            action_type == sim::ControlAction::Additive || action_type == sim::ControlAction::ParameterControl) 
        {
            command_action = true;
        }
        if(ps_unit_pt->getStateOfAction() == sim::None){
            ps_unit_pt->setStateOfActivation(sim::State::Active);
            if(ps_unit_pt->getTypeOfAction() == sim::Branch::ProcedureTransfer){
                //
                branch_generated = executeInstinctiveResponseProcedureTransfer(_operator, _stm);
            }
 
            else{
                // execute procedure step unit action
                if ( _operator.getTypeOfOperator() == sim::Operator::ODM && command_action ) {
                    entry = sim::Strategy::FollowInstruction;
                }
                //
                static_HEP_multiplier = this->calculateProcedureStepStaticHEPMultiplier();
                //
                branch_generated = ps_unit_pt->executeAction(_operator, _stm, entry, this->getDescription(),
                    this->getCurrentProcedureName(), this->getCurrentStepName(), _skip_action_threshold,
                    static_HEP_multiplier);
            }
        }
        else if(ps_unit_pt->getNumberOfANDExpectation() <= 0){//simple action no expectation
            if (_skip) {
                ps_unit_pt->setStateOfActivation(sim::State::Skip);
                str= "Procedure: Skipped Step Action";
                branch_number = g_sim.Branch_center.getIDOfRecentGeneratedBranch();
                g_sim.Command_handler.displayInformation(str);
                g_sim.Aux_info.addRecord(str,branch_number);
            } 
            else {          
                ps_unit_pt->setStateOfActivation(sim::State::Succeed);
            }
        }
 
        else if(_skip && ps_unit_pt->getStateOfExpectation() == sim::None){ // skipped step - bypass expectations & non response action
            ps_unit_pt->setStateOfActivation(sim::State::Skip);
            str= "Procedure: Skipped Step Action";
            branch_number = g_sim.Branch_center.getIDOfRecentGeneratedBranch();
            g_sim.Command_handler.displayInformation(str);
            g_sim.Aux_info.addRecord(str,branch_number);
        }
 
        else if(ps_unit_pt->getStateOfExpectation() == sim::State::Active){
            if ( _operator.getTypeOfOperator() == sim::Operator::ODM) {
                entry = sim::Strategy::FollowInstruction;
            }
            branch_generated = ps_unit_pt->executeExpectation(_operator, _stm, entry);
        }
 
        else if (ps_unit_pt->getStateOfExpectation() == sim::None){
            ps_unit_pt->setStateOfExpectation(sim::State::Active);
            if ( _operator.getTypeOfOperator() == sim::Operator::ODM) {
                entry = sim::Strategy::FollowInstruction;
            }
            branch_generated = ps_unit_pt->executeExpectation(_operator, _stm, entry);
        }
 
        else if (ps_unit_pt->getStateOfExpectation() == sim::State::Failed && ps_unit_pt->hasNonResponseAction())
        {
            if(ps_unit_pt->getStateOfNonResponseAction() == sim::None){
                ps_unit_pt->setStateOfNonResponseAction(sim::State::Active);
                if ( _operator.getTypeOfOperator() == sim::Operator::ODM) {
                    entry = sim::Strategy::FollowInstruction;
                }
                //
                static_HEP_multiplier = this->calculateProcedureStepStaticHEPMultiplier();
                //
                branch_generated = ps_unit_pt->executeNonResponseAction(_operator, _stm, entry, this->getCurrentProcedureName(), this->getCurrentStepName(),_skip_non_response_threshold, static_HEP_multiplier);
            }
            else {
                if(_skip) {
                    str= "Procedure: Skipped Non-Response Action";
                    branch_number = g_sim.Branch_center.getIDOfRecentGeneratedBranch();
                    g_sim.Command_handler.displayInformation(str);
                    g_sim.Aux_info.addRecord(str,branch_number);
                }
                ps_unit_pt->setStateOfActivation(sim::State::Succeed);
            }
        }
        else{
            ps_unit_pt->setStateOfActivation(sim::State::Succeed);
        }       
        
    }
    else{
 
        //
        if (next_procedure_name != "NONE" && next_procedure_name != "None") {
            branch_generated = executeInstinctiveResponseProcedureTransfer(_operator, _stm);
        }
        else {
            _stm.perceived_info.setStateOfAProcedureStep(current_procedure_name, current_step_name, sim::State::Done);
            this->resetStateOfActivation();
            //
            // branch will not be generated when procedure is complete - need to update hard wired diagnosis 
            // for completed procedure
            switch (_operator.getTypeOfOperator()) {
            case sim::Operator::ODM:
                g_sim.Decision_Maker.knowledge_base.KBcheckHardWiredMatchForProcedureActivity(current_procedure_name, sim::State::Done);
                break;
            case sim::Operator::OAT:
                g_sim.Action_Taker.knowledge_base.KBcheckHardWiredMatchForProcedureActivity(current_procedure_name,sim::State::Done);
                break;
            default:
                break;
            }
        }
 
    }
    return branch_generated;
}
 
bool ProcedureStep::executeInstinctiveResponseProcedureTransfer(Operator &_operator, ShortTermMemory &_stm)
{
    string str, sub_str, active_procedure_name, active_step_name, active_combined_name;
    bool next_is_a_mental_procedure = false;
    bool next_is_a_functional_recovery_guideline = false;
    bool branch_generated = false;
    double time;
    map<string, ProcedureStep *>::iterator procedure_map_itr;
    BranchProcedureStep *b_procedure_pt;
    ProcedureStep * ps_pt;
    //
    // determine if next procedure is a mental procedure
    if(next_procedure_name.size() > 5){
        sub_str = next_procedure_name.substr(0,5);
        if (sub_str == "MPBG_"){
            next_is_a_mental_procedure = true;
        }
    }
    //
    // determine if next procedure step is a functional recovery guideline
    if(next_procedure_name.size() > 4){
        sub_str = next_procedure_name.substr(0,4);
        if (sub_str == "FRG_"){
            next_is_a_functional_recovery_guideline = true;
        }
    }
    //
    if (!next_is_a_mental_procedure && _operator.getTypeOfOperator() == sim::Operator::ODM)  // only sim::Operator::ODM can transfer from mental procedure to a paper procedure
    {  
        // get active paper emergency procedure name and step
        active_procedure_name = _stm.perceived_info.getCurrentProcedureName();
        active_step_name = _stm.perceived_info.getCurrentProceduralStepName();
        active_combined_name = active_procedure_name + active_step_name;
        procedure_map_itr = g_sim.All_procedure.procedure_map.find(active_combined_name);
        if(procedure_map_itr != g_sim.All_procedure.procedure_map.end()){
            ps_pt = procedure_map_itr->second;
            // reset the state of activation for the current paper procedure step
            if (ps_pt != 0)
            {
                ps_pt->resetStateOfActivation();
            }
        }
        if (next_is_a_functional_recovery_guideline) {
            // if instinctive response procedure refers to an FRG, sim::State::Pause the active paper procedure
            // in memory to allow return to appropriate step after FRG is complete
            _stm.perceived_info.interruptCurrentProcedureStep(); // sets state of activation to sim::State::Pause
            //
            //update state of hardwired diagnoses
            switch (_operator.getTypeOfOperator()) {
            case sim::Operator::ODM:
                g_sim.Decision_Maker.knowledge_base.KBcheckHardWiredMatchForProcedureActivity(active_procedure_name, sim::State::Pause);
                break;
            case sim::Operator::OAT:
                g_sim.Action_Taker.knowledge_base.KBcheckHardWiredMatchForProcedureActivity(active_procedure_name,sim::State::Pause);
                break;
            default:
                break;
            }
        }
        else {
            // next procedure is a paper procedure.  
            // Mark current paper procedure complete as sim::State::Interrupted in memory
            _stm.perceived_info.setStateOfAProcedureStep(active_procedure_name,active_step_name, sim::State::Interrupted);
            //
            //update state of hard wired diagnoses
            switch (_operator.getTypeOfOperator()) {
            case sim::Operator::ODM:
                g_sim.Decision_Maker.knowledge_base.KBcheckHardWiredMatchForProcedureActivity(active_procedure_name, sim::State::Done);
                break;
            case sim::Operator::OAT:
                g_sim.Action_Taker.knowledge_base.KBcheckHardWiredMatchForProcedureActivity(active_procedure_name,sim::State::Done);
                break;
            default:
                break;
            }
        }
    }
    //
    this->resetStateOfActivation();
    _stm.perceived_info.setStateOfAProcedureStep(current_procedure_name, current_step_name, sim::State::Done);
    //
    if ( _operator.getTypeOfOperator() == sim::Operator::ODM || next_is_a_mental_procedure )
    {
 
        b_procedure_pt = new BranchProcedureStep();
        b_procedure_pt->setSenderAndReceiver(_operator.getTypeOfOperator(), _operator.getTypeOfOperator());//(sender, receiver)
        //
        // set time delay for procedure transfer
        if (next_procedure_name == current_procedure_name) 
        {
            time = g_sim.All_procedure.getStepTransferTime();  // transfer within same procedure
        }
        else if (next_is_a_functional_recovery_guideline)
        {
            time = -0.5; // set time low for FRG transition to avoid conflict with paused procedures
        }
        else 
        {
            time = g_sim.All_procedure.getProcedureTransferTime(); // transfer to a new procedure
        }
        b_procedure_pt->setTimerAndProbability(time, 1.0 - _operator.hfe_bbn.getProcedureInterpretationFailureProbability());//(remaining time, probability)
        b_procedure_pt->setProcedureName(next_procedure_name);
        b_procedure_pt->setStepName(next_step_name);
        b_procedure_pt->setPriority(_stm.perceived_info.getMentalPriorityOfAProcedureStep(current_procedure_name, current_step_name));
        b_procedure_pt->setLastProcedureName(current_procedure_name);
        b_procedure_pt->setLastStepName(current_step_name);
        if (next_is_a_mental_procedure) {
            b_procedure_pt->setTypeOfPauseActivity(sim::Strategy::InstinctiveResponse);
            g_sim.Branch_center.addInstinctiveResponseProcedure(_operator.getTypeOfOperator(), b_procedure_pt);
            branch_generated = true;
        } else if (_operator.getTypeOfOperator() == sim::Operator::ODM && !next_is_a_mental_procedure)
        {
            b_procedure_pt->setTypeOfPauseActivity(sim::Branch::ProcedureXfr);
            g_sim.Branch_center.addProcedureStep(_operator.getTypeOfOperator(),b_procedure_pt);
            g_sim.Decision_Maker.setPauseActivity(true);
        }
    }
    else 
    {
        // operator other than sim::Operator::ODM attempted transfer to paper procedure
        // ignore transfer and complete procedure step
        ofstream fout("err messages.txt", ios::app);
        cout << "      " << r5pars_.timesno << "  ProcedureStep::executeInstinctiveResponseProcedureTransfer: Illegal procedure transfer operation in " << current_procedure_name << ' ' << current_step_name << endl;
        fout << r5pars_.timesno << "  ProcedureStep::executeInstinctiveResponseProcedureTransfer: Illegal procedure transfer operation in " << current_procedure_name << ' ' << current_step_name << "\n";
        fout.close();   
        //
        // since branch will not be generated when procedure is complete, update hard wired diagnosis 
        // for completed procedure
        switch (_operator.getTypeOfOperator()) {
        case sim::Operator::ODM:
            g_sim.Decision_Maker.knowledge_base.KBcheckHardWiredMatchForProcedureActivity(current_procedure_name, sim::State::Done);
            break;
        case sim::Operator::OAT:
            g_sim.Action_Taker.knowledge_base.KBcheckHardWiredMatchForProcedureActivity(current_procedure_name,sim::State::Done);
            break;
        default:
            break;
        }
    }
    return branch_generated;
}
 
bool ProcedureStep::checkWhetherThisIsAMentalProcedure(string _procedure_name){
    string str;
    bool this_is_a_mental_procedure = false;
    if (_procedure_name.size() >= 5){
        str = _procedure_name.substr(0, 5);
        if(str == "MPBG_") this_is_a_mental_procedure = true;
    }
    return this_is_a_mental_procedure;
}
 
double ProcedureStep::calculateProcedureStepStaticHEPMultiplier(){
    double multiplier = 1.0;
    //
    // determine HEP multiplier based on procedure type
    switch(this->getProcedureType()) { 
    case sim::Proc::NOP:
        multiplier *= g_sim.All_procedure.getNormalProcedureMultiplier();
        break;
    case sim::Proc::AOP:
        multiplier *= g_sim.All_procedure.getAbnormalProcedureMultiplier();
        break;
    case sim::Proc::EOP:
        multiplier *= g_sim.All_procedure.getOptimalRecoveryProcedureMultiplier();
        break;
    case sim::Proc::FRG:
        multiplier *= g_sim.All_procedure.getFunctionalRecoveryProcedureMultipler();
        break;
    case sim::Proc::ECA:
        multiplier *= g_sim.All_procedure.getFunctionalRecoveryProcedureMultipler();
        break;
    case sim::Proc::MentalProcedure:
        multiplier *= g_sim.All_procedure.getMentalProcedureMultiplier();
        break;
    default:
        multiplier *= 1.0;
        ofstream fout("err messages.txt", ios::app);
        cout << "      " << r5pars_.timesno << "  ProcedureStep::calculateProcedureStepStaticHEPMultiplier: Unrecognized Procedure Type in " << current_procedure_name << ' ' << current_step_name << endl;
        fout << r5pars_.timesno << "  ProcedureStep::calculateProcedureStepStaticHEPMultiplier: Unrecognized Procedure Type in " << current_procedure_name << ' ' << current_step_name << "\n";
        fout.close();
        break;
    }
    //
    // determine HEP multiplier based on procedure step characteristics
    switch (this->getProcedureStepCharacteristics()) {
    case sim::Proc::ObjectiveRelated:
        multiplier *= g_sim.All_procedure.getObjectiveStepMultiplier();
        break;
    case sim::Proc::PrerequisiteAction:
        multiplier *= g_sim.All_procedure.getPrerequisiteStepMultiplier();
        break;
    case sim::Proc::MonitoringStep:
        multiplier *= g_sim.All_procedure.getMonitoringStepMultiplier();
        break;
    case sim::Proc::VerificationStep:
        multiplier *= g_sim.All_procedure.getVerificationStepMultiplier();
        break;
    case sim::Proc::DiagnosisStep:
        multiplier *= g_sim.All_procedure.getDiagnosisStepMultiplier();
        break;
    default:
        multiplier *= 1.0;
        ofstream fout("err messages.txt", ios::app);
        cout << "      " << r5pars_.timesno << "  ProcedureStep::calculateProcedureStepStaticHEPMultiplier: Unrecognized Step Type in " << current_procedure_name << ' ' << current_step_name << endl;
        fout << r5pars_.timesno << "  ProcedureStep::calculateProcedureStepStaticHEPMultiplier: Unrecognized Step Type in " << current_procedure_name << ' ' << current_step_name << "\n";
        fout.close();
        break;
    }
    //
    // adjust multiplier for step complexity
    if (this->getProcedureStepComplexity() > 1.0) {
        multiplier *= fmin(10.0,this->getProcedureStepComplexity());
    } else {
        multiplier *= fmax(0.1, this->getProcedureStepComplexity());
    }
    //
    return multiplier;
}
 
void ProcedureStep::setBranchControlFlag(int n){branch_control_flag = n;}
int ProcedureStep::getBranchControlFlag(){return branch_control_flag;}
 
void ProcedureStep::saveProcedureStepToFile(ofstream &fout){
    int i , num;
    fout << current_procedure_name         << ' ' << current_step_name         << ' ' 
         << next_procedure_name            << ' ' << next_step_name            << ' ' 
         << description                    << ' ' << branch_control_flag       << ' ' 
         << procedure_step_characteristics << ' ' << procedure_step_complexity << ' '
         << procedure_type                 << '\n';
    num = this->procedure_step_unit.size();
    fout << num << '\n';
    for(i = 0; i < num; i++){
        this->procedure_step_unit.at(i)->saveProcedureStepUnitToFile(fout);
    }
    this->saveStateOfActivationToFile(fout);
}
void ProcedureStep::retrieveProcedureStepFromFile(ifstream &fin){
    int i, num;
    fin >> current_procedure_name >> current_step_name
        >> next_procedure_name    >> next_step_name;
    this->readDescriptionFromFile(fin);
    fin >> branch_control_flag       >> procedure_step_characteristics
        >> procedure_step_complexity >> procedure_type;
    fin >> num;
    for(i = 0; i < num; i++){
        auto procedure_step_unit_pt = make_unique<ProcedureStepUnit>();
        procedure_step_unit_pt->retrieveProcedureStepUnitFromFile(fin);
        procedure_step_unit.push_back(std::move(procedure_step_unit_pt));
    }
    this->retrieveStateOfActivationFromFile(fin);
}