DiagnosisActionUnit.cpp

Go to the documentation of this file.

// DiagnosisActionUnit.cpp: implementation of the DiagnosisActionUnit class.
//
 
#include "DiagnosisActionUnit.h"
#include "../ControlPanel/ControlPanel.h"
#include "../Global/SimulationContext.h"
using namespace std;
 
 
// Construction/Destruction
 
DiagnosisActionUnit::DiagnosisActionUnit()
{
    diagnosis_priority = -999;
    diagnosis_name = "NONE";
    priority_action_ptr = nullptr;
    action_prereqs_evaluated = true;
}
 
DiagnosisActionUnit::~DiagnosisActionUnit()
{
    this->clearDiagnosisActionUnit();
}
 
void DiagnosisActionUnit::clearDiagnosisActionUnit()
{
    action_list.clear();
}
 
void DiagnosisActionUnit::setDiagnosisName(string _name) {diagnosis_name = _name;}
string DiagnosisActionUnit::getDiagnosisName() {return diagnosis_name;}
void DiagnosisActionUnit::setDiagnosisPriority(int n) {diagnosis_priority = n;}
int DiagnosisActionUnit::getDiagnosisPriority() {return diagnosis_priority;}
void DiagnosisActionUnit::setActionPrereqsEvaluated(bool log) {action_prereqs_evaluated = log;}
bool DiagnosisActionUnit::getActionPrereqsEvaluated() {return action_prereqs_evaluated;}
 
DiagnosisComponentActionUnit *DiagnosisActionUnit::getPriorityActionPtr() {return priority_action_ptr;}
 
void DiagnosisActionUnit::readDiagnosisActionUnitInfoFromFile(ifstream &fin)
{
    string str;
    double t_min, alpha, beta;
    int i, num_actions;
    fin >>  str  >> diagnosis_name;
    fin >>  str  >> diagnosis_priority;
    fin >>  str  >> t_min >> alpha >> beta;
    this->reset_delay_time.setT_Minimum(t_min);
    this->reset_delay_time.setAlpha_Weibull(alpha);
    this->reset_delay_time.setBeta_Weibull(beta);
    //
    fin >>  str  >> num_actions;
    for (i = 0 ; i < num_actions ; i++)
    {
        auto comp_action_ptr = make_unique<DiagnosisComponentActionUnit>();
        comp_action_ptr->readDiagnosisComponentActionUnitInfoFromFile(fin);
        this->action_list.push_back(std::move(comp_action_ptr));
    }
 
}
 
bool DiagnosisActionUnit::setPtrToHighPriorityAction(Operator &_operator, ShortTermMemory &_stm)
{
    auto comp_action_itr = this->action_list.begin();
    //DecisionAction *perceived_action_ptr = 0;
    SystemControl *system_control_ptr = 0;
    MentalParameterValue *mental_value_ptr = 0;
    bool branch_generated = false;
    bool evaluate_prereqs;
    bool no_prereqs;
    bool control_at_limit;
    bool control_failed;
    bool found_action_prereq = false;
    double current_control_value, new_control_value;
    int highest_priority = 100;
    int prereq_state;
    string str;
    this->priority_action_ptr = nullptr;
    this->setActionPrereqsEvaluated(true);
    //
    comp_action_itr = this->action_list.begin();
    while (comp_action_itr != this->action_list.end() && !branch_generated && !found_action_prereq)
    {
        //
        if( (*comp_action_itr)->getPriority() < highest_priority) {
            //
            // determine if control input will exceed high or low limits or if control has failed
            control_at_limit = false;
            control_failed = false;
            //perceived_action_ptr = _stm.perceived_info.checkExistanceOfAction((*comp_action_itr)->getInfoName());
            system_control_ptr = g_sim.Indicator.controls.getControlFromMap((*comp_action_itr)->getInfoName());
            if (system_control_ptr != 0) {
                //
                // determine if new control value will exceed high or low limit
                //current_control_value = perceived_action_ptr->getPerceivedControlValue();
                current_control_value = system_control_ptr->getControlValue();
                switch ((*comp_action_itr)->getActionType()) {
                case sim::ControlAction::Additive:
                    new_control_value = current_control_value + (*comp_action_itr)->getControlInput();
                    if (new_control_value < (*comp_action_itr)->getLowerLimit() ||
                        new_control_value > (*comp_action_itr)->getUpperLimit() ||
                        fabs(new_control_value - current_control_value) < 0.0001   ) {
                        control_at_limit = true;
                    }
                    break;
                case sim::ControlAction::ParameterControl:
                    mental_value_ptr = _stm.perceived_info.checkExistanceOfPerceivedParameterValue((*comp_action_itr)->getControlParameterName());
                    if (mental_value_ptr != 0 ) {
                        new_control_value = mental_value_ptr->getObservedParameterValue();
                        if (new_control_value < (*comp_action_itr)->getLowerLimit() ||
                            new_control_value > (*comp_action_itr)->getUpperLimit() ||
                            fabs(new_control_value - current_control_value) < 0.0001   ) {
                            control_at_limit = true;
                        }
                    }
                    break;
                case sim::Action::Action:
                    new_control_value = (*comp_action_itr)->getControlInput();
                    if (new_control_value <  (*comp_action_itr)->getLowerLimit() ||
                        new_control_value >  (*comp_action_itr)->getUpperLimit() ||
                        fabs(new_control_value - current_control_value) < 0.0001    ) {
                        control_at_limit = true;
                    }
                    break;
                case sim::State::Control:
                    break;
                default:
                    break;
                }
            }
            if (system_control_ptr->getFunctionalState() == sim::State::FailedP) 
            {
                control_failed = true;
            }
            //
            if(!control_at_limit && !control_failed) {
                //
                if ((*comp_action_itr)->action_prerequisites.size() == 0  ) {
                    no_prereqs = true; 
                } else {
                    no_prereqs = false;
                }
                prereq_state = (*comp_action_itr)->getPrerequisiteState();
                if (!no_prereqs && (prereq_state == sim::None || prereq_state == sim::State::Active)) 
                {
                    evaluate_prereqs = true;
                    found_action_prereq = true;
                    this->setActionPrereqsEvaluated(false);
                } else {
                    evaluate_prereqs = false;
                }
                //
                if(evaluate_prereqs) {
                    //
                    if ((*comp_action_itr)->getPrerequisiteState() == sim::None) {
                        // post message for for the prerequisite evaluation
                        str = "Evaluate Action Prerequisites for diagnosis (";
                        str += this->getDiagnosisName();
                        str += ") action (";
                        str += (*comp_action_itr)->getInfoName();
                        str += ")";
                        g_sim.Command_handler.displayInformation(str);
                        g_sim.Aux_info.addRecord(str,g_sim.Branch_center.getIDOfRecentGeneratedBranch());
                        //
                    }
                    (*comp_action_itr)->setPrerequisiteState(sim::State::Active);
                    branch_generated = (*comp_action_itr)->assessPrerequisites(_operator, _stm, sim::Strategy::InductiveDeductive); 
                    if (branch_generated) {
                        return branch_generated;
                    }
                } else if (no_prereqs || prereq_state == sim::State::Succeed){
                    highest_priority = (*comp_action_itr)->getPriority();
                    priority_action_ptr = (*comp_action_itr).get();
                }
            }
        }
        comp_action_itr++;
    }
    return branch_generated;
}
 
