EventSymptomMatrix.cpp

Go to the documentation of this file.

// EventSymptomMatrix.cpp: implementation of the EventSymptomMatrix class.
//
 
#include "EventSymptomMatrix.h"
#include "KBHardWiredUnit.h"
#include "../Branch/BranchRecord.h"
#include <boost/serialization/export.hpp>
#include "../Global/SimulationContext.h"
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <cstdint>
#include <stdexcept>
BOOST_CLASS_EXPORT_IMPLEMENT(EventSymptomMatrix)
using namespace std;
 
void EventSymptomMatrix::state_save(boost::archive::binary_oarchive& ar) const {
    const uint32_t n_sym = static_cast<uint32_t>(symptoms.size());
    const uint32_t n_evt = static_cast<uint32_t>(events.size());
    ar << abnormal_confidence << n_sym << n_evt;
    for (const auto& s : symptoms) { const double c = s->getConfidence(); ar << c; }
    for (const auto& e : events)   { const double c = e->getConfidence(); ar << c; }
}
void EventSymptomMatrix::state_load(boost::archive::binary_iarchive& ar) {
    uint32_t n_sym = 0, n_evt = 0;
    ar >> abnormal_confidence >> n_sym >> n_evt;
    if (n_sym != symptoms.size() || n_evt != events.size())
        throw std::runtime_error("EventSymptomMatrix state overlay: unit counts mismatch against the seeded matrix");
    double c = 0.0;
    for (auto& s : symptoms) { ar >> c; s->setConfidence(c); }
    for (auto& e : events)   { ar >> c; e->setConfidence(c); }
}
 
 
// Construction/Destruction
 
EventSymptomMatrix::EventSymptomMatrix()
{
    num_symptom = 0;
    num_event = 0;
    abnormal_confidence = 0.0;
}
 
