PassiveAlarmLoadUnit.cpp

Go to the documentation of this file.

// PassiveAlarmLoadUnit.cpp: implementation of the PassiveAlarmLoadUnit class.
//
 
#include "PassiveAlarmLoadUnit.h"
using namespace std;
 
// Construction/Destruction
 
PassiveAlarmLoadUnit::PassiveAlarmLoadUnit()
{
    this->m_stack_size = 36;
    this->m_alarm_capacity = 3;
}
 
PassiveAlarmLoadUnit::~PassiveAlarmLoadUnit()
{
 
}
 
void PassiveAlarmLoadUnit::AddNewDataPoint(int n)
{
    vector<int>::iterator int_itr;
    vector<float>::iterator fl_itr;
    int_itr = this->m_No_of_alarms_history.begin();
    fl_itr = this->m_alarm_time_history.begin();
 
    this->m_No_of_alarms_history.insert(int_itr, n);
    this->m_alarm_time_history.insert(fl_itr, r5pars_.timesno);
 
    if(this->m_No_of_alarms_history.size() != this->m_alarm_time_history.size())
    {this->ErrorMessage("m_No_of_alarms_history does not the size of m_alarm_time_history");}
 
    this->PopBackIfNecessary();
    this->UpdatePassiveAlarmLoadValue();
}
 
 
void PassiveAlarmLoadUnit::PopBackIfNecessary()
{
    if(this->m_No_of_alarms_history.size() != this->m_alarm_time_history.size())
    {this->ErrorMessage("m_No_of_alarms_history does not the size of m_alarm_time_history");}
 
    while(this->m_No_of_alarms_history.size() > this->m_stack_size)
    {
        this->m_No_of_alarms_history.pop_back();
        this->m_alarm_time_history.pop_back();
    }
}
 
float PassiveAlarmLoadUnit::GetAlarmLoadValue()
{
    return this->m_alarm_load_value;
}
 
void PassiveAlarmLoadUnit::UpdatePassiveAlarmLoadValue()
{
    float denominator = 0;
    float numerator = 0;
    float time = r5pars_.timesno;
    bool add_to_timeline = false;
    ValueTimeLineUnit * vtu_pt;
    int i;
    
    vector<int>::iterator int_itr;
    vector<float>::iterator fl_itr;
 
    if(this->m_No_of_alarms_history.size() != this->m_alarm_time_history.size())
    {this->ErrorMessage("m_No_of_alarms_history does not equal to the size of m_alarm_time_history");}
 
    int_itr = this->m_No_of_alarms_history.begin();
    fl_itr = this->m_alarm_time_history.begin();
 
    while(int_itr != this->m_No_of_alarms_history.end())
    {
        numerator += exp(-0.461*(r5pars_.timesno - (*fl_itr))) * (*int_itr) / this->m_alarm_capacity;
        denominator += exp(-0.461* (r5pars_.timesno - (*fl_itr) ) );
        int_itr++;
        fl_itr++;
    }
 
    i = this->m_No_of_alarms_history.size();
    while (i < this->m_stack_size)
    {
        denominator += exp(-0.461 * 0.5*float(i));
        i++;
    }
 
    if(numerator != 0)
    {numerator *= 1;}
    if(denominator == 0)
    {this->m_alarm_load_value = 0;}
    else
    {
        this->m_alarm_load_value = min<float>(numerator/denominator , 1);
    }
    if(this->m_passive_alarm_load_timeline.size() == 0) 
    {
        add_to_timeline = true;
    }
    else
    {
        vtu_pt = this->m_passive_alarm_load_timeline.rbegin()->get();
        if(vtu_pt->m_fl != this->m_alarm_load_value)
        {add_to_timeline = true;}
    }   
}
 
void PassiveAlarmLoadUnit::ErrorMessage(string str)
{
    cout << r5pars_.timesno << "  " << str << " in ReasonMachine.cpp" << '\n';
    ofstream fout("err messages.txt", ios::app);
    fout << r5pars_.timesno << "  " << str << '\n';
    fout.close();
    //r5pars_.terminateall = true;
}
 
void PassiveAlarmLoadUnit::CopyFromAnotherPassiveAlarmLoadUnit(PassiveAlarmLoadUnit * _pau_pt)
{
/*
    int m_alarm_capacity;
    float m_alarm_load_value;
    int m_operator;
    int m_stack_size;
 
    vector<int> m_No_of_alarms_history;
    vector<float> m_alarm_time_history;
*/
    vector<int>::iterator int_itr;
    vector<float>::iterator fl_itr;
    ValueTimeLineUnit * v_pt;
 
    this->m_alarm_capacity = _pau_pt->m_alarm_capacity;
    this->m_alarm_load_value = _pau_pt->m_alarm_load_value;
    this->m_operator = _pau_pt->m_operator;
    this->m_stack_size = _pau_pt->m_stack_size;
 
    if(this->m_No_of_alarms_history.size() > 0)
    {this->ErrorMessage("this->m_No_of_alarms_history.size() > 0");}
    if(this->m_alarm_time_history.size() > 0)
    {this->ErrorMessage("this->m_alarm_time_history.size() > 0");}
    if(this->m_passive_alarm_load_timeline.size() > 0)
    {this->ErrorMessage("this->m_passive_alarm_load_timeline.size() > 0");}
 
    for(int_itr = _pau_pt->m_No_of_alarms_history.begin(); int_itr != _pau_pt->m_No_of_alarms_history.end(); int_itr++)
    {
        this->m_No_of_alarms_history.push_back(*int_itr);
    }
    for(fl_itr = _pau_pt->m_alarm_time_history.begin(); fl_itr != _pau_pt->m_alarm_time_history.end(); fl_itr++)
    {
        this->m_alarm_time_history.push_back(*fl_itr);
    }
    for(auto &e : _pau_pt->m_passive_alarm_load_timeline)
    {
        auto v = make_unique<ValueTimeLineUnit>();
        v->CopyFromAnotherVTLU(e.get());
        this->m_passive_alarm_load_timeline.push_back(std::move(v));
    }
}