DiagnosisActionModule.cpp

Go to the documentation of this file.

// DiagnosisActionModule.cpp: implementation of the DiagnosisActionModule class.
//
 
#include "DiagnosisActionModule.h"
#include "Operator.h"
#include "../ControlPanel/ControlPanel.h"
#include <boost/serialization/export.hpp>
#include "../Global/SimulationContext.h"
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(DiagnosisActionModule)
using namespace std;
 
 
// Construction/Destruction
 
DiagnosisActionModule::DiagnosisActionModule()
{
    number_of_diagnoses = 0;
 
}
 
DiagnosisActionModule::~DiagnosisActionModule()
{
    this->clearDiagnosisActionModule();
}
 
void DiagnosisActionModule::clearDiagnosisActionModule()
{
    this->event_list.clear();
}
 
void DiagnosisActionModule::setNumberOfDiagnoses(int n) {number_of_diagnoses = n;}
int DiagnosisActionModule::getNumberOfDiagnoses() {return number_of_diagnoses;}
 
void DiagnosisActionModule::readDiagnosisActionModuleInfoFromFile(string _filename)
{
    string str;
    int i;
    ifstream fin(_filename.c_str(), ios::in);
    if(!fin.is_open()){
        cout << "File: " << _filename <<  " cound not be found" << endl;
        ofstream fout("err messages.txt", ios::app);
        fout << r5pars_.timesno << "  File: " << _filename <<  " cound not be found\n";
        fout.close();
    }
    else {
        fin >> str >> number_of_diagnoses;
        for (i = 0 ; i != number_of_diagnoses ; i++ )
        {
            auto pt = std::make_unique<DiagnosisActionUnit>();
            pt->readDiagnosisActionUnitInfoFromFile(fin);
            this->event_list.push_back(std::move(pt));
        }
        fin.close();
    }
}
 