EventSymptomMatrix::~EventSymptomMatrix()
{
    clearEventSymptomMatrix();
}
void EventSymptomMatrix::clearEventSymptomMatrix()
{
    num_symptom = 0;
    num_event = 0;
    abnormal_confidence = 0.0;
    symptoms.clear();
    events.clear();
}
void EventSymptomMatrix::setNumSymptom(int n){num_symptom = n;}
void EventSymptomMatrix::setNumEvent(int n){num_event = n;}
void EventSymptomMatrix::setAbnormalConfidence(double x) {abnormal_confidence = x;}
int EventSymptomMatrix::getNumSymptom(){return num_symptom;}
int EventSymptomMatrix::getNumEvent(){return num_event;}
double EventSymptomMatrix::getAbnormalConfidence() {return abnormal_confidence;}
void EventSymptomMatrix::readInfoFromFile(string _file_name){
    string str;
    int i;
 
    ifstream fin(_file_name.c_str(), ios::in);
    if(!fin.is_open()){
        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_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("SPDS::readInfoFromFile err.");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
    }
    else {
        fin >> str >> num_symptom;
        for(i = 0; i < num_symptom; i++){
            auto symptoms_ptr = make_unique<SymptomUnit>();
            symptoms_ptr->readInfoFromFile(fin);
            symptoms.push_back(std::move(symptoms_ptr));
        }
        fin >> str >> num_event;
        for(i = 0; i < num_event; i++){
            auto events_ptr = make_unique<DiagnosisEventUnit>();
            events_ptr->readInfoFromFile(num_symptom, fin);
            events.push_back(std::move(events_ptr));
        }
        fin.close();
    }
}
 
 
void EventSymptomMatrix::updateRationalSymptomConfidence(KB &_kb){
    bool found_hwd;
    double x;
    decltype(_kb.hard_wired_diagnosis)::iterator hwd_itr;//hard_wired_diagnosis;
    string symptom_name;
    for(auto& symptom : symptoms){
        symptom_name = symptom->getSymptomName();
        found_hwd = false;
        hwd_itr = _kb.hard_wired_diagnosis.begin();
        do{
            if(symptom_name == (*hwd_itr)->getInfoName()){//found symptom
                found_hwd = true;
                // get symptom confidence from hardwired diagnosis and convert from percent to probability
                x = ((*hwd_itr)->getConfidenceLevel());
                symptom->setConfidence(x);
            }
            else{
                hwd_itr++;
            }
        }while(!found_hwd && hwd_itr != _kb.hard_wired_diagnosis.end());
        if(!found_hwd){//could not find the symptom
            //error message
            ofstream fout("err messages.txt", ios::app);
            cout << "EventSymptomMatrix::updateRationalSymptomConfidence symptom: " << symptom_name << " could not be found." << endl;
            fout << r5pars_.timesno << "  EventSymptomMatrix::updateRationalSymptomConfidence symptom: " << symptom_name    << " could not be found.\n";
            fout.close();
            r5pars_.sim_err = true;
            g_sim.Branch_center.setTempESMessage("EventSymptomMatrix::updateRationalSymptomConfidence err.");
            g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
        }
    }
}
void EventSymptomMatrix::updateRationalEventConfidence(){
    DiagnosisEventUnit *events_pt;
    int i, j, num_perceived_symptoms, num_symptoms_explained;
    double x,symptom_confidence, relationship_value, upper, lower, correction;
    //abnormal_confidence = 0.0;
    num_perceived_symptoms = 0;
    for (i=0;i<symptoms.size();i++) {
        if (symptoms.at(i)->getConfidence() > 0.1) {
            num_perceived_symptoms = num_perceived_symptoms + 1;
        }
    }
    for(j = 0; j < events.size(); j++){
        upper = 1.0;
        lower = 1.0;
        num_symptoms_explained = 0;
        events_pt = events.at(j).get();
        for(i = 0; i < symptoms.size(); i++){
            symptom_confidence = symptoms.at(i)->getConfidence();
            relationship_value = events_pt->symptom_event_relationship.at(i);
            if ((relationship_value * symptom_confidence ) > 0.01) {
                num_symptoms_explained = num_symptoms_explained + 1;
            }
            upper = fmin(upper, fmax(0.0, fmin(1.0, symptom_confidence + 1.0 - relationship_value)));
            if(relationship_value > 0.0001){
                x = 1.0;
            }
            else{
                x = 0.0;
            }
//          x = (relationship_value > 0.0001 );
            if (x > symptom_confidence) {
                lower = fmin(lower, symptom_confidence);
            }
        }
        if (events_pt->getCategoryName() != "Imbalance") {
            correction = num_symptoms_explained / (num_perceived_symptoms + 0.0001);
        } else {
            correction = 1.0;
        }
        events_pt->setLowerBound(lower);
        events_pt->setUpperBound(upper);
        events_pt->setConfidence((lower + upper) * correction /2.0);
        // update overall plant assessment
        if (events_pt->getCategoryName() == "DBA" || events_pt->getCategoryName() == "AOO") {
            abnormal_confidence = fmax(abnormal_confidence, events_pt->getConfidence());
        }
    }
}
 
double EventSymptomMatrix::getEventRationalConfidence(string _str) {
    bool found = false;
    double confidence = 0.0;
    if (_str == "Not_Applicable")
    {
        confidence = 1.0;
    } else {
        auto event_itr = this->events.begin();
        while (event_itr != this->events.end() && ! found) {
            if ((*event_itr)->getDiagnosisName() == _str) {
                found = true;
                confidence = (*event_itr)->getConfidence();
            }
            else {
                event_itr ++;
            }
        }
        if(!found) {   //could not find a match to the requested event
                //error message
                ofstream fout("err messages.txt", ios::app);
                cout << "EventSymptomMatrix::getEventRationalConfidence: " << _str  << " could not be found." << endl;
                fout << r5pars_.timesno << "  EventSymptomMatrix::getEventRationalConfidence: " << _str << " could not be found.\n";
        }
    } 
    return confidence;  
}
 