void DiagnosisActionUnit::resetDiagnosisActionUnit()
{
    this->setStateOfActivation(sim::None);
    for (auto& action_item : this->action_list){
        action_item->resetComponentActionUnit();
    }
}
 
void DiagnosisActionUnit::copyDiagnosisActionUnit(DiagnosisActionUnit &_dau)
{
    diagnosis_name = _dau.getDiagnosisName();
    diagnosis_priority = _dau.getDiagnosisPriority();
    action_prereqs_evaluated = _dau.getActionPrereqsEvaluated();
    this->reset_delay_time.copyTimer(_dau.reset_delay_time);
    this->copyStateOfActivation(_dau);
    for (auto& src : _dau.action_list)
    {
        auto action_unit_ptr = make_unique<DiagnosisComponentActionUnit>();
        action_unit_ptr->copyDiagnosisComponentActionUnit(*src);
        this->action_list.push_back(std::move(action_unit_ptr));
    }
}
 
void DiagnosisActionUnit::saveDiagnosisActionUnitToFile(ofstream &fout)
{
    int num_actions;
    int action_prereqs_flag = 0;
    fout << diagnosis_name << ' ' << diagnosis_priority << '\n';
    if (action_prereqs_evaluated) {action_prereqs_flag = 1;}
    fout << action_prereqs_flag    << '\n';
    this->reset_delay_time.saveTimerToFile(fout);
    this->saveStateOfActivationToFile(fout);
    num_actions = this->action_list.size();
    fout << num_actions << '\n';
    for (auto& action_unit : action_list)
    {
        action_unit->saveDiagnosisComponentActionUnitToFile(fout);
    }
}
 
void DiagnosisActionUnit::retreiveDiagnosisActionUnitFromFile(ifstream &fin)
{
    int i, num_actions;
    int action_prereqs_flag;
    //
    fin >> diagnosis_name >> diagnosis_priority;
    fin >> action_prereqs_flag;
    if (action_prereqs_flag == 1) {
        action_prereqs_flag = true;
    } else {
        action_prereqs_flag = false;
    }
    this->reset_delay_time.retrieveTimerFromFile(fin);
    this->retrieveStateOfActivationFromFile(fin);
    fin >> num_actions;
    for ( i = 0 ; i < num_actions ; i++)
    {
        auto action_unit_ptr = make_unique<DiagnosisComponentActionUnit>();
        action_unit_ptr->retrieveDiagnosisComponentActionUnitFromFile(fin);
        this->action_list.push_back(std::move(action_unit_ptr));
    }
}