AlarmParameter.cpp

Go to the documentation of this file.

// AlarmParameter.cpp: implementation of the AlarmParameter class.
//
 
#include "AlarmParameter.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>
BOOST_CLASS_EXPORT_IMPLEMENT(AlarmParameter)
using namespace std;
 
 
// Construction/Destruction
 
AlarmParameter::AlarmParameter()
{
    this->setTypeOfAlarm(DisplayType::AlarmParameter);
    threshold_value_that_activate_the_alarm = -9999.0;
    relational_operator_to_activate_the_alarm = sim::State::Unknown;
}
 
AlarmParameter::~AlarmParameter()
{
 
}
void AlarmParameter::readInfoFromFile(ifstream &fin){
    string str;
    AlarmControlPanelUnit::readInfoFromFile(fin);
    fin >> str >> threshold_value_that_activate_the_alarm;
 
    if (str == "GT") {
        relational_operator_to_activate_the_alarm = sim::Compare::GT;
    }
    else if(str == "GE"){
        relational_operator_to_activate_the_alarm = sim::Compare::GE;
    }
    else if(str == "EQ"){
        relational_operator_to_activate_the_alarm = sim::Compare::EQ;
    }
    else if(str == "LE"){
        relational_operator_to_activate_the_alarm = sim::Compare::LE;
    }
    else if(str == "LT"){
        relational_operator_to_activate_the_alarm = sim::Compare::LT;
    }
    else{
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("AlarmParameter::readInfoFromFile err");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::NoKB);
        ofstream fout("err messages.txt", ios::app);
        cout << "AlarmParameter::readInfoFromFile: Alarm " << this->getAlarmName() << " its relational operator " 
            << str << " can not be recognized!" << endl;
        fout << r5pars_.timesno << "  AlarmParameter::readInfoFromFile: Alarm " << this->getAlarmName() << " its relational operator " 
            << str << " can not be recognized!\n";
        fout.close();
    }
}
void AlarmParameter::setThresholdValueThatActivateTheAlarm(double x){threshold_value_that_activate_the_alarm = x;}
void AlarmParameter::setRelationalOperatorToActivateTheAlarm(int n){relational_operator_to_activate_the_alarm = n;}
double AlarmParameter::getThresholdValueThatActivateTheAlarm(){return threshold_value_that_activate_the_alarm;}
int AlarmParameter::getRelationalOperatorToActivateTheAlarm(){return relational_operator_to_activate_the_alarm;}
int AlarmParameter::updateDisplayedAlarmState(ControlPanelDisplay &_cp){
    DisplayParameterValue *dpv_ptr;
    SystemDisplay *d_element;
    double parameter_value;
    int ctrl_state;
    d_element = 0;
    if(this->getPtrToCorrespondingIndicator() == 0){
        this->setPtrToCorrespondingIndicator((SystemDisplay *) _cp.getDisplayFromMap(this->getCorrespondingIndicatorName()));
    }
    if (this->getPtrToCorrespondingIndicator() != 0){
        ctrl_state = this->getDisplayedOperatorControlState();
        dpv_ptr = (DisplayParameterValue *) this->getPtrToCorrespondingIndicator();
        if(this->getFuncationalState() == sim::State::Succeed){
            parameter_value = dpv_ptr->getDisplayedParameterValue();
            if(ctrl_state == sim::State::Off){
                this->setDisplayedAlarmState(sim::State::Off);
            }
            else if(ctrl_state == sim::State::Auto){
                switch(relational_operator_to_activate_the_alarm){
                case sim::Compare::GT:
                    if(parameter_value > threshold_value_that_activate_the_alarm){
                        this->setDisplayedAlarmState(sim::State::On);
                        this->setTimeAtWhichThisAlarmIsActivated(r5pars_.timesno);
                    }
                    break;
                case sim::Compare::GE:
                    if(parameter_value >= threshold_value_that_activate_the_alarm){
                        this->setDisplayedAlarmState(sim::State::On);
                        this->setTimeAtWhichThisAlarmIsActivated(r5pars_.timesno);
                    }
                    break;
                case sim::Compare::EQ:
                    if(parameter_value == threshold_value_that_activate_the_alarm){
                        this->setDisplayedAlarmState(sim::State::On);
                        this->setTimeAtWhichThisAlarmIsActivated(r5pars_.timesno);
                    }
                    break;
                case sim::Compare::LE:
                    if(parameter_value <= threshold_value_that_activate_the_alarm){
                        this->setDisplayedAlarmState(sim::State::On);
                        this->setTimeAtWhichThisAlarmIsActivated(r5pars_.timesno);
                    }
                    break;
                case sim::Compare::LT:
                    if(parameter_value < threshold_value_that_activate_the_alarm){
                        this->setDisplayedAlarmState(sim::State::On);
                        this->setTimeAtWhichThisAlarmIsActivated(r5pars_.timesno);
                    }
                    break;
                default:
                    r5pars_.sim_err = true;
                    g_sim.Branch_center.setTempESMessage("AlarmParameter::updateDisplayedAlarmState err");
                    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
                    ofstream fout("err messages.txt", ios::app);
                    cout << "AlarmParameter::updateDisplayedAlarmState: Alarm " << this->getAlarmName() << " its relational operator " 
                        << relational_operator_to_activate_the_alarm << " can not be recognized!" << endl;
                    fout << r5pars_.timesno << "  AlarmParameter::updateDisplayedAlarmState: Alarm " << this->getAlarmName() << " its relational operator " 
                        << relational_operator_to_activate_the_alarm << " can not be recognized!\n";
                    fout.close();
                    break;
                }
            }
            else if (ctrl_state == sim::State::Reset){
                switch(relational_operator_to_activate_the_alarm){
                case sim::Compare::GT:
                    if(parameter_value > threshold_value_that_activate_the_alarm){
                        this->setDisplayedAlarmState(sim::State::On);
                        this->setTimeAtWhichThisAlarmIsActivated(r5pars_.timesno);
                    }
                    //  allow alarm reset
                    else{
                        this->setDisplayedAlarmState(sim::State::Off);
                    }
                    break;
                case sim::Compare::GE:
                    if(parameter_value >= threshold_value_that_activate_the_alarm){
                        this->setDisplayedAlarmState(sim::State::On);
                        this->setTimeAtWhichThisAlarmIsActivated(r5pars_.timesno);
                    }
                    else{
                        this->setDisplayedAlarmState(sim::State::Off);
                    }
                    break;
                case sim::Compare::EQ:
                    if(parameter_value == threshold_value_that_activate_the_alarm){
                        this->setTimeAtWhichThisAlarmIsActivated(r5pars_.timesno);
                        this->setDisplayedAlarmState(sim::State::On);
                    }
                    else{
                        this->setDisplayedAlarmState(sim::State::Off);
                    }
                    break;
                case sim::Compare::LE:
                    if(parameter_value <= threshold_value_that_activate_the_alarm){
                        this->setDisplayedAlarmState(sim::State::On);
                        this->setTimeAtWhichThisAlarmIsActivated(r5pars_.timesno);
                    }
                    else{
                        this->setDisplayedAlarmState(sim::State::Off);
                    }
                    break;
                case sim::Compare::LT:
                    if(parameter_value < threshold_value_that_activate_the_alarm){
                        this->setDisplayedAlarmState(sim::State::On);
                        this->setTimeAtWhichThisAlarmIsActivated(r5pars_.timesno);
                    }
                    else{
                        this->setDisplayedAlarmState(sim::State::Off);
                    }
                    break;
                default:
                    r5pars_.sim_err = true;
                    g_sim.Branch_center.setTempESMessage("AlarmParameter::updateDisplayedAlarmState err");
                    g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
                    ofstream fout("err messages.txt", ios::app);
                    cout << "AlarmParameter::updateDisplayedAlarmState: Alarm " << this->getAlarmName() << " its relational operator " 
                        << relational_operator_to_activate_the_alarm << " can not be recognized!" << endl;
                    fout << r5pars_.timesno << "  AlarmParameter::updateDisplayedAlarmState: Alarm " << this->getAlarmName() << " its relational operator " 
                        << relational_operator_to_activate_the_alarm << " can not be recognized!\n";
                    fout.close();
                    break;
                }
            }
            else{}
        }
        else{//alarm fails
            if (ctrl_state == sim::State::Off && this->getDisplayedAlarmState() != sim::State::Off){
                this->setDisplayedAlarmState(sim::State::Off);
            }
            else{
                if (this->getDisplayedAlarmState() != this->getDisplayedAlarmStateWhenFail()){
                    this->setDisplayedAlarmState(this->getDisplayedAlarmStateWhenFail());
                }
            }
        }
    }
    else{
        r5pars_.sim_err = true;
        g_sim.Branch_center.setTempESMessage("AlarmParameter::updateDisplayedAlarmState err");
        g_sim.Branch_center.setTempTypeOfConsequence(Consequence::AdsSimErr);
        ofstream fout("err messages.txt", ios::app);
        cout << "AlarmParameter::updateDisplayedAlarmState: Alarm " << this->getAlarmName() << " its corresponding display " 
            << this->getCorrespondingIndicatorName() << " can not be found!" << endl;
        fout << r5pars_.timesno << "  AlarmParameter::updateDisplayedAlarmState: Alarm " << this->getAlarmName() << " its corresponding display " 
            << this->getCorrespondingIndicatorName() << " can not be found!\n";
        fout.close();
    }
    return this->getDisplayedAlarmState();
}
void AlarmParameter::copyAlarmParameter(AlarmParameter &_ap){
    threshold_value_that_activate_the_alarm = _ap.getThresholdValueThatActivateTheAlarm();
    relational_operator_to_activate_the_alarm = _ap.getRelationalOperatorToActivateTheAlarm();
    AlarmControlPanelUnit::copyAlarmControlPanelUnit(_ap);
}
void AlarmParameter::saveAlarmParameterToFile(ofstream &fout){
    this->saveAlarmControlPanelUnitToFile(fout);
    fout << threshold_value_that_activate_the_alarm << ' '
        << relational_operator_to_activate_the_alarm << '\n';
}
void AlarmParameter::retrieveAlarmParameterFromFile(ifstream &fin){
    this->retrieveAlarmControlPanelUnitFromFile(fin);
    fin >>  threshold_value_that_activate_the_alarm >> relational_operator_to_activate_the_alarm;
}