void EventSymptomMatrix::updatePerceivedSymptomConfidence(){
}
void EventSymptomMatrix::updatePerceivedEventConfidence(){
}
 
void EventSymptomMatrix::updateBothRationalConfidence(KB &_kb){
    this->updateRationalSymptomConfidence(_kb);
    this->updateRationalEventConfidence();
}
 
void EventSymptomMatrix::outputEventSymptomMatrixLabelToFile(string _str, ofstream &fout){
    int i;
    string str1;
    for(i = 0; i < symptoms.size(); i++){
        str1 = _str + symptoms.at(i)->getSymptomName();
        fout << '\t' << str1;
    }
    for(i = 0; i < events.size(); i++){
        str1 = _str + events.at(i)->getDiagnosisName();
        fout << '\t' << str1;
//          << '\t' << str1
//          << '\t' << str1;
    }
}
 
void EventSymptomMatrix::outputEventSymptomMatrixUnitToFile(ofstream &fout){
    int i;
    for(i = 0; i < symptoms.size(); i++){
        fout << "\tConfidence";
    }
    for(i = 0; i < events.size(); i++){
//      fout << "\tConfidence\tLower_B\tUpper_B";
        fout << "\tConfidence";
    }
}
 
void EventSymptomMatrix::copyEventSymptomMatrix(EventSymptomMatrix& _esm){
    num_symptom = _esm.getNumSymptom();
    num_event = _esm.getNumEvent();
    abnormal_confidence = _esm.getAbnormalConfidence();
    for(auto& src : _esm.symptoms){
        auto symptoms_pt = make_unique<SymptomUnit>();
        symptoms_pt->copySymptomUnit(*src);
        this->symptoms.push_back(std::move(symptoms_pt));
    }
    for(auto& src : _esm.events){
        auto events_pt = make_unique<DiagnosisEventUnit>();
        events_pt->copyDiagnosisEventUnit(*src);
        this->events.push_back(std::move(events_pt));
    }
}
 
void EventSymptomMatrix::saveEventSymptomMatrixToFile(ofstream &fout){
    fout << "EventSymptomMatrix "
        << num_symptom << ' '
        << num_event << ' '
        << abnormal_confidence << ' '
        << symptoms.size() << ' '
        << events.size() << '\n';
    for(auto& symptom : symptoms){
        symptom->saveSymptomUnitToFile(fout);
    }
    for(auto& event : events){
        event->saveDiagnosisEventUnitToFile(fout);
    }
}
 
void EventSymptomMatrix::retrieveEventSymptomMatrixFromFile(ifstream &fin){
    int tn_symptom, tn_event, i;
    string str;
    fin >> str
        >> num_symptom
        >> num_event
        >> abnormal_confidence
        >> tn_symptom
        >> tn_event;
    if (str != "EventSymptomMatrix"){
            ofstream fout("err messages.txt", ios::app);
            cout << "EventSymptomMatrix::retrieveEventSymptomMatrixFromFile retrieval error in previous function" << endl;
            fout << r5pars_.timesno << "  EventSymptomMatrix::retrieveEventSymptomMatrixFromFile error in previous function\n";
            fout.close();
            r5pars_.sim_err = true;
            g_sim.Branch_center.setTempESMessage("EventSymptomMatrix::retrieveEventSymptomMatrixFromFile Prior err.");
            g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
            return;
    }
    for(i = 0; i < tn_symptom; i++){
        auto symptoms_pt = make_unique<SymptomUnit>();
        symptoms_pt->retrieveSymptomUnitFromFile(fin);
        this->symptoms.push_back(std::move(symptoms_pt));
    }
    for(i = 0; i < tn_event; i++){
        auto events_pt = make_unique<DiagnosisEventUnit>();
        events_pt->retrieveDiagnosisEventUnitFromFile(fin);
        this->events.push_back(std::move(events_pt));
    }
}