bool DiagnosisActionModule::onceThroughProcessForReasoningStrategy(Operator &_operator, ShortTermMemory &_stm, EventSymptomMatrix &_diagnosis)
{
    bool branch_generated = false;
    DiagnosisActionUnit *priority_diagnosis = 0;
    DiagnosisComponentActionUnit *action_ptr = 0;
    BranchAction *branch_action = 0;
    MentalParameterValue *mpv_pt = 0;
    SystemControl * sc_ptr = 0;
    ControlValue * control_value_ptr = 0;
    int receiver = sim::Operator::OAT;
    int branch_number;
    double time, delay_time;
    double control_value = 0.0;
    string str;
    if (_operator.getTypeOfOperator() == sim::Operator::OAT) {receiver = sim::Source::Plant;}
    //
    // find high priority diagnosis for action
    priority_diagnosis = this->getPtrToHighPriorityDiagnosisActionUnit(_diagnosis);
    if (priority_diagnosis != 0) {
        branch_generated = priority_diagnosis->setPtrToHighPriorityAction(_operator, _stm);
        if (branch_generated) {
            return branch_generated;
        }
        else if (priority_diagnosis->getActionPrereqsEvaluated()) // no new branch generated - check if all necessary action prerequisistes have been evaluated
        {
            action_ptr = priority_diagnosis->getPriorityActionPtr();
            if (action_ptr != 0)
            {
                //
                if(action_ptr->getPrerequisiteState() == sim::State::Succeed) 
                {
                    // post message for execution of knowledge based action
                    str = "Execute Knowledge Based Action: ";
                    str += action_ptr->getInfoName();
                    branch_number = g_sim.Branch_center.getIDOfRecentGeneratedBranch();
                    g_sim.Command_handler.displayInformation(str);
                    g_sim.Aux_info.addRecord(str,branch_number);
                    //
                    branch_action = new BranchAction;
                    branch_action->setActionName(action_ptr->getInfoName());
                    branch_action->setSenderAndReceiver(_operator.getTypeOfOperator(), receiver);
                    branch_action->setTypeOfPauseActivity(sim::Strategy::InductiveDeductive);
                    //
                    time = 5.0;
                    branch_action->setActionTime(time);
                    branch_action->setTimerAndProbability(time, 1.0 - _operator.hfe_bbn.getDiagnosisFailureProbability());
                    //
                    // determine control value setting for action
                    switch (action_ptr->getActionType()) {
                    //
                    case sim::ControlAction::ParameterControl:
                        mpv_pt = _stm.perceived_info.checkExistanceOfPerceivedParameterValue(action_ptr->getControlParameterName());
                        sc_ptr = g_sim.Indicator.controls.getControlFromMap(action_ptr->getInfoName());
                        if (sc_ptr != 0) {
                            control_value_ptr = (ControlValue *) sc_ptr;
                            if (mpv_pt!= 0 && sc_ptr->getTypeOfControl()==DisplayType::ControlValue)
                            {
                                control_value = mpv_pt->getObservedParameterValue();
                                control_value = fmin(control_value, control_value_ptr->getValueForOnOrFullyOpen());
                                control_value = fmax(control_value, control_value_ptr->getValueForOffOrFullyClose());
                            } 
                            else   // control parameter has not been perceived, do not change control value 
                            {
                                control_value = control_value_ptr->getControlValue();
                                //
                                ofstream fout("err messages.txt", ios::app);
                                cout << "DiagnosisActionModule::onceThroughProcessForReasoningStrategy - Parameter: " << action_ptr->getControlParameterName() << " has not been perceived" << endl;
                                fout << r5pars_.timesno << "  DiagnosisActionModule::onceThroughProcessForReasoningStrategy - Parameter: " << action_ptr->getControlParameterName() << " has not been perceived\n";
                                fout.close();
                            }
                        } else { // control not found on control panel
                            ofstream fout("err messages.txt", ios::app);
                            cout << "DiagnosisActionModule::onceThroughProcessForReasoningStrategy - Control: " << action_ptr->getInfoName() << " can not be recognized" << endl;
                            fout << r5pars_.timesno << "  DiagnosisActionModule::onceThroughProcessForReasoningStrategy - Control: " << action_ptr->getInfoName() << " can not be recognized\n";
                            fout.close();
                            r5pars_.sim_err = true;
                            g_sim.Branch_center.setTempESMessage("DiagnosisActionModule::onceThroughProcessForReasoningStrategy error");
                            g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
                        }
                        break;
                    //
                    case sim::ControlAction::Additive:
                        sc_ptr = g_sim.Indicator.controls.getControlFromMap(action_ptr->getInfoName());
                        if (sc_ptr != 0)
                        {
                            if (sc_ptr->getTypeOfControl()==DisplayType::ControlValue){
                                control_value_ptr = (ControlValue *) sc_ptr;
                                // Displayed control value may differ from actual control value due to perception filtering
                                // control_value = control_value_ptr->getDisplayedControlValue(); 
                                control_value = control_value_ptr->getControlValue();
                                control_value += action_ptr->getControlInput();
                                // verify that control value does not exceeed component control range
                                control_value = fmin(control_value, control_value_ptr->getValueForOnOrFullyOpen());
                                control_value = fmax(control_value, control_value_ptr->getValueForOffOrFullyClose());
                            }
                        } else   // control not found on control panel
                        {                
                            ofstream fout("err messages.txt", ios::app);
                            cout << "DiagnosisActionModule::onceThroughProcessForReasoningStrategy - Control: " << action_ptr->getInfoName() << " can not be recognized" << endl;
                            fout << r5pars_.timesno << "  DiagnosisActionModule::onceThroughProcessForReasoningStrategy - Control: " << action_ptr->getInfoName() << " can not be recognized\n";
                            fout.close();
                            r5pars_.sim_err = true;
                            g_sim.Branch_center.setTempESMessage("DiagnosisActionModule::onceThroughProcessForReasoningStrategy error");
                            g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
                        }
                        break;
                    //
                    case sim::Action::Action:
                        control_value = action_ptr->getControlInput();
                        break;
                    //
                    default:
                        break;
                    }
                    //
                    branch_action->setControlValue(control_value);
                    g_sim.Branch_center.addAction(_operator.getTypeOfOperator(), branch_action);
                    //
                    branch_generated = true;
                    //
                    
                } // end - add action branch
                else 
                {
                    // post message that knowledge based action prereqs not met
                    str = "Prerequisites for Knowledge Based Action: ";
                    str += action_ptr->getInfoName();
                    str += " have not been met.";
                    branch_number = g_sim.Branch_center.getIDOfRecentGeneratedBranch();
                    g_sim.Command_handler.displayInformation(str);
                    g_sim.Aux_info.addRecord(str,branch_number);
                    //
                }
            } // end - high priority action found
            else {
                // reset delay time if no action can be performed
                delay_time = priority_diagnosis->reset_delay_time.calculateMeanRequiredTime();
                priority_diagnosis->reset_delay_time.setRemainingTime(r5pars_.timesno + delay_time);
            }
            priority_diagnosis->resetDiagnosisActionUnit();
        } 
    } // end - high priority diagnosis found
 
    return branch_generated;
}
 
 
DiagnosisActionUnit *DiagnosisActionModule::getPtrToHighPriorityDiagnosisActionUnit(EventSymptomMatrix &_diagnosis)
{
    DiagnosisActionUnit *priority_diagnosis = nullptr;
    bool diagnosis_found = false;
    int highest_priority = 100;
    double event_confidence;
    double delay_time;
    double highest_confidence = 0.5;
    //
    // determine if there is a currently active diagnosis
    auto diagnosis_itr = this->event_list.begin();
    while (diagnosis_itr != event_list.end() && !diagnosis_found) {
        if ((*diagnosis_itr)->getStateOfActivation() == sim::State::Active)
        {
            priority_diagnosis = diagnosis_itr->get();
            diagnosis_found = true;
        }
        else {
            diagnosis_itr++;
        }
    }
    // if there is no active diagnosis, search for new diagnosis
    if (!diagnosis_found)
    {
        for (auto& elem : event_list)
        {
            event_confidence = _diagnosis.getEventRationalConfidence(elem->getDiagnosisName());
            if ( event_confidence > highest_confidence &&
                 elem->reset_delay_time.getRemainingTime() < r5pars_.timesno &&
                 elem->getDiagnosisPriority() < highest_priority )
            {
                if (elem->action_list.size() > 0) {
                    priority_diagnosis = elem.get();
                    highest_confidence = event_confidence;
                    highest_priority = elem->getDiagnosisPriority();
                }
            }
        }
        if (priority_diagnosis) {
            priority_diagnosis->setStateOfActivation(sim::State::Active);
            delay_time = priority_diagnosis->reset_delay_time.calculateMeanRequiredTime();
            priority_diagnosis->reset_delay_time.setRemainingTime(r5pars_.timesno + delay_time);
        }
    }
    return priority_diagnosis;
}
 
void DiagnosisActionModule::copyDiagnosisActionModule(DiagnosisActionModule &_dam)
{
    number_of_diagnoses = _dam.getNumberOfDiagnoses();
    for (auto& src : _dam.event_list)
    {
        auto pt = std::make_unique<DiagnosisActionUnit>();
        pt->copyDiagnosisActionUnit(*src);
        event_list.push_back(std::move(pt));
    }
}
 
void DiagnosisActionModule::saveDiagnosisActionModuleToFile(ofstream &fout)
{
    fout << "DiagnosisActionUnit"   << '\n';
    fout << number_of_diagnoses     << '\n';
    for(auto& elem : this->event_list)
    {
        elem->saveDiagnosisActionUnitToFile(fout);
    }
}
 
void DiagnosisActionModule::retreiveDiagnosisActionModuleFromFile(ifstream &fin)
{
    int i;
    string str;
    fin >> str;
    fin >> number_of_diagnoses;
    for ( i = 0 ; i < number_of_diagnoses ; i++ )
    {
        auto pt = std::make_unique<DiagnosisActionUnit>();
        pt->retreiveDiagnosisActionUnitFromFile(fin);
        this->event_list.push_back(std::move(pt));
    }